├── src
    └── lib.rs
├── .gitignore
├── aave-v3
    ├── src
    │   ├── lib.rs
    │   └── contracts
    │   │   ├── context.rs
    │   │   ├── proxy.rs
    │   │   ├── versioned_initializable.rs
    │   │   ├── i_delegation_token.rs
    │   │   ├── erc165.rs
    │   │   ├── ierc165.rs
    │   │   ├── mod.rs
    │   │   ├── flash_loan_logic.rs
    │   │   ├── i_sequencer_oracle.rs
    │   │   ├── pool_storage.rs
    │   │   ├── address.rs
    │   │   ├── helpers.rs
    │   │   ├── strings.rs
    │   │   ├── safe_cast.rs
    │   │   ├── safe_math.rs
    │   │   ├── initializable.rs
    │   │   ├── data_types.rs
    │   │   ├── math_utils.rs
    │   │   ├── wad_ray_math.rs
    │   │   ├── generic_logic.rs
    │   │   ├── calldata_logic.rs
    │   │   ├── g_pv_2_safe_erc20.rs
    │   │   ├── percentage_math.rs
    │   │   ├── user_configuration.rs
    │   │   ├── shared_types.rs
    │   │   ├── configurator_input_types.rs
    │   │   ├── selfdestruct_transfer.rs
    │   │   ├── base_upgradeability_proxy.rs
    │   │   ├── isolation_mode_logic.rs
    │   │   ├── reserve_logic.rs
    │   │   └── i_price_oracle.rs
    ├── Cargo.toml
    └── build.rs
├── compound
    ├── src
    │   ├── lib.rs
    │   └── contracts
    │   │   ├── mod.rs
    │   │   ├── comp_interface.rs
    │   │   ├── v1_price_oracle_interface.rs
    │   │   ├── exponential.rs
    │   │   ├── careful_math.rs
    │   │   ├── safe_math.rs
    │   │   ├── token_error_reporter.rs
    │   │   ├── c_erc_20_storage.rs
    │   │   ├── comptroller_error_reporter.rs
    │   │   ├── vat_like.rs
    │   │   └── c_delegation_storage.rs
    ├── Cargo.toml
    └── build.rs
├── template
    ├── src
    │   ├── contracts
    │   │   └── mod.rs
    │   └── lib.rs
    ├── Cargo.toml
    └── build.rs
├── uniswap-v3-periphery
    ├── src
    │   └── lib.rs
    ├── Cargo.toml
    └── build.rs
├── Cargo.toml
├── .github
    └── workflows
    │   └── ci.yml
└── README.md


/src/lib.rs:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | target/
2 | 


--------------------------------------------------------------------------------
/aave-v3/src/lib.rs:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/compound/src/lib.rs:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/template/src/contracts/mod.rs:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/uniswap-v3-periphery/src/lib.rs:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/template/src/lib.rs:
--------------------------------------------------------------------------------
1 | #![allow(clippy::all)]
2 | #![allow(non_camel_case_types)]
3 | 
4 | mod contracts;
5 | pub use contracts::*;


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "defi-bindings"
 3 | version = "0.2.0"
 4 | edition = "2021"
 5 | 
 6 | [workspace]
 7 | members = [
 8 |     "aave-v3",
 9 |     "compound",
10 |     "uniswap-v3-periphery",
11 | ]


--------------------------------------------------------------------------------
/uniswap-v3-periphery/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "uniswap-v3-periphery-bindings"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | [dependencies]
 7 | ethers = { git = "https://github.com/gakonst/ethers-rs", features = ["abigen"] }
 8 | serde_json = "1.0"
 9 | 
10 | [build-dependencies]
11 | foundry-binder = { git = "https://github.com/foundry-rs/foundry" }


--------------------------------------------------------------------------------
/template/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "template-bindings"
 3 | version = "0.2.0"
 4 | edition = "2021"
 5 | description = """
 6 | Rust bindings for <template>
 7 | """
 8 | 
 9 | [dependencies]
10 | ethers = { git = "https://github.com/gakonst/ethers-rs", features = ["abigen"] }
11 | 
12 | [build-dependencies]
13 | foundry-binder = { git = "https://github.com/foundry-rs/foundry" }


--------------------------------------------------------------------------------
/aave-v3/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "aave-v3-bindings"
 3 | version = "0.2.0"
 4 | edition = "2021"
 5 | description = """
 6 | Rust bindings for https://github.com/aave/aave-v3-core
 7 | """
 8 | 
 9 | [dependencies]
10 | ethers = { git = "https://github.com/gakonst/ethers-rs", features = ["abigen"] }
11 | 
12 | [build-dependencies]
13 | foundry-binder = { git = "https://github.com/foundry-rs/foundry" }


--------------------------------------------------------------------------------
/compound/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "compound-bindings"
 3 | version = "0.2.0"
 4 | edition = "2021"
 5 | description = """
 6 | Rust bindings for https://github.com/compound-finance/compound-protocol
 7 | """
 8 | 
 9 | [dependencies]
10 | ethers = { git = "https://github.com/gakonst/ethers-rs", features = ["abigen"] }
11 | 
12 | [build-dependencies]
13 | foundry-binder = { git = "https://github.com/foundry-rs/foundry" }


--------------------------------------------------------------------------------
/uniswap-v3-periphery/build.rs:
--------------------------------------------------------------------------------
 1 | //! Generates the bindings
 2 | use foundry_binder::{Binder, RepositoryBuilder, Url};
 3 | 
 4 | // github repository url
 5 | const REPO_URL: &str = "https://github.com/Uniswap/v3-periphery";
 6 | 
 7 | // the release tag for which to generate bindings for
 8 | const RELEASE_TAG: &str = "v1.3.0";
 9 | 
10 | fn generate() {
11 |     let binder =
12 |         Binder::new(RepositoryBuilder::new(Url::parse(REPO_URL).unwrap()).tag(RELEASE_TAG));
13 | 
14 |     binder.generate().expect("Failed to generate bindings")
15 | }
16 | 
17 | fn main() {
18 |     // only generate if `FRESH_BINDINGS` env var is set
19 |     if std::env::var("FRESH_BINDINGS").is_ok() {
20 |         generate()
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/aave-v3/build.rs:
--------------------------------------------------------------------------------
 1 | //! Generates the bindings
 2 | use foundry_binder::{Binder, RepositoryBuilder, Url};
 3 | 
 4 | // github repository url
 5 | const REPO_URL: &str = "https://github.com/aave/aave-v3-core";
 6 | 
 7 | // the release tag for which to generate bindings for
 8 | const RELEASE_TAG: &str = "v1.16.2";
 9 | 
10 | fn generate() {
11 |     let binder =
12 |         Binder::new(RepositoryBuilder::new(Url::parse(REPO_URL).unwrap()).tag(RELEASE_TAG))
13 |             .command(["yarn", "install"]);
14 | 
15 |     binder.generate().expect("Failed to generate bindings")
16 | }
17 | 
18 | fn main() {
19 |     // only generate if `FRESH_BINDINGS` env var is set
20 |     if std::env::var("FRESH_BINDINGS").is_ok() {
21 |         generate()
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/compound/build.rs:
--------------------------------------------------------------------------------
 1 | //! Generates the bindings
 2 | use foundry_binder::{Binder, RepositoryBuilder, Url};
 3 | 
 4 | // github repository url
 5 | const REPO_URL: &str = "https://github.com/compound-finance/compound-protocol";
 6 | 
 7 | // the release tag for which to generate bindings for
 8 | const RELEASE_TAG: &str = "v2.8.1";
 9 | 
10 | fn generate() {
11 |     let binder =
12 |         Binder::new(RepositoryBuilder::new(Url::parse(REPO_URL).unwrap()).tag(RELEASE_TAG))
13 |             .command(["yarn", "install"]);
14 | 
15 |     binder.generate().expect("Failed to generate bindings")
16 | }
17 | 
18 | fn main() {
19 |     // only generate if `FRESH_BINDINGS` env var is set
20 |     if std::env::var("FRESH_BINDINGS").is_ok() {
21 |         generate()
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/template/build.rs:
--------------------------------------------------------------------------------
 1 | //! Generates the bindings
 2 | use foundry_binder::{Binder, RepositoryBuilder, Url};
 3 | 
 4 | // github repository url
 5 | const REPO_URL: &str = "<the-url-of-the-project>";
 6 | 
 7 | // the release tag for which to generate bindings for
 8 | const RELEASE_TAG: &str = "v3.0.0";
 9 | 
10 | fn generate() {
11 |     let binder =
12 |         Binder::new(RepositoryBuilder::new(Url::parse(REPO_URL).unwrap())
13 |             // generate bindings for this release tag
14 |             // if not set, then the default branch will be used
15 |             .tag(RELEASE_TAG))
16 |             // keep build artifacts in `artifacts` folder
17 |             .keep_artifacts("artifacts");
18 | 
19 |     binder.generate().expect("Failed to generate bindings")
20 | }
21 | 
22 | fn main() {
23 |     // only generate if `FRESH_BINDINGS` env var is set
24 |     if std::env::var("FRESH_BINDINGS").is_ok() {
25 |         generate()
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | on: [push, pull_request]
 2 | 
 3 | name: CI
 4 | 
 5 | jobs:
 6 |   check:
 7 |     name: Check
 8 |     runs-on: ubuntu-latest
 9 |     steps:
10 |       - uses: actions/checkout@v2
11 |       - uses: actions-rs/toolchain@v1
12 |         with:
13 |           profile: minimal
14 |           toolchain: stable
15 |           override: true
16 |       - uses: actions-rs/cargo@v1
17 |         with:
18 |           command: check
19 | 
20 |   test:
21 |     name: Test Suite
22 |     runs-on: ubuntu-latest
23 |     steps:
24 |       - uses: actions/checkout@v2
25 |       - uses: actions-rs/toolchain@v1
26 |         with:
27 |           profile: minimal
28 |           toolchain: stable
29 |           override: true
30 |       - uses: actions-rs/cargo@v1
31 |         with:
32 |           command: test
33 | 
34 |   fmt:
35 |     name: Rustfmt
36 |     runs-on: ubuntu-latest
37 |     steps:
38 |       - uses: actions/checkout@v2
39 |       - uses: actions-rs/toolchain@v1
40 |         with:
41 |           profile: minimal
42 |           toolchain: nightly
43 |           override: true
44 |       - run: rustup component add rustfmt
45 |       - uses: actions-rs/cargo@v1
46 |         with:
47 |           command: fmt
48 |           args: --all -- --check


--------------------------------------------------------------------------------
/compound/src/contracts/mod.rs:
--------------------------------------------------------------------------------
 1 | #![allow(clippy::all)]
 2 | //! This module contains abigen! generated bindings for solidity contracts.
 3 | //! This is autogenerated code.
 4 | //! Do not manually edit these files.
 5 | //! These files may be overwritten by the codegen system at any time.
 6 | pub mod c_dai_delegate;
 7 | pub mod c_delegate_interface;
 8 | pub mod c_delegation_storage;
 9 | pub mod c_delegator_interface;
10 | pub mod c_erc_20;
11 | pub mod c_erc_20_delegate;
12 | pub mod c_erc_20_delegator;
13 | pub mod c_erc_20_immutable;
14 | pub mod c_erc_20_interface;
15 | pub mod c_erc_20_storage;
16 | pub mod c_ether;
17 | pub mod c_token;
18 | pub mod c_token_interface;
19 | pub mod c_token_storage;
20 | pub mod careful_math;
21 | pub mod comp;
22 | pub mod comp_interface;
23 | pub mod compound_lens;
24 | pub mod comptroller;
25 | pub mod comptroller_error_reporter;
26 | pub mod comptroller_g1;
27 | pub mod comptroller_g2;
28 | pub mod comptroller_g3;
29 | pub mod comptroller_interface;
30 | pub mod comptroller_lens_interface;
31 | pub mod comptroller_v1_storage;
32 | pub mod comptroller_v2_storage;
33 | pub mod comptroller_v3_storage;
34 | pub mod dai_interest_rate_model_v2;
35 | pub mod dai_join_like;
36 | pub mod eip20_interface;
37 | pub mod eip20_non_standard_interface;
38 | pub mod exponential;
39 | pub mod gem_like;
40 | pub mod governor_alpha;
41 | pub mod interest_rate_model;
42 | pub mod jug_like;
43 | pub mod jump_rate_model;
44 | pub mod maximillion;
45 | pub mod pot_like;
46 | pub mod price_oracle;
47 | pub mod price_oracle_proxy;
48 | pub mod reservoir;
49 | pub mod safe_math;
50 | pub mod simple_price_oracle;
51 | pub mod timelock;
52 | pub mod timelock_interface;
53 | pub mod token_error_reporter;
54 | pub mod unitroller;
55 | pub mod unitroller_admin_storage;
56 | pub mod v1_price_oracle_interface;
57 | pub mod vat_like;
58 | pub mod white_paper_interest_rate_model;
59 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/context.rs:
--------------------------------------------------------------------------------
 1 | pub use context::*;
 2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
 3 | pub mod context {
 4 |     #![allow(clippy::enum_variant_names)]
 5 |     #![allow(dead_code)]
 6 |     #![allow(clippy::type_complexity)]
 7 |     #![allow(unused_imports)]
 8 |     use ethers::contract::{
 9 |         builders::{ContractCall, Event},
10 |         Contract, Lazy,
11 |     };
12 |     use ethers::core::{
13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
14 |         types::*,
15 |     };
16 |     use ethers::providers::Middleware;
17 |     #[doc = "Context was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
18 |     use std::sync::Arc;
19 |     pub static CONTEXT_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
20 |         ethers::contract::Lazy::new(|| {
21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
22 |         });
23 |     pub struct Context<M>(ethers::contract::Contract<M>);
24 |     impl<M> Clone for Context<M> {
25 |         fn clone(&self) -> Self {
26 |             Context(self.0.clone())
27 |         }
28 |     }
29 |     impl<M> std::ops::Deref for Context<M> {
30 |         type Target = ethers::contract::Contract<M>;
31 |         fn deref(&self) -> &Self::Target {
32 |             &self.0
33 |         }
34 |     }
35 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for Context<M> {
36 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
37 |             f.debug_tuple(stringify!(Context))
38 |                 .field(&self.address())
39 |                 .finish()
40 |         }
41 |     }
42 |     impl<M: ethers::providers::Middleware> Context<M> {
43 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
44 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
45 |         #[doc = r" object"]
46 |         pub fn new<T: Into<ethers::core::types::Address>>(
47 |             address: T,
48 |             client: ::std::sync::Arc<M>,
49 |         ) -> Self {
50 |             ethers::contract::Contract::new(address.into(), CONTEXT_ABI.clone(), client).into()
51 |         }
52 |     }
53 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for Context<M> {
54 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
55 |             Self(contract)
56 |         }
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # defi-bindings
 2 | 
 3 | Contains various [ethers-rs](https://github.com/gakonst/ethers-rs) rust bindings of defi projects generated with [foundry-binder](https://github.com/gakonst/foundry/tree/master/binder).
 4 | 
 5 | ## Use the bindings
 6 | 
 7 | Import directly from this repo
 8 | 
 9 | ```toml
10 | uniswap-v3-periphery-bindings = { git = "https://github.com/mattsse/defi-bindings" }
11 | ```
12 | 
13 | ## Generate your own
14 | 
15 | You can the [`./template`](template) crate as base.
16 | 
17 | which has following deps in its `Cargo.toml`
18 | 
19 | ```toml
20 | [dependencies]
21 | ethers = { git = "https://github.com/gakonst/ethers-rs", features = ["abigen"] }
22 | 
23 | [build-dependencies]
24 | foundry-binder = { git = "https://github.com/gakonst/foundry" }
25 | ```
26 | 
27 | In the `build.rs` file, you must configure which project you want to check out, build, and generate bindings for.
28 | 
29 | ```rust
30 | use foundry_binder::{Binder, RepositoryBuilder, Url};
31 | 
32 | // github repository url
33 | const REPO_URL: &str = "<the-url-of-the-project>";
34 | 
35 | // the release tag for which to generate bindings for
36 | const RELEASE_TAG: &str = "v3.0.0";
37 | 
38 | /// This clones the project, builds the project and generates rust bindings
39 | fn generate() {
40 |     let binder =
41 |         Binder::new(RepositoryBuilder::new(Url::parse(REPO_URL).unwrap())
42 |             // generate bindings for this release tag
43 |             // if not set, then the default branch will be used
44 |             .tag(RELEASE_TAG))
45 |             // keep build artifacts in `artifacts` folder
46 |             .keep_artifacts("artifacts");
47 | 
48 |     binder.generate().expect("Failed to generate bindings")
49 | }
50 | 
51 | fn main() {
52 |     // only generate if `FRESH_BINDINGS` env var is set
53 |     if std::env::var("FRESH_BINDINGS").is_ok() {
54 |         generate()
55 |     }
56 | }
57 | ```
58 | 
59 | To build the project, simply run `cargo build` which executes the `build.rs`. Afterwards, if everything succeeded, the bindings are written to `src/contracts`.
60 | The `FRESH_BINDINGS` ensures that these steps are not executed on each new `cargo build`.
61 | 
62 | ```shell
63 | FRESH_BINDINGS="" cargo build
64 | ```
65 | 
66 | 
67 | ## License
68 | 
69 | Licensed under either of these:
70 | 
71 | * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
72 |   https://www.apache.org/licenses/LICENSE-2.0)
73 | * MIT license ([LICENSE-MIT](LICENSE-MIT) or
74 |   https://opensource.org/licenses/MIT)
75 |    
76 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/proxy.rs:
--------------------------------------------------------------------------------
 1 | pub use proxy::*;
 2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
 3 | pub mod proxy {
 4 |     #![allow(clippy::enum_variant_names)]
 5 |     #![allow(dead_code)]
 6 |     #![allow(clippy::type_complexity)]
 7 |     #![allow(unused_imports)]
 8 |     use ethers::contract::{
 9 |         builders::{ContractCall, Event},
10 |         Contract, Lazy,
11 |     };
12 |     use ethers::core::{
13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
14 |         types::*,
15 |     };
16 |     use ethers::providers::Middleware;
17 |     #[doc = "Proxy was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
18 |     use std::sync::Arc;
19 |     pub static PROXY_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
20 |         ethers::contract::Lazy::new(|| {
21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[],\"stateMutability\":\"payable\",\"type\":\"fallback\",\"outputs\":[]}]") . expect ("invalid abi")
22 |         });
23 |     pub struct Proxy<M>(ethers::contract::Contract<M>);
24 |     impl<M> Clone for Proxy<M> {
25 |         fn clone(&self) -> Self {
26 |             Proxy(self.0.clone())
27 |         }
28 |     }
29 |     impl<M> std::ops::Deref for Proxy<M> {
30 |         type Target = ethers::contract::Contract<M>;
31 |         fn deref(&self) -> &Self::Target {
32 |             &self.0
33 |         }
34 |     }
35 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for Proxy<M> {
36 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
37 |             f.debug_tuple(stringify!(Proxy))
38 |                 .field(&self.address())
39 |                 .finish()
40 |         }
41 |     }
42 |     impl<M: ethers::providers::Middleware> Proxy<M> {
43 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
44 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
45 |         #[doc = r" object"]
46 |         pub fn new<T: Into<ethers::core::types::Address>>(
47 |             address: T,
48 |             client: ::std::sync::Arc<M>,
49 |         ) -> Self {
50 |             ethers::contract::Contract::new(address.into(), PROXY_ABI.clone(), client).into()
51 |         }
52 |     }
53 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for Proxy<M> {
54 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
55 |             Self(contract)
56 |         }
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/versioned_initializable.rs:
--------------------------------------------------------------------------------
 1 | pub use versioned_initializable::*;
 2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
 3 | pub mod versioned_initializable {
 4 |     #![allow(clippy::enum_variant_names)]
 5 |     #![allow(dead_code)]
 6 |     #![allow(clippy::type_complexity)]
 7 |     #![allow(unused_imports)]
 8 |     use ethers::contract::{
 9 |         builders::{ContractCall, Event},
10 |         Contract, Lazy,
11 |     };
12 |     use ethers::core::{
13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
14 |         types::*,
15 |     };
16 |     use ethers::providers::Middleware;
17 |     #[doc = "VersionedInitializable was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
18 |     use std::sync::Arc;
19 |     pub static VERSIONEDINITIALIZABLE_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
20 |         ethers::contract::Lazy::new(|| {
21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
22 |         });
23 |     pub struct VersionedInitializable<M>(ethers::contract::Contract<M>);
24 |     impl<M> Clone for VersionedInitializable<M> {
25 |         fn clone(&self) -> Self {
26 |             VersionedInitializable(self.0.clone())
27 |         }
28 |     }
29 |     impl<M> std::ops::Deref for VersionedInitializable<M> {
30 |         type Target = ethers::contract::Contract<M>;
31 |         fn deref(&self) -> &Self::Target {
32 |             &self.0
33 |         }
34 |     }
35 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for VersionedInitializable<M> {
36 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
37 |             f.debug_tuple(stringify!(VersionedInitializable))
38 |                 .field(&self.address())
39 |                 .finish()
40 |         }
41 |     }
42 |     impl<M: ethers::providers::Middleware> VersionedInitializable<M> {
43 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
44 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
45 |         #[doc = r" object"]
46 |         pub fn new<T: Into<ethers::core::types::Address>>(
47 |             address: T,
48 |             client: ::std::sync::Arc<M>,
49 |         ) -> Self {
50 |             ethers::contract::Contract::new(
51 |                 address.into(),
52 |                 VERSIONEDINITIALIZABLE_ABI.clone(),
53 |                 client,
54 |             )
55 |             .into()
56 |         }
57 |     }
58 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>>
59 |         for VersionedInitializable<M>
60 |     {
61 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
62 |             Self(contract)
63 |         }
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/i_delegation_token.rs:
--------------------------------------------------------------------------------
 1 | pub use i_delegation_token::*;
 2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
 3 | pub mod i_delegation_token {
 4 |     #![allow(clippy::enum_variant_names)]
 5 |     #![allow(dead_code)]
 6 |     #![allow(clippy::type_complexity)]
 7 |     #![allow(unused_imports)]
 8 |     use ethers::contract::{
 9 |         builders::{ContractCall, Event},
10 |         Contract, Lazy,
11 |     };
12 |     use ethers::core::{
13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
14 |         types::*,
15 |     };
16 |     use ethers::providers::Middleware;
17 |     #[doc = "IDelegationToken was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
18 |     use std::sync::Arc;
19 |     pub static IDELEGATIONTOKEN_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
20 |         ethers::contract::Lazy::new(|| {
21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"delegatee\",\"type\":\"address\",\"components\":[]}],\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"delegate\",\"outputs\":[]}]") . expect ("invalid abi")
22 |         });
23 |     pub struct IDelegationToken<M>(ethers::contract::Contract<M>);
24 |     impl<M> Clone for IDelegationToken<M> {
25 |         fn clone(&self) -> Self {
26 |             IDelegationToken(self.0.clone())
27 |         }
28 |     }
29 |     impl<M> std::ops::Deref for IDelegationToken<M> {
30 |         type Target = ethers::contract::Contract<M>;
31 |         fn deref(&self) -> &Self::Target {
32 |             &self.0
33 |         }
34 |     }
35 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for IDelegationToken<M> {
36 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
37 |             f.debug_tuple(stringify!(IDelegationToken))
38 |                 .field(&self.address())
39 |                 .finish()
40 |         }
41 |     }
42 |     impl<M: ethers::providers::Middleware> IDelegationToken<M> {
43 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
44 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
45 |         #[doc = r" object"]
46 |         pub fn new<T: Into<ethers::core::types::Address>>(
47 |             address: T,
48 |             client: ::std::sync::Arc<M>,
49 |         ) -> Self {
50 |             ethers::contract::Contract::new(address.into(), IDELEGATIONTOKEN_ABI.clone(), client)
51 |                 .into()
52 |         }
53 |         #[doc = "Calls the contract's `delegate` (0x5c19a95c) function"]
54 |         pub fn delegate(
55 |             &self,
56 |             delegatee: ethers::core::types::Address,
57 |         ) -> ethers::contract::builders::ContractCall<M, ()> {
58 |             self.0
59 |                 .method_hash([92, 25, 169, 92], delegatee)
60 |                 .expect("method not found (this should never happen)")
61 |         }
62 |     }
63 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for IDelegationToken<M> {
64 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
65 |             Self(contract)
66 |         }
67 |     }
68 |     #[doc = "Container type for all input parameters for the `delegate` function with signature `delegate(address)` and selector `[92, 25, 169, 92]`"]
69 |     #[derive(
70 |         Clone,
71 |         Debug,
72 |         Default,
73 |         Eq,
74 |         PartialEq,
75 |         ethers :: contract :: EthCall,
76 |         ethers :: contract :: EthDisplay,
77 |     )]
78 |     #[ethcall(name = "delegate", abi = "delegate(address)")]
79 |     pub struct DelegateCall {
80 |         pub delegatee: ethers::core::types::Address,
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/erc165.rs:
--------------------------------------------------------------------------------
 1 | pub use erc165::*;
 2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
 3 | pub mod erc165 {
 4 |     #![allow(clippy::enum_variant_names)]
 5 |     #![allow(dead_code)]
 6 |     #![allow(clippy::type_complexity)]
 7 |     #![allow(unused_imports)]
 8 |     use ethers::contract::{
 9 |         builders::{ContractCall, Event},
10 |         Contract, Lazy,
11 |     };
12 |     use ethers::core::{
13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
14 |         types::*,
15 |     };
16 |     use ethers::providers::Middleware;
17 |     #[doc = "ERC165 was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
18 |     use std::sync::Arc;
19 |     pub static ERC165_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
20 |         ethers::contract::Lazy::new(|| {
21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\",\"components\":[]}],\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\",\"components\":[]}]}]") . expect ("invalid abi")
22 |         });
23 |     pub struct ERC165<M>(ethers::contract::Contract<M>);
24 |     impl<M> Clone for ERC165<M> {
25 |         fn clone(&self) -> Self {
26 |             ERC165(self.0.clone())
27 |         }
28 |     }
29 |     impl<M> std::ops::Deref for ERC165<M> {
30 |         type Target = ethers::contract::Contract<M>;
31 |         fn deref(&self) -> &Self::Target {
32 |             &self.0
33 |         }
34 |     }
35 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for ERC165<M> {
36 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
37 |             f.debug_tuple(stringify!(ERC165))
38 |                 .field(&self.address())
39 |                 .finish()
40 |         }
41 |     }
42 |     impl<M: ethers::providers::Middleware> ERC165<M> {
43 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
44 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
45 |         #[doc = r" object"]
46 |         pub fn new<T: Into<ethers::core::types::Address>>(
47 |             address: T,
48 |             client: ::std::sync::Arc<M>,
49 |         ) -> Self {
50 |             ethers::contract::Contract::new(address.into(), ERC165_ABI.clone(), client).into()
51 |         }
52 |         #[doc = "Calls the contract's `supportsInterface` (0x01ffc9a7) function"]
53 |         pub fn supports_interface(
54 |             &self,
55 |             interface_id: [u8; 4],
56 |         ) -> ethers::contract::builders::ContractCall<M, bool> {
57 |             self.0
58 |                 .method_hash([1, 255, 201, 167], interface_id)
59 |                 .expect("method not found (this should never happen)")
60 |         }
61 |     }
62 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for ERC165<M> {
63 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
64 |             Self(contract)
65 |         }
66 |     }
67 |     #[doc = "Container type for all input parameters for the `supportsInterface` function with signature `supportsInterface(bytes4)` and selector `[1, 255, 201, 167]`"]
68 |     #[derive(
69 |         Clone,
70 |         Debug,
71 |         Default,
72 |         Eq,
73 |         PartialEq,
74 |         ethers :: contract :: EthCall,
75 |         ethers :: contract :: EthDisplay,
76 |     )]
77 |     #[ethcall(name = "supportsInterface", abi = "supportsInterface(bytes4)")]
78 |     pub struct SupportsInterfaceCall {
79 |         pub interface_id: [u8; 4],
80 |     }
81 |     #[doc = "Container type for all return fields from the `supportsInterface` function with signature `supportsInterface(bytes4)` and selector `[1, 255, 201, 167]`"]
82 |     #[derive(
83 |         Clone,
84 |         Debug,
85 |         Default,
86 |         Eq,
87 |         PartialEq,
88 |         ethers :: contract :: EthAbiType,
89 |         ethers :: contract :: EthAbiCodec,
90 |     )]
91 |     pub struct SupportsInterfaceReturn(pub bool);
92 | }
93 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/ierc165.rs:
--------------------------------------------------------------------------------
 1 | pub use ierc165::*;
 2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
 3 | pub mod ierc165 {
 4 |     #![allow(clippy::enum_variant_names)]
 5 |     #![allow(dead_code)]
 6 |     #![allow(clippy::type_complexity)]
 7 |     #![allow(unused_imports)]
 8 |     use ethers::contract::{
 9 |         builders::{ContractCall, Event},
10 |         Contract, Lazy,
11 |     };
12 |     use ethers::core::{
13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
14 |         types::*,
15 |     };
16 |     use ethers::providers::Middleware;
17 |     #[doc = "IERC165 was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
18 |     use std::sync::Arc;
19 |     pub static IERC165_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
20 |         ethers::contract::Lazy::new(|| {
21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\",\"components\":[]}],\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\",\"components\":[]}]}]") . expect ("invalid abi")
22 |         });
23 |     pub struct IERC165<M>(ethers::contract::Contract<M>);
24 |     impl<M> Clone for IERC165<M> {
25 |         fn clone(&self) -> Self {
26 |             IERC165(self.0.clone())
27 |         }
28 |     }
29 |     impl<M> std::ops::Deref for IERC165<M> {
30 |         type Target = ethers::contract::Contract<M>;
31 |         fn deref(&self) -> &Self::Target {
32 |             &self.0
33 |         }
34 |     }
35 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for IERC165<M> {
36 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
37 |             f.debug_tuple(stringify!(IERC165))
38 |                 .field(&self.address())
39 |                 .finish()
40 |         }
41 |     }
42 |     impl<M: ethers::providers::Middleware> IERC165<M> {
43 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
44 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
45 |         #[doc = r" object"]
46 |         pub fn new<T: Into<ethers::core::types::Address>>(
47 |             address: T,
48 |             client: ::std::sync::Arc<M>,
49 |         ) -> Self {
50 |             ethers::contract::Contract::new(address.into(), IERC165_ABI.clone(), client).into()
51 |         }
52 |         #[doc = "Calls the contract's `supportsInterface` (0x01ffc9a7) function"]
53 |         pub fn supports_interface(
54 |             &self,
55 |             interface_id: [u8; 4],
56 |         ) -> ethers::contract::builders::ContractCall<M, bool> {
57 |             self.0
58 |                 .method_hash([1, 255, 201, 167], interface_id)
59 |                 .expect("method not found (this should never happen)")
60 |         }
61 |     }
62 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for IERC165<M> {
63 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
64 |             Self(contract)
65 |         }
66 |     }
67 |     #[doc = "Container type for all input parameters for the `supportsInterface` function with signature `supportsInterface(bytes4)` and selector `[1, 255, 201, 167]`"]
68 |     #[derive(
69 |         Clone,
70 |         Debug,
71 |         Default,
72 |         Eq,
73 |         PartialEq,
74 |         ethers :: contract :: EthCall,
75 |         ethers :: contract :: EthDisplay,
76 |     )]
77 |     #[ethcall(name = "supportsInterface", abi = "supportsInterface(bytes4)")]
78 |     pub struct SupportsInterfaceCall {
79 |         pub interface_id: [u8; 4],
80 |     }
81 |     #[doc = "Container type for all return fields from the `supportsInterface` function with signature `supportsInterface(bytes4)` and selector `[1, 255, 201, 167]`"]
82 |     #[derive(
83 |         Clone,
84 |         Debug,
85 |         Default,
86 |         Eq,
87 |         PartialEq,
88 |         ethers :: contract :: EthAbiType,
89 |         ethers :: contract :: EthAbiCodec,
90 |     )]
91 |     pub struct SupportsInterfaceReturn(pub bool);
92 | }
93 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/mod.rs:
--------------------------------------------------------------------------------
  1 | #![allow(clippy::all)]
  2 | //! This module contains abigen! generated bindings for solidity contracts.
  3 | //! This is autogenerated code.
  4 | //! Do not manually edit these files.
  5 | //! These files may be overwritten by the codegen system at any time.
  6 | pub mod a_token;
  7 | pub mod aave_oracle;
  8 | pub mod aave_protocol_data_provider;
  9 | pub mod access_control;
 10 | pub mod acl_manager;
 11 | pub mod address;
 12 | pub mod admin_upgradeability_proxy;
 13 | pub mod aggregator_interface;
 14 | pub mod base_admin_upgradeability_proxy;
 15 | pub mod base_immutable_admin_upgradeability_proxy;
 16 | pub mod base_upgradeability_proxy;
 17 | pub mod borrow_logic;
 18 | pub mod bridge_logic;
 19 | pub mod calldata_logic;
 20 | pub mod configurator_input_types;
 21 | pub mod configurator_logic;
 22 | pub mod context;
 23 | pub mod data_types;
 24 | pub mod debt_token_base;
 25 | pub mod default_reserve_interest_rate_strategy;
 26 | pub mod delegation_aware_a_token;
 27 | pub mod e_mode_logic;
 28 | pub mod eip712_base;
 29 | pub mod erc165;
 30 | pub mod erc20;
 31 | pub mod errors;
 32 | pub mod flash_loan_logic;
 33 | pub mod flash_loan_receiver_base;
 34 | pub mod flash_loan_simple_receiver_base;
 35 | pub mod flashloan_attacker;
 36 | pub mod g_pv_2_safe_erc20;
 37 | pub mod generic_logic;
 38 | pub mod helpers;
 39 | pub mod i_aave_incentives_controller;
 40 | pub mod i_aave_oracle;
 41 | pub mod i_access_control;
 42 | pub mod i_credit_delegation_token;
 43 | pub mod i_delegation_token;
 44 | pub mod i_flash_loan_receiver;
 45 | pub mod i_flash_loan_simple_receiver;
 46 | pub mod i_initializable_a_token;
 47 | pub mod i_initializable_debt_token;
 48 | pub mod i_pool;
 49 | pub mod i_pool_addresses_provider;
 50 | pub mod i_pool_addresses_provider_registry;
 51 | pub mod i_pool_configurator;
 52 | pub mod i_pool_data_provider;
 53 | pub mod i_price_oracle;
 54 | pub mod i_price_oracle_getter;
 55 | pub mod i_price_oracle_sentinel;
 56 | pub mod i_reserve_interest_rate_strategy;
 57 | pub mod i_scaled_balance_token;
 58 | pub mod i_sequencer_oracle;
 59 | pub mod i_stable_debt_token;
 60 | pub mod i_variable_debt_token;
 61 | pub mod ia_token;
 62 | pub mod iacl_manager;
 63 | pub mod ierc165;
 64 | pub mod ierc20;
 65 | pub mod ierc20_detailed;
 66 | pub mod ierc20_with_permit;
 67 | pub mod il2_pool;
 68 | pub mod incentivized_erc20;
 69 | pub mod initializable;
 70 | pub mod initializable_admin_upgradeability_proxy;
 71 | pub mod initializable_immutable_admin_upgradeability_proxy;
 72 | pub mod initializable_upgradeability_proxy;
 73 | pub mod isolation_mode_logic;
 74 | pub mod iweth;
 75 | pub mod l2_encoder;
 76 | pub mod l2_pool;
 77 | pub mod liquidation_logic;
 78 | pub mod math_utils;
 79 | pub mod mintable_delegation_erc20;
 80 | pub mod mintable_erc20;
 81 | pub mod mintable_incentivized_erc20;
 82 | pub mod mock_a_token;
 83 | pub mod mock_aggregator;
 84 | pub mod mock_flash_loan_receiver;
 85 | pub mod mock_flash_loan_simple_receiver;
 86 | pub mod mock_incentives_controller;
 87 | pub mod mock_initializable_from_constructor_imple;
 88 | pub mod mock_initializable_imple;
 89 | pub mod mock_initializable_imple_v2;
 90 | pub mod mock_l2_pool;
 91 | pub mod mock_periphery_contract_v1;
 92 | pub mod mock_periphery_contract_v2;
 93 | pub mod mock_pool;
 94 | pub mod mock_pool_inherited;
 95 | pub mod mock_reentrant_initializable_imple;
 96 | pub mod mock_reserve_configuration;
 97 | pub mod mock_reserve_interest_rate_strategy;
 98 | pub mod mock_stable_debt_token;
 99 | pub mod mock_variable_debt_token;
100 | pub mod ownable;
101 | pub mod percentage_math;
102 | pub mod pool;
103 | pub mod pool_addresses_provider;
104 | pub mod pool_addresses_provider_registry;
105 | pub mod pool_configurator;
106 | pub mod pool_logic;
107 | pub mod pool_storage;
108 | pub mod price_oracle;
109 | pub mod price_oracle_sentinel;
110 | pub mod proxy;
111 | pub mod reserve_configuration;
112 | pub mod reserve_logic;
113 | pub mod reserves_setup_helper;
114 | pub mod safe_cast;
115 | pub mod safe_math;
116 | pub mod scaled_balance_token_base;
117 | pub mod selfdestruct_transfer;
118 | pub mod sequencer_oracle;
119 | pub mod shared_types;
120 | pub mod stable_debt_token;
121 | pub mod strings;
122 | pub mod supply_logic;
123 | pub mod upgradeability_proxy;
124 | pub mod user_configuration;
125 | pub mod validation_logic;
126 | pub mod variable_debt_token;
127 | pub mod versioned_initializable;
128 | pub mod wad_ray_math;
129 | pub mod wad_ray_math_wrapper;
130 | pub mod weth9;
131 | pub mod weth9_mocked;
132 | 


--------------------------------------------------------------------------------
/compound/src/contracts/comp_interface.rs:
--------------------------------------------------------------------------------
 1 | pub use comp_interface::*;
 2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
 3 | pub mod comp_interface {
 4 |     #![allow(clippy::enum_variant_names)]
 5 |     #![allow(dead_code)]
 6 |     #![allow(clippy::type_complexity)]
 7 |     #![allow(unused_imports)]
 8 |     use ethers::contract::{
 9 |         builders::{ContractCall, Event},
10 |         Contract, Lazy,
11 |     };
12 |     use ethers::core::{
13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
14 |         types::*,
15 |     };
16 |     use ethers::providers::Middleware;
17 |     #[doc = "CompInterface was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
18 |     use std::sync::Arc;
19 |     pub static COMPINTERFACE_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
20 |         ethers::contract::Lazy::new(|| {
21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\",\"components\":[]},{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\",\"components\":[]}],\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"getPriorVotes\",\"outputs\":[{\"internalType\":\"uint96\",\"name\":\"\",\"type\":\"uint96\",\"components\":[]}]}]") . expect ("invalid abi")
22 |         });
23 |     pub struct CompInterface<M>(ethers::contract::Contract<M>);
24 |     impl<M> Clone for CompInterface<M> {
25 |         fn clone(&self) -> Self {
26 |             CompInterface(self.0.clone())
27 |         }
28 |     }
29 |     impl<M> std::ops::Deref for CompInterface<M> {
30 |         type Target = ethers::contract::Contract<M>;
31 |         fn deref(&self) -> &Self::Target {
32 |             &self.0
33 |         }
34 |     }
35 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for CompInterface<M> {
36 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
37 |             f.debug_tuple(stringify!(CompInterface))
38 |                 .field(&self.address())
39 |                 .finish()
40 |         }
41 |     }
42 |     impl<M: ethers::providers::Middleware> CompInterface<M> {
43 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
44 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
45 |         #[doc = r" object"]
46 |         pub fn new<T: Into<ethers::core::types::Address>>(
47 |             address: T,
48 |             client: ::std::sync::Arc<M>,
49 |         ) -> Self {
50 |             ethers::contract::Contract::new(address.into(), COMPINTERFACE_ABI.clone(), client)
51 |                 .into()
52 |         }
53 |         #[doc = "Calls the contract's `getPriorVotes` (0x782d6fe1) function"]
54 |         pub fn get_prior_votes(
55 |             &self,
56 |             account: ethers::core::types::Address,
57 |             block_number: ethers::core::types::U256,
58 |         ) -> ethers::contract::builders::ContractCall<M, u128> {
59 |             self.0
60 |                 .method_hash([120, 45, 111, 225], (account, block_number))
61 |                 .expect("method not found (this should never happen)")
62 |         }
63 |     }
64 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for CompInterface<M> {
65 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
66 |             Self(contract)
67 |         }
68 |     }
69 |     #[doc = "Container type for all input parameters for the `getPriorVotes` function with signature `getPriorVotes(address,uint256)` and selector `[120, 45, 111, 225]`"]
70 |     #[derive(
71 |         Clone,
72 |         Debug,
73 |         Default,
74 |         Eq,
75 |         PartialEq,
76 |         ethers :: contract :: EthCall,
77 |         ethers :: contract :: EthDisplay,
78 |     )]
79 |     #[ethcall(name = "getPriorVotes", abi = "getPriorVotes(address,uint256)")]
80 |     pub struct GetPriorVotesCall {
81 |         pub account: ethers::core::types::Address,
82 |         pub block_number: ethers::core::types::U256,
83 |     }
84 |     #[doc = "Container type for all return fields from the `getPriorVotes` function with signature `getPriorVotes(address,uint256)` and selector `[120, 45, 111, 225]`"]
85 |     #[derive(
86 |         Clone,
87 |         Debug,
88 |         Default,
89 |         Eq,
90 |         PartialEq,
91 |         ethers :: contract :: EthAbiType,
92 |         ethers :: contract :: EthAbiCodec,
93 |     )]
94 |     pub struct GetPriorVotesReturn(pub u128);
95 | }
96 | 


--------------------------------------------------------------------------------
/compound/src/contracts/v1_price_oracle_interface.rs:
--------------------------------------------------------------------------------
  1 | pub use v1_price_oracle_interface::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod v1_price_oracle_interface {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "V1PriceOracleInterface was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static V1PRICEORACLEINTERFACE_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\",\"components\":[]}],\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"assetPrices\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\",\"components\":[]}]}]") . expect ("invalid abi")
 22 |         });
 23 |     pub struct V1PriceOracleInterface<M>(ethers::contract::Contract<M>);
 24 |     impl<M> Clone for V1PriceOracleInterface<M> {
 25 |         fn clone(&self) -> Self {
 26 |             V1PriceOracleInterface(self.0.clone())
 27 |         }
 28 |     }
 29 |     impl<M> std::ops::Deref for V1PriceOracleInterface<M> {
 30 |         type Target = ethers::contract::Contract<M>;
 31 |         fn deref(&self) -> &Self::Target {
 32 |             &self.0
 33 |         }
 34 |     }
 35 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for V1PriceOracleInterface<M> {
 36 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 37 |             f.debug_tuple(stringify!(V1PriceOracleInterface))
 38 |                 .field(&self.address())
 39 |                 .finish()
 40 |         }
 41 |     }
 42 |     impl<M: ethers::providers::Middleware> V1PriceOracleInterface<M> {
 43 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 44 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 45 |         #[doc = r" object"]
 46 |         pub fn new<T: Into<ethers::core::types::Address>>(
 47 |             address: T,
 48 |             client: ::std::sync::Arc<M>,
 49 |         ) -> Self {
 50 |             ethers::contract::Contract::new(
 51 |                 address.into(),
 52 |                 V1PRICEORACLEINTERFACE_ABI.clone(),
 53 |                 client,
 54 |             )
 55 |             .into()
 56 |         }
 57 |         #[doc = "Calls the contract's `assetPrices` (0x5e9a523c) function"]
 58 |         pub fn asset_prices(
 59 |             &self,
 60 |             asset: ethers::core::types::Address,
 61 |         ) -> ethers::contract::builders::ContractCall<M, ethers::core::types::U256> {
 62 |             self.0
 63 |                 .method_hash([94, 154, 82, 60], asset)
 64 |                 .expect("method not found (this should never happen)")
 65 |         }
 66 |     }
 67 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>>
 68 |         for V1PriceOracleInterface<M>
 69 |     {
 70 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 71 |             Self(contract)
 72 |         }
 73 |     }
 74 |     #[doc = "Container type for all input parameters for the `assetPrices` function with signature `assetPrices(address)` and selector `[94, 154, 82, 60]`"]
 75 |     #[derive(
 76 |         Clone,
 77 |         Debug,
 78 |         Default,
 79 |         Eq,
 80 |         PartialEq,
 81 |         ethers :: contract :: EthCall,
 82 |         ethers :: contract :: EthDisplay,
 83 |     )]
 84 |     #[ethcall(name = "assetPrices", abi = "assetPrices(address)")]
 85 |     pub struct AssetPricesCall {
 86 |         pub asset: ethers::core::types::Address,
 87 |     }
 88 |     #[doc = "Container type for all return fields from the `assetPrices` function with signature `assetPrices(address)` and selector `[94, 154, 82, 60]`"]
 89 |     #[derive(
 90 |         Clone,
 91 |         Debug,
 92 |         Default,
 93 |         Eq,
 94 |         PartialEq,
 95 |         ethers :: contract :: EthAbiType,
 96 |         ethers :: contract :: EthAbiCodec,
 97 |     )]
 98 |     pub struct AssetPricesReturn(pub ethers::core::types::U256);
 99 | }
100 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/flash_loan_logic.rs:
--------------------------------------------------------------------------------
 1 | pub use flash_loan_logic::*;
 2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
 3 | pub mod flash_loan_logic {
 4 |     #![allow(clippy::enum_variant_names)]
 5 |     #![allow(dead_code)]
 6 |     #![allow(clippy::type_complexity)]
 7 |     #![allow(unused_imports)]
 8 |     use ethers::contract::{
 9 |         builders::{ContractCall, Event},
10 |         Contract, Lazy,
11 |     };
12 |     use ethers::core::{
13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
14 |         types::*,
15 |     };
16 |     use ethers::providers::Middleware;
17 |     #[doc = "FlashLoanLogic was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
18 |     use std::sync::Arc;
19 |     pub static FLASHLOANLOGIC_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
20 |         ethers::contract::Lazy::new(|| {
21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\",\"components\":[],\"indexed\":true},{\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\",\"components\":[],\"indexed\":false},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\",\"components\":[],\"indexed\":true},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\",\"components\":[],\"indexed\":false},{\"internalType\":\"enum DataTypes.InterestRateMode\",\"name\":\"interestRateMode\",\"type\":\"uint8\",\"components\":[],\"indexed\":false},{\"internalType\":\"uint256\",\"name\":\"premium\",\"type\":\"uint256\",\"components\":[],\"indexed\":false},{\"internalType\":\"uint16\",\"name\":\"referralCode\",\"type\":\"uint16\",\"components\":[],\"indexed\":true}],\"type\":\"event\",\"name\":\"FlashLoan\",\"outputs\":[],\"anonymous\":false}]") . expect ("invalid abi")
22 |         });
23 |     pub struct FlashLoanLogic<M>(ethers::contract::Contract<M>);
24 |     impl<M> Clone for FlashLoanLogic<M> {
25 |         fn clone(&self) -> Self {
26 |             FlashLoanLogic(self.0.clone())
27 |         }
28 |     }
29 |     impl<M> std::ops::Deref for FlashLoanLogic<M> {
30 |         type Target = ethers::contract::Contract<M>;
31 |         fn deref(&self) -> &Self::Target {
32 |             &self.0
33 |         }
34 |     }
35 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for FlashLoanLogic<M> {
36 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
37 |             f.debug_tuple(stringify!(FlashLoanLogic))
38 |                 .field(&self.address())
39 |                 .finish()
40 |         }
41 |     }
42 |     impl<M: ethers::providers::Middleware> FlashLoanLogic<M> {
43 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
44 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
45 |         #[doc = r" object"]
46 |         pub fn new<T: Into<ethers::core::types::Address>>(
47 |             address: T,
48 |             client: ::std::sync::Arc<M>,
49 |         ) -> Self {
50 |             ethers::contract::Contract::new(address.into(), FLASHLOANLOGIC_ABI.clone(), client)
51 |                 .into()
52 |         }
53 |         #[doc = "Gets the contract's `FlashLoan` event"]
54 |         pub fn flash_loan_filter(&self) -> ethers::contract::builders::Event<M, FlashLoanFilter> {
55 |             self.0.event()
56 |         }
57 |         #[doc = r" Returns an [`Event`](#ethers_contract::builders::Event) builder for all events of this contract"]
58 |         pub fn events(&self) -> ethers::contract::builders::Event<M, FlashLoanFilter> {
59 |             self.0.event_with_filter(Default::default())
60 |         }
61 |     }
62 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for FlashLoanLogic<M> {
63 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
64 |             Self(contract)
65 |         }
66 |     }
67 |     #[derive(
68 |         Clone,
69 |         Debug,
70 |         Default,
71 |         Eq,
72 |         PartialEq,
73 |         ethers :: contract :: EthEvent,
74 |         ethers :: contract :: EthDisplay,
75 |     )]
76 |     #[ethevent(
77 |         name = "FlashLoan",
78 |         abi = "FlashLoan(address,address,address,uint256,uint8,uint256,uint16)"
79 |     )]
80 |     pub struct FlashLoanFilter {
81 |         #[ethevent(indexed)]
82 |         pub target: ethers::core::types::Address,
83 |         pub initiator: ethers::core::types::Address,
84 |         #[ethevent(indexed)]
85 |         pub asset: ethers::core::types::Address,
86 |         pub amount: ethers::core::types::U256,
87 |         pub interest_rate_mode: u8,
88 |         pub premium: ethers::core::types::U256,
89 |         #[ethevent(indexed)]
90 |         pub referral_code: u16,
91 |     }
92 | }
93 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/i_sequencer_oracle.rs:
--------------------------------------------------------------------------------
  1 | pub use i_sequencer_oracle::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod i_sequencer_oracle {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "ISequencerOracle was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static ISEQUENCERORACLE_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[],\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"latestRoundData\",\"outputs\":[{\"internalType\":\"uint80\",\"name\":\"roundId\",\"type\":\"uint80\",\"components\":[]},{\"internalType\":\"int256\",\"name\":\"answer\",\"type\":\"int256\",\"components\":[]},{\"internalType\":\"uint256\",\"name\":\"startedAt\",\"type\":\"uint256\",\"components\":[]},{\"internalType\":\"uint256\",\"name\":\"updatedAt\",\"type\":\"uint256\",\"components\":[]},{\"internalType\":\"uint80\",\"name\":\"answeredInRound\",\"type\":\"uint80\",\"components\":[]}]}]") . expect ("invalid abi")
 22 |         });
 23 |     pub struct ISequencerOracle<M>(ethers::contract::Contract<M>);
 24 |     impl<M> Clone for ISequencerOracle<M> {
 25 |         fn clone(&self) -> Self {
 26 |             ISequencerOracle(self.0.clone())
 27 |         }
 28 |     }
 29 |     impl<M> std::ops::Deref for ISequencerOracle<M> {
 30 |         type Target = ethers::contract::Contract<M>;
 31 |         fn deref(&self) -> &Self::Target {
 32 |             &self.0
 33 |         }
 34 |     }
 35 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for ISequencerOracle<M> {
 36 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 37 |             f.debug_tuple(stringify!(ISequencerOracle))
 38 |                 .field(&self.address())
 39 |                 .finish()
 40 |         }
 41 |     }
 42 |     impl<M: ethers::providers::Middleware> ISequencerOracle<M> {
 43 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 44 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 45 |         #[doc = r" object"]
 46 |         pub fn new<T: Into<ethers::core::types::Address>>(
 47 |             address: T,
 48 |             client: ::std::sync::Arc<M>,
 49 |         ) -> Self {
 50 |             ethers::contract::Contract::new(address.into(), ISEQUENCERORACLE_ABI.clone(), client)
 51 |                 .into()
 52 |         }
 53 |         #[doc = "Calls the contract's `latestRoundData` (0xfeaf968c) function"]
 54 |         pub fn latest_round_data(
 55 |             &self,
 56 |         ) -> ethers::contract::builders::ContractCall<
 57 |             M,
 58 |             (
 59 |                 u128,
 60 |                 I256,
 61 |                 ethers::core::types::U256,
 62 |                 ethers::core::types::U256,
 63 |                 u128,
 64 |             ),
 65 |         > {
 66 |             self.0
 67 |                 .method_hash([254, 175, 150, 140], ())
 68 |                 .expect("method not found (this should never happen)")
 69 |         }
 70 |     }
 71 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for ISequencerOracle<M> {
 72 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 73 |             Self(contract)
 74 |         }
 75 |     }
 76 |     #[doc = "Container type for all input parameters for the `latestRoundData` function with signature `latestRoundData()` and selector `[254, 175, 150, 140]`"]
 77 |     #[derive(
 78 |         Clone,
 79 |         Debug,
 80 |         Default,
 81 |         Eq,
 82 |         PartialEq,
 83 |         ethers :: contract :: EthCall,
 84 |         ethers :: contract :: EthDisplay,
 85 |     )]
 86 |     #[ethcall(name = "latestRoundData", abi = "latestRoundData()")]
 87 |     pub struct LatestRoundDataCall;
 88 |     #[doc = "Container type for all return fields from the `latestRoundData` function with signature `latestRoundData()` and selector `[254, 175, 150, 140]`"]
 89 |     #[derive(
 90 |         Clone,
 91 |         Debug,
 92 |         Default,
 93 |         Eq,
 94 |         PartialEq,
 95 |         ethers :: contract :: EthAbiType,
 96 |         ethers :: contract :: EthAbiCodec,
 97 |     )]
 98 |     pub struct LatestRoundDataReturn {
 99 |         pub round_id: u128,
100 |         pub answer: I256,
101 |         pub started_at: ethers::core::types::U256,
102 |         pub updated_at: ethers::core::types::U256,
103 |         pub answered_in_round: u128,
104 |     }
105 | }
106 | 


--------------------------------------------------------------------------------
/compound/src/contracts/exponential.rs:
--------------------------------------------------------------------------------
  1 | pub use exponential::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod exponential {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "Exponential was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static EXPONENTIAL_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static EXPONENTIAL_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x6080604052348015600f57600080fd5b50603e80601d6000396000f3fe6080604052600080fdfea265627a7a72315820c19029aa27f7cf4bf3beacab05b4e6a5c57c8731b99c9805de640e7c5904999164736f6c63430005110032" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct Exponential<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for Exponential<M> {
 30 |         fn clone(&self) -> Self {
 31 |             Exponential(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for Exponential<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for Exponential<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(Exponential))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> Exponential<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), EXPONENTIAL_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 EXPONENTIAL_ABI.clone(),
 89 |                 EXPONENTIAL_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for Exponential<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/pool_storage.rs:
--------------------------------------------------------------------------------
  1 | pub use pool_storage::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod pool_storage {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "PoolStorage was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static POOLSTORAGE_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static POOLSTORAGE_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220a744ea932ac8b241cc34cbe86d94f5a832b767abce23610e7dc8609d11d4b75a64736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct PoolStorage<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for PoolStorage<M> {
 30 |         fn clone(&self) -> Self {
 31 |             PoolStorage(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for PoolStorage<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for PoolStorage<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(PoolStorage))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> PoolStorage<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), POOLSTORAGE_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 POOLSTORAGE_ABI.clone(),
 89 |                 POOLSTORAGE_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for PoolStorage<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/compound/src/contracts/careful_math.rs:
--------------------------------------------------------------------------------
  1 | pub use careful_math::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod careful_math {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "CarefulMath was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static CAREFULMATH_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static CAREFULMATH_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x6080604052348015600f57600080fd5b50603e80601d6000396000f3fe6080604052600080fdfea265627a7a72315820224ca43cc1f218e948d7531db46f261afc4c6c31290cf71bfcc88d5fcc5b36ec64736f6c63430005110032" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct CarefulMath<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for CarefulMath<M> {
 30 |         fn clone(&self) -> Self {
 31 |             CarefulMath(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for CarefulMath<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for CarefulMath<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(CarefulMath))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> CarefulMath<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), CAREFULMATH_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 CAREFULMATH_ABI.clone(),
 89 |                 CAREFULMATH_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for CarefulMath<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/compound/src/contracts/safe_math.rs:
--------------------------------------------------------------------------------
  1 | pub use safe_math::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod safe_math {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "SafeMath was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static SAFEMATH_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static SAFEMATH_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582050b556b30bd4cc77f527237cb4d9b244a2b0decdd467b5989557b37ac9a48ad164736f6c63430005110032" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct SafeMath<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for SafeMath<M> {
 30 |         fn clone(&self) -> Self {
 31 |             SafeMath(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for SafeMath<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for SafeMath<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(SafeMath))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> SafeMath<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), SAFEMATH_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 SAFEMATH_ABI.clone(),
 89 |                 SAFEMATH_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for SafeMath<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/address.rs:
--------------------------------------------------------------------------------
  1 | pub use address::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod address {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "Address was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static ADDRESS_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static ADDRESS_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122041583d8427bf59358ba555204a024e0e9e115008e75dc7cbfc2aa366b28b996664736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct Address<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for Address<M> {
 30 |         fn clone(&self) -> Self {
 31 |             Address(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for Address<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for Address<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(Address))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> Address<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), ADDRESS_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 ADDRESS_ABI.clone(),
 89 |                 ADDRESS_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for Address<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/helpers.rs:
--------------------------------------------------------------------------------
  1 | pub use helpers::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod helpers {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "Helpers was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static HELPERS_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static HELPERS_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212201f046705f68d3c9aaa8555eead2b3c37030d0148bd4a966ee312ad39645f143b64736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct Helpers<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for Helpers<M> {
 30 |         fn clone(&self) -> Self {
 31 |             Helpers(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for Helpers<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for Helpers<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(Helpers))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> Helpers<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), HELPERS_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 HELPERS_ABI.clone(),
 89 |                 HELPERS_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for Helpers<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/strings.rs:
--------------------------------------------------------------------------------
  1 | pub use strings::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod strings {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "Strings was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static STRINGS_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static STRINGS_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212207bbbd485213b9ea860ceb6b13f4470fd5e0a16701468f5f8d56d4c556822d0b664736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct Strings<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for Strings<M> {
 30 |         fn clone(&self) -> Self {
 31 |             Strings(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for Strings<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for Strings<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(Strings))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> Strings<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), STRINGS_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 STRINGS_ABI.clone(),
 89 |                 STRINGS_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for Strings<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/safe_cast.rs:
--------------------------------------------------------------------------------
  1 | pub use safe_cast::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod safe_cast {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "SafeCast was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static SAFECAST_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static SAFECAST_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212207ea610714272954b22acdba14d61c131fb9a63023ce102640b8304bf971fecb864736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct SafeCast<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for SafeCast<M> {
 30 |         fn clone(&self) -> Self {
 31 |             SafeCast(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for SafeCast<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for SafeCast<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(SafeCast))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> SafeCast<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), SAFECAST_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 SAFECAST_ABI.clone(),
 89 |                 SAFECAST_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for SafeCast<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/safe_math.rs:
--------------------------------------------------------------------------------
  1 | pub use safe_math::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod safe_math {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "SafeMath was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static SAFEMATH_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static SAFEMATH_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220c0a7ec2ba68bfac85dc62e0c9ae585379e918e0d2388568ecfd2b3561d594ffe64736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct SafeMath<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for SafeMath<M> {
 30 |         fn clone(&self) -> Self {
 31 |             SafeMath(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for SafeMath<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for SafeMath<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(SafeMath))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> SafeMath<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), SAFEMATH_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 SAFEMATH_ABI.clone(),
 89 |                 SAFEMATH_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for SafeMath<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/initializable.rs:
--------------------------------------------------------------------------------
  1 | pub use initializable::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod initializable {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "Initializable was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static INITIALIZABLE_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static INITIALIZABLE_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea264697066735822122084edcf79a898329f3c957f7768f84223eb9268de3db03f0ae94ff047d5055ecd64736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct Initializable<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for Initializable<M> {
 30 |         fn clone(&self) -> Self {
 31 |             Initializable(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for Initializable<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for Initializable<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(Initializable))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> Initializable<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), INITIALIZABLE_ABI.clone(), client)
 56 |                 .into()
 57 |         }
 58 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 59 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 60 |         #[doc = r""]
 61 |         #[doc = r" Notes:"]
 62 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 63 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 64 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 65 |         #[doc = r""]
 66 |         #[doc = r""]
 67 |         #[doc = r" # Example"]
 68 |         #[doc = r""]
 69 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 70 |         #[doc = r""]
 71 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 72 |         #[doc = r""]
 73 |         #[doc = r" ```ignore"]
 74 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 75 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 76 |         #[doc = r""]
 77 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 78 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 79 |         #[doc = r" # }"]
 80 |         #[doc = r" ```"]
 81 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 82 |             client: ::std::sync::Arc<M>,
 83 |             constructor_args: T,
 84 |         ) -> ::std::result::Result<
 85 |             ethers::contract::builders::ContractDeployer<M, Self>,
 86 |             ethers::contract::ContractError<M>,
 87 |         > {
 88 |             let factory = ethers::contract::ContractFactory::new(
 89 |                 INITIALIZABLE_ABI.clone(),
 90 |                 INITIALIZABLE_BYTECODE.clone().into(),
 91 |                 client,
 92 |             );
 93 |             let deployer = factory.deploy(constructor_args)?;
 94 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 95 |             Ok(deployer)
 96 |         }
 97 |     }
 98 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for Initializable<M> {
 99 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
100 |             Self(contract)
101 |         }
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/data_types.rs:
--------------------------------------------------------------------------------
  1 | pub use data_types::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod data_types {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "DataTypes was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static DATATYPES_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static DATATYPES_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220360eac8f0fef58483d4728776c7cf9ba3de1756d51f1fa3c79ed8b99d0b2d51d64736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct DataTypes<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for DataTypes<M> {
 30 |         fn clone(&self) -> Self {
 31 |             DataTypes(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for DataTypes<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for DataTypes<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(DataTypes))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> DataTypes<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), DATATYPES_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 DATATYPES_ABI.clone(),
 89 |                 DATATYPES_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for DataTypes<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/math_utils.rs:
--------------------------------------------------------------------------------
  1 | pub use math_utils::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod math_utils {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "MathUtils was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static MATHUTILS_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static MATHUTILS_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212201f2cb935ff53b5b2b3cf377e4a1505ad7686c2d7404b59d9c591f281a8f0eafa64736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct MathUtils<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for MathUtils<M> {
 30 |         fn clone(&self) -> Self {
 31 |             MathUtils(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for MathUtils<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for MathUtils<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(MathUtils))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> MathUtils<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), MATHUTILS_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 MATHUTILS_ABI.clone(),
 89 |                 MATHUTILS_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for MathUtils<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/wad_ray_math.rs:
--------------------------------------------------------------------------------
  1 | pub use wad_ray_math::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod wad_ray_math {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "WadRayMath was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static WADRAYMATH_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static WADRAYMATH_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212206b23c10e47845eb01451cf6a3953bfa27f117ca2df7f4d92d50213b6fd15045b64736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct WadRayMath<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for WadRayMath<M> {
 30 |         fn clone(&self) -> Self {
 31 |             WadRayMath(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for WadRayMath<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for WadRayMath<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(WadRayMath))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> WadRayMath<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), WADRAYMATH_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 WADRAYMATH_ABI.clone(),
 89 |                 WADRAYMATH_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for WadRayMath<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/generic_logic.rs:
--------------------------------------------------------------------------------
  1 | pub use generic_logic::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod generic_logic {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "GenericLogic was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static GENERICLOGIC_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static GENERICLOGIC_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122089e267f2b1b00382f1599d6f8e5fe20c2ce9e456dff0b8a3ee19ca9dfc0f667764736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct GenericLogic<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for GenericLogic<M> {
 30 |         fn clone(&self) -> Self {
 31 |             GenericLogic(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for GenericLogic<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for GenericLogic<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(GenericLogic))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> GenericLogic<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), GENERICLOGIC_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 GENERICLOGIC_ABI.clone(),
 89 |                 GENERICLOGIC_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |     }
 97 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for GenericLogic<M> {
 98 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 99 |             Self(contract)
100 |         }
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/calldata_logic.rs:
--------------------------------------------------------------------------------
  1 | pub use calldata_logic::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod calldata_logic {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "CalldataLogic was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static CALLDATALOGIC_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static CALLDATALOGIC_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212204aafec10ae3a6be8787c59736515c628f7a010a4ec797618f2e126ac2696411f64736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct CalldataLogic<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for CalldataLogic<M> {
 30 |         fn clone(&self) -> Self {
 31 |             CalldataLogic(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for CalldataLogic<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for CalldataLogic<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(CalldataLogic))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> CalldataLogic<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), CALLDATALOGIC_ABI.clone(), client)
 56 |                 .into()
 57 |         }
 58 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 59 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 60 |         #[doc = r""]
 61 |         #[doc = r" Notes:"]
 62 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 63 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 64 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 65 |         #[doc = r""]
 66 |         #[doc = r""]
 67 |         #[doc = r" # Example"]
 68 |         #[doc = r""]
 69 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 70 |         #[doc = r""]
 71 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 72 |         #[doc = r""]
 73 |         #[doc = r" ```ignore"]
 74 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 75 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 76 |         #[doc = r""]
 77 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 78 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 79 |         #[doc = r" # }"]
 80 |         #[doc = r" ```"]
 81 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 82 |             client: ::std::sync::Arc<M>,
 83 |             constructor_args: T,
 84 |         ) -> ::std::result::Result<
 85 |             ethers::contract::builders::ContractDeployer<M, Self>,
 86 |             ethers::contract::ContractError<M>,
 87 |         > {
 88 |             let factory = ethers::contract::ContractFactory::new(
 89 |                 CALLDATALOGIC_ABI.clone(),
 90 |                 CALLDATALOGIC_BYTECODE.clone().into(),
 91 |                 client,
 92 |             );
 93 |             let deployer = factory.deploy(constructor_args)?;
 94 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 95 |             Ok(deployer)
 96 |         }
 97 |     }
 98 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for CalldataLogic<M> {
 99 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
100 |             Self(contract)
101 |         }
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/g_pv_2_safe_erc20.rs:
--------------------------------------------------------------------------------
  1 | pub use g_pv_2_safe_erc20::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod g_pv_2_safe_erc20 {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "GPv2SafeERC20 was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static GPV2SAFEERC20_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static GPV2SAFEERC20_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212208f3beef52a00fdffc496a1b7020200140800bc6da9e7731ba94db8d45b6d0a9d64736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct GPv2SafeERC20<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for GPv2SafeERC20<M> {
 30 |         fn clone(&self) -> Self {
 31 |             GPv2SafeERC20(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for GPv2SafeERC20<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for GPv2SafeERC20<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(GPv2SafeERC20))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> GPv2SafeERC20<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), GPV2SAFEERC20_ABI.clone(), client)
 56 |                 .into()
 57 |         }
 58 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 59 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 60 |         #[doc = r""]
 61 |         #[doc = r" Notes:"]
 62 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 63 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 64 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 65 |         #[doc = r""]
 66 |         #[doc = r""]
 67 |         #[doc = r" # Example"]
 68 |         #[doc = r""]
 69 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 70 |         #[doc = r""]
 71 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 72 |         #[doc = r""]
 73 |         #[doc = r" ```ignore"]
 74 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 75 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 76 |         #[doc = r""]
 77 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 78 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 79 |         #[doc = r" # }"]
 80 |         #[doc = r" ```"]
 81 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 82 |             client: ::std::sync::Arc<M>,
 83 |             constructor_args: T,
 84 |         ) -> ::std::result::Result<
 85 |             ethers::contract::builders::ContractDeployer<M, Self>,
 86 |             ethers::contract::ContractError<M>,
 87 |         > {
 88 |             let factory = ethers::contract::ContractFactory::new(
 89 |                 GPV2SAFEERC20_ABI.clone(),
 90 |                 GPV2SAFEERC20_BYTECODE.clone().into(),
 91 |                 client,
 92 |             );
 93 |             let deployer = factory.deploy(constructor_args)?;
 94 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 95 |             Ok(deployer)
 96 |         }
 97 |     }
 98 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for GPv2SafeERC20<M> {
 99 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
100 |             Self(contract)
101 |         }
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/percentage_math.rs:
--------------------------------------------------------------------------------
  1 | pub use percentage_math::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod percentage_math {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "PercentageMath was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static PERCENTAGEMATH_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static PERCENTAGEMATH_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220ed74f792b2c0f3843ad9b1ea642db5f70d0df7a79d59351ff0a9a208d2e50e5364736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct PercentageMath<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for PercentageMath<M> {
 30 |         fn clone(&self) -> Self {
 31 |             PercentageMath(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for PercentageMath<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for PercentageMath<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(PercentageMath))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> PercentageMath<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), PERCENTAGEMATH_ABI.clone(), client)
 56 |                 .into()
 57 |         }
 58 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 59 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 60 |         #[doc = r""]
 61 |         #[doc = r" Notes:"]
 62 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 63 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 64 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 65 |         #[doc = r""]
 66 |         #[doc = r""]
 67 |         #[doc = r" # Example"]
 68 |         #[doc = r""]
 69 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 70 |         #[doc = r""]
 71 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 72 |         #[doc = r""]
 73 |         #[doc = r" ```ignore"]
 74 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 75 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 76 |         #[doc = r""]
 77 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 78 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 79 |         #[doc = r" # }"]
 80 |         #[doc = r" ```"]
 81 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 82 |             client: ::std::sync::Arc<M>,
 83 |             constructor_args: T,
 84 |         ) -> ::std::result::Result<
 85 |             ethers::contract::builders::ContractDeployer<M, Self>,
 86 |             ethers::contract::ContractError<M>,
 87 |         > {
 88 |             let factory = ethers::contract::ContractFactory::new(
 89 |                 PERCENTAGEMATH_ABI.clone(),
 90 |                 PERCENTAGEMATH_BYTECODE.clone().into(),
 91 |                 client,
 92 |             );
 93 |             let deployer = factory.deploy(constructor_args)?;
 94 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 95 |             Ok(deployer)
 96 |         }
 97 |     }
 98 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for PercentageMath<M> {
 99 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
100 |             Self(contract)
101 |         }
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/user_configuration.rs:
--------------------------------------------------------------------------------
  1 | pub use user_configuration::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod user_configuration {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "UserConfiguration was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static USERCONFIGURATION_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static USERCONFIGURATION_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220203e0b447f690a1bff56458674e874eec0253954ad2f807ce8aab1d2a99a4e9b64736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct UserConfiguration<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for UserConfiguration<M> {
 30 |         fn clone(&self) -> Self {
 31 |             UserConfiguration(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for UserConfiguration<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for UserConfiguration<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(UserConfiguration))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> UserConfiguration<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), USERCONFIGURATION_ABI.clone(), client)
 56 |                 .into()
 57 |         }
 58 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 59 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 60 |         #[doc = r""]
 61 |         #[doc = r" Notes:"]
 62 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 63 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 64 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 65 |         #[doc = r""]
 66 |         #[doc = r""]
 67 |         #[doc = r" # Example"]
 68 |         #[doc = r""]
 69 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 70 |         #[doc = r""]
 71 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 72 |         #[doc = r""]
 73 |         #[doc = r" ```ignore"]
 74 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 75 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 76 |         #[doc = r""]
 77 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 78 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 79 |         #[doc = r" # }"]
 80 |         #[doc = r" ```"]
 81 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 82 |             client: ::std::sync::Arc<M>,
 83 |             constructor_args: T,
 84 |         ) -> ::std::result::Result<
 85 |             ethers::contract::builders::ContractDeployer<M, Self>,
 86 |             ethers::contract::ContractError<M>,
 87 |         > {
 88 |             let factory = ethers::contract::ContractFactory::new(
 89 |                 USERCONFIGURATION_ABI.clone(),
 90 |                 USERCONFIGURATION_BYTECODE.clone().into(),
 91 |                 client,
 92 |             );
 93 |             let deployer = factory.deploy(constructor_args)?;
 94 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 95 |             Ok(deployer)
 96 |         }
 97 |     }
 98 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>>
 99 |         for UserConfiguration<M>
100 |     {
101 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
102 |             Self(contract)
103 |         }
104 |     }
105 | }
106 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/shared_types.rs:
--------------------------------------------------------------------------------
  1 | #[doc = "`UpdateATokenInput(address,address,address,string,string,address,bytes)`"]
  2 | #[derive(
  3 |     Clone,
  4 |     Debug,
  5 |     Default,
  6 |     Eq,
  7 |     PartialEq,
  8 |     ethers :: contract :: EthAbiType,
  9 |     ethers :: contract :: EthAbiCodec,
 10 | )]
 11 | pub struct UpdateATokenInput {
 12 |     pub asset: ethers::core::types::Address,
 13 |     pub treasury: ethers::core::types::Address,
 14 |     pub incentives_controller: ethers::core::types::Address,
 15 |     pub name: String,
 16 |     pub symbol: String,
 17 |     pub implementation: ethers::core::types::Address,
 18 |     pub params: ethers::core::types::Bytes,
 19 | }
 20 | #[doc = "`CalculateInterestRatesParams(uint256,uint256,uint256,uint256,uint256,uint256,uint256,address,address)`"]
 21 | #[derive(
 22 |     Clone,
 23 |     Debug,
 24 |     Default,
 25 |     Eq,
 26 |     PartialEq,
 27 |     ethers :: contract :: EthAbiType,
 28 |     ethers :: contract :: EthAbiCodec,
 29 | )]
 30 | pub struct CalculateInterestRatesParams {
 31 |     pub unbacked: ethers::core::types::U256,
 32 |     pub liquidity_added: ethers::core::types::U256,
 33 |     pub liquidity_taken: ethers::core::types::U256,
 34 |     pub total_stable_debt: ethers::core::types::U256,
 35 |     pub total_variable_debt: ethers::core::types::U256,
 36 |     pub average_stable_borrow_rate: ethers::core::types::U256,
 37 |     pub reserve_factor: ethers::core::types::U256,
 38 |     pub reserve: ethers::core::types::Address,
 39 |     pub a_token: ethers::core::types::Address,
 40 | }
 41 | #[doc = "`EmodeCategory(uint16,uint16,uint16,address,string)`"]
 42 | #[derive(
 43 |     Clone,
 44 |     Debug,
 45 |     Default,
 46 |     Eq,
 47 |     PartialEq,
 48 |     ethers :: contract :: EthAbiType,
 49 |     ethers :: contract :: EthAbiCodec,
 50 | )]
 51 | pub struct EmodeCategory {
 52 |     pub ltv: u16,
 53 |     pub liquidation_threshold: u16,
 54 |     pub liquidation_bonus: u16,
 55 |     pub price_source: ethers::core::types::Address,
 56 |     pub label: String,
 57 | }
 58 | #[doc = "`InitReserveInput(address,address,address,uint8,address,address,address,address,string,string,string,string,string,string,bytes)`"]
 59 | #[derive(
 60 |     Clone,
 61 |     Debug,
 62 |     Default,
 63 |     Eq,
 64 |     PartialEq,
 65 |     ethers :: contract :: EthAbiType,
 66 |     ethers :: contract :: EthAbiCodec,
 67 | )]
 68 | pub struct InitReserveInput {
 69 |     pub a_token_impl: ethers::core::types::Address,
 70 |     pub stable_debt_token_impl: ethers::core::types::Address,
 71 |     pub variable_debt_token_impl: ethers::core::types::Address,
 72 |     pub underlying_asset_decimals: u8,
 73 |     pub interest_rate_strategy_address: ethers::core::types::Address,
 74 |     pub underlying_asset: ethers::core::types::Address,
 75 |     pub treasury: ethers::core::types::Address,
 76 |     pub incentives_controller: ethers::core::types::Address,
 77 |     pub a_token_name: String,
 78 |     pub a_token_symbol: String,
 79 |     pub variable_debt_token_name: String,
 80 |     pub variable_debt_token_symbol: String,
 81 |     pub stable_debt_token_name: String,
 82 |     pub stable_debt_token_symbol: String,
 83 |     pub params: ethers::core::types::Bytes,
 84 | }
 85 | #[doc = "`UserConfigurationMap(uint256)`"]
 86 | #[derive(
 87 |     Clone,
 88 |     Debug,
 89 |     Default,
 90 |     Eq,
 91 |     PartialEq,
 92 |     ethers :: contract :: EthAbiType,
 93 |     ethers :: contract :: EthAbiCodec,
 94 | )]
 95 | pub struct UserConfigurationMap {
 96 |     pub data: ethers::core::types::U256,
 97 | }
 98 | #[doc = "`ReserveConfigurationMap(uint256)`"]
 99 | #[derive(
100 |     Clone,
101 |     Debug,
102 |     Default,
103 |     Eq,
104 |     PartialEq,
105 |     ethers :: contract :: EthAbiType,
106 |     ethers :: contract :: EthAbiCodec,
107 | )]
108 | pub struct ReserveConfigurationMap {
109 |     pub data: ethers::core::types::U256,
110 | }
111 | #[doc = "`ReserveData((uint256),uint128,uint128,uint128,uint128,uint128,uint40,uint16,address,address,address,address,uint128,uint128,uint128)`"]
112 | #[derive(
113 |     Clone,
114 |     Debug,
115 |     Default,
116 |     Eq,
117 |     PartialEq,
118 |     ethers :: contract :: EthAbiType,
119 |     ethers :: contract :: EthAbiCodec,
120 | )]
121 | pub struct ReserveData {
122 |     pub configuration: ReserveConfigurationMap,
123 |     pub liquidity_index: u128,
124 |     pub current_liquidity_rate: u128,
125 |     pub variable_borrow_index: u128,
126 |     pub current_variable_borrow_rate: u128,
127 |     pub current_stable_borrow_rate: u128,
128 |     pub last_update_timestamp: u64,
129 |     pub id: u16,
130 |     pub a_token_address: ethers::core::types::Address,
131 |     pub stable_debt_token_address: ethers::core::types::Address,
132 |     pub variable_debt_token_address: ethers::core::types::Address,
133 |     pub interest_rate_strategy_address: ethers::core::types::Address,
134 |     pub accrued_to_treasury: u128,
135 |     pub unbacked: u128,
136 |     pub isolation_mode_total_debt: u128,
137 | }
138 | #[doc = "`UpdateDebtTokenInput(address,address,string,string,address,bytes)`"]
139 | #[derive(
140 |     Clone,
141 |     Debug,
142 |     Default,
143 |     Eq,
144 |     PartialEq,
145 |     ethers :: contract :: EthAbiType,
146 |     ethers :: contract :: EthAbiCodec,
147 | )]
148 | pub struct UpdateDebtTokenInput {
149 |     pub asset: ethers::core::types::Address,
150 |     pub incentives_controller: ethers::core::types::Address,
151 |     pub name: String,
152 |     pub symbol: String,
153 |     pub implementation: ethers::core::types::Address,
154 |     pub params: ethers::core::types::Bytes,
155 | }
156 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/configurator_input_types.rs:
--------------------------------------------------------------------------------
  1 | pub use configurator_input_types::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod configurator_input_types {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "ConfiguratorInputTypes was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static CONFIGURATORINPUTTYPES_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers::core::utils::__serde_json::from_str("[]").expect("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static CONFIGURATORINPUTTYPES_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220acb1e169e9cba2918ef960181d3018352983c81156cf74e01d97c35b562e526564736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct ConfiguratorInputTypes<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for ConfiguratorInputTypes<M> {
 30 |         fn clone(&self) -> Self {
 31 |             ConfiguratorInputTypes(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for ConfiguratorInputTypes<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for ConfiguratorInputTypes<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(ConfiguratorInputTypes))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> ConfiguratorInputTypes<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(
 56 |                 address.into(),
 57 |                 CONFIGURATORINPUTTYPES_ABI.clone(),
 58 |                 client,
 59 |             )
 60 |             .into()
 61 |         }
 62 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 63 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 64 |         #[doc = r""]
 65 |         #[doc = r" Notes:"]
 66 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 67 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 68 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 69 |         #[doc = r""]
 70 |         #[doc = r""]
 71 |         #[doc = r" # Example"]
 72 |         #[doc = r""]
 73 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 74 |         #[doc = r""]
 75 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 76 |         #[doc = r""]
 77 |         #[doc = r" ```ignore"]
 78 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 79 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 80 |         #[doc = r""]
 81 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 82 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 83 |         #[doc = r" # }"]
 84 |         #[doc = r" ```"]
 85 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 86 |             client: ::std::sync::Arc<M>,
 87 |             constructor_args: T,
 88 |         ) -> ::std::result::Result<
 89 |             ethers::contract::builders::ContractDeployer<M, Self>,
 90 |             ethers::contract::ContractError<M>,
 91 |         > {
 92 |             let factory = ethers::contract::ContractFactory::new(
 93 |                 CONFIGURATORINPUTTYPES_ABI.clone(),
 94 |                 CONFIGURATORINPUTTYPES_BYTECODE.clone().into(),
 95 |                 client,
 96 |             );
 97 |             let deployer = factory.deploy(constructor_args)?;
 98 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 99 |             Ok(deployer)
100 |         }
101 |     }
102 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>>
103 |         for ConfiguratorInputTypes<M>
104 |     {
105 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
106 |             Self(contract)
107 |         }
108 |     }
109 | }
110 | 


--------------------------------------------------------------------------------
/compound/src/contracts/token_error_reporter.rs:
--------------------------------------------------------------------------------
  1 | pub use token_error_reporter::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod token_error_reporter {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "TokenErrorReporter was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static TOKENERRORREPORTER_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"error\",\"type\":\"uint256\",\"components\":[],\"indexed\":false},{\"internalType\":\"uint256\",\"name\":\"info\",\"type\":\"uint256\",\"components\":[],\"indexed\":false},{\"internalType\":\"uint256\",\"name\":\"detail\",\"type\":\"uint256\",\"components\":[],\"indexed\":false}],\"type\":\"event\",\"name\":\"Failure\",\"outputs\":[],\"anonymous\":false}]") . expect ("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static TOKENERRORREPORTER_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x6080604052348015600f57600080fd5b50603e80601d6000396000f3fe6080604052600080fdfea265627a7a723158200e72d22cd27923ed3c19331225eec8b32264cefc27cca5e4b7d56aeb46b9105c64736f6c63430005110032" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct TokenErrorReporter<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for TokenErrorReporter<M> {
 30 |         fn clone(&self) -> Self {
 31 |             TokenErrorReporter(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for TokenErrorReporter<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for TokenErrorReporter<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(TokenErrorReporter))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> TokenErrorReporter<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), TOKENERRORREPORTER_ABI.clone(), client)
 56 |                 .into()
 57 |         }
 58 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 59 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 60 |         #[doc = r""]
 61 |         #[doc = r" Notes:"]
 62 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 63 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 64 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 65 |         #[doc = r""]
 66 |         #[doc = r""]
 67 |         #[doc = r" # Example"]
 68 |         #[doc = r""]
 69 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 70 |         #[doc = r""]
 71 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 72 |         #[doc = r""]
 73 |         #[doc = r" ```ignore"]
 74 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 75 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 76 |         #[doc = r""]
 77 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 78 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 79 |         #[doc = r" # }"]
 80 |         #[doc = r" ```"]
 81 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 82 |             client: ::std::sync::Arc<M>,
 83 |             constructor_args: T,
 84 |         ) -> ::std::result::Result<
 85 |             ethers::contract::builders::ContractDeployer<M, Self>,
 86 |             ethers::contract::ContractError<M>,
 87 |         > {
 88 |             let factory = ethers::contract::ContractFactory::new(
 89 |                 TOKENERRORREPORTER_ABI.clone(),
 90 |                 TOKENERRORREPORTER_BYTECODE.clone().into(),
 91 |                 client,
 92 |             );
 93 |             let deployer = factory.deploy(constructor_args)?;
 94 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 95 |             Ok(deployer)
 96 |         }
 97 |         #[doc = "Gets the contract's `Failure` event"]
 98 |         pub fn failure_filter(&self) -> ethers::contract::builders::Event<M, FailureFilter> {
 99 |             self.0.event()
100 |         }
101 |         #[doc = r" Returns an [`Event`](#ethers_contract::builders::Event) builder for all events of this contract"]
102 |         pub fn events(&self) -> ethers::contract::builders::Event<M, FailureFilter> {
103 |             self.0.event_with_filter(Default::default())
104 |         }
105 |     }
106 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>>
107 |         for TokenErrorReporter<M>
108 |     {
109 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
110 |             Self(contract)
111 |         }
112 |     }
113 |     #[derive(
114 |         Clone,
115 |         Debug,
116 |         Default,
117 |         Eq,
118 |         PartialEq,
119 |         ethers :: contract :: EthEvent,
120 |         ethers :: contract :: EthDisplay,
121 |     )]
122 |     #[ethevent(name = "Failure", abi = "Failure(uint256,uint256,uint256)")]
123 |     pub struct FailureFilter {
124 |         pub error: ethers::core::types::U256,
125 |         pub info: ethers::core::types::U256,
126 |         pub detail: ethers::core::types::U256,
127 |     }
128 | }
129 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/selfdestruct_transfer.rs:
--------------------------------------------------------------------------------
  1 | pub use selfdestruct_transfer::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod selfdestruct_transfer {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "SelfdestructTransfer was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static SELFDESTRUCTTRANSFER_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"address payable\",\"name\":\"to\",\"type\":\"address\",\"components\":[]}],\"stateMutability\":\"payable\",\"type\":\"function\",\"name\":\"destroyAndTransfer\",\"outputs\":[]}]") . expect ("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static SELFDESTRUCTTRANSFER_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x6080604052348015600f57600080fd5b5060a28061001e6000396000f3fe608060405260043610601c5760003560e01c8063785e07b3146021575b600080fd5b6030602c366004603e565b6032565b005b806001600160a01b0316ff5b600060208284031215604f57600080fd5b81356001600160a01b0381168114606557600080fd5b939250505056fea26469706673582212207105fc6c0aa8e21a6bc0d7a96b984cdb00da16f370fdc0ab5c0fef5ad6c0012164736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct SelfdestructTransfer<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for SelfdestructTransfer<M> {
 30 |         fn clone(&self) -> Self {
 31 |             SelfdestructTransfer(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for SelfdestructTransfer<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for SelfdestructTransfer<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(SelfdestructTransfer))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> SelfdestructTransfer<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(
 56 |                 address.into(),
 57 |                 SELFDESTRUCTTRANSFER_ABI.clone(),
 58 |                 client,
 59 |             )
 60 |             .into()
 61 |         }
 62 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 63 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 64 |         #[doc = r""]
 65 |         #[doc = r" Notes:"]
 66 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 67 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 68 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 69 |         #[doc = r""]
 70 |         #[doc = r""]
 71 |         #[doc = r" # Example"]
 72 |         #[doc = r""]
 73 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 74 |         #[doc = r""]
 75 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 76 |         #[doc = r""]
 77 |         #[doc = r" ```ignore"]
 78 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 79 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 80 |         #[doc = r""]
 81 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 82 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 83 |         #[doc = r" # }"]
 84 |         #[doc = r" ```"]
 85 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 86 |             client: ::std::sync::Arc<M>,
 87 |             constructor_args: T,
 88 |         ) -> ::std::result::Result<
 89 |             ethers::contract::builders::ContractDeployer<M, Self>,
 90 |             ethers::contract::ContractError<M>,
 91 |         > {
 92 |             let factory = ethers::contract::ContractFactory::new(
 93 |                 SELFDESTRUCTTRANSFER_ABI.clone(),
 94 |                 SELFDESTRUCTTRANSFER_BYTECODE.clone().into(),
 95 |                 client,
 96 |             );
 97 |             let deployer = factory.deploy(constructor_args)?;
 98 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 99 |             Ok(deployer)
100 |         }
101 |         #[doc = "Calls the contract's `destroyAndTransfer` (0x785e07b3) function"]
102 |         pub fn destroy_and_transfer(
103 |             &self,
104 |             to: ethers::core::types::Address,
105 |         ) -> ethers::contract::builders::ContractCall<M, ()> {
106 |             self.0
107 |                 .method_hash([120, 94, 7, 179], to)
108 |                 .expect("method not found (this should never happen)")
109 |         }
110 |     }
111 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>>
112 |         for SelfdestructTransfer<M>
113 |     {
114 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
115 |             Self(contract)
116 |         }
117 |     }
118 |     #[doc = "Container type for all input parameters for the `destroyAndTransfer` function with signature `destroyAndTransfer(address)` and selector `[120, 94, 7, 179]`"]
119 |     #[derive(
120 |         Clone,
121 |         Debug,
122 |         Default,
123 |         Eq,
124 |         PartialEq,
125 |         ethers :: contract :: EthCall,
126 |         ethers :: contract :: EthDisplay,
127 |     )]
128 |     #[ethcall(name = "destroyAndTransfer", abi = "destroyAndTransfer(address)")]
129 |     pub struct DestroyAndTransferCall {
130 |         pub to: ethers::core::types::Address,
131 |     }
132 | }
133 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/base_upgradeability_proxy.rs:
--------------------------------------------------------------------------------
  1 | pub use base_upgradeability_proxy::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod base_upgradeability_proxy {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "BaseUpgradeabilityProxy was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static BASEUPGRADEABILITYPROXY_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\",\"components\":[],\"indexed\":true}],\"type\":\"event\",\"name\":\"Upgraded\",\"outputs\":[],\"anonymous\":false},{\"inputs\":[],\"stateMutability\":\"payable\",\"type\":\"fallback\",\"outputs\":[]}]") . expect ("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static BASEUPGRADEABILITYPROXY_BYTECODE: ethers::contract::Lazy<
 25 |         ethers::core::types::Bytes,
 26 |     > = ethers::contract::Lazy::new(|| {
 27 |         "0x6080604052348015600f57600080fd5b5060948061001e6000396000f3fe6080604052600a600c565b005b603960357f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5490565b603b565b565b3660008037600080366000845af43d6000803e8080156059573d6000f35b3d6000fdfea2646970667358221220cc45cfde4ecffc2b59c346a11698b92584546f25516dc381866214a193bb11c464736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 28 |     });
 29 |     pub struct BaseUpgradeabilityProxy<M>(ethers::contract::Contract<M>);
 30 |     impl<M> Clone for BaseUpgradeabilityProxy<M> {
 31 |         fn clone(&self) -> Self {
 32 |             BaseUpgradeabilityProxy(self.0.clone())
 33 |         }
 34 |     }
 35 |     impl<M> std::ops::Deref for BaseUpgradeabilityProxy<M> {
 36 |         type Target = ethers::contract::Contract<M>;
 37 |         fn deref(&self) -> &Self::Target {
 38 |             &self.0
 39 |         }
 40 |     }
 41 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for BaseUpgradeabilityProxy<M> {
 42 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 43 |             f.debug_tuple(stringify!(BaseUpgradeabilityProxy))
 44 |                 .field(&self.address())
 45 |                 .finish()
 46 |         }
 47 |     }
 48 |     impl<M: ethers::providers::Middleware> BaseUpgradeabilityProxy<M> {
 49 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 50 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 51 |         #[doc = r" object"]
 52 |         pub fn new<T: Into<ethers::core::types::Address>>(
 53 |             address: T,
 54 |             client: ::std::sync::Arc<M>,
 55 |         ) -> Self {
 56 |             ethers::contract::Contract::new(
 57 |                 address.into(),
 58 |                 BASEUPGRADEABILITYPROXY_ABI.clone(),
 59 |                 client,
 60 |             )
 61 |             .into()
 62 |         }
 63 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 64 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 65 |         #[doc = r""]
 66 |         #[doc = r" Notes:"]
 67 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 68 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 69 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 70 |         #[doc = r""]
 71 |         #[doc = r""]
 72 |         #[doc = r" # Example"]
 73 |         #[doc = r""]
 74 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 75 |         #[doc = r""]
 76 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 77 |         #[doc = r""]
 78 |         #[doc = r" ```ignore"]
 79 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 80 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 81 |         #[doc = r""]
 82 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 83 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 84 |         #[doc = r" # }"]
 85 |         #[doc = r" ```"]
 86 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 87 |             client: ::std::sync::Arc<M>,
 88 |             constructor_args: T,
 89 |         ) -> ::std::result::Result<
 90 |             ethers::contract::builders::ContractDeployer<M, Self>,
 91 |             ethers::contract::ContractError<M>,
 92 |         > {
 93 |             let factory = ethers::contract::ContractFactory::new(
 94 |                 BASEUPGRADEABILITYPROXY_ABI.clone(),
 95 |                 BASEUPGRADEABILITYPROXY_BYTECODE.clone().into(),
 96 |                 client,
 97 |             );
 98 |             let deployer = factory.deploy(constructor_args)?;
 99 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
100 |             Ok(deployer)
101 |         }
102 |         #[doc = "Gets the contract's `Upgraded` event"]
103 |         pub fn upgraded_filter(&self) -> ethers::contract::builders::Event<M, UpgradedFilter> {
104 |             self.0.event()
105 |         }
106 |         #[doc = r" Returns an [`Event`](#ethers_contract::builders::Event) builder for all events of this contract"]
107 |         pub fn events(&self) -> ethers::contract::builders::Event<M, UpgradedFilter> {
108 |             self.0.event_with_filter(Default::default())
109 |         }
110 |     }
111 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>>
112 |         for BaseUpgradeabilityProxy<M>
113 |     {
114 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
115 |             Self(contract)
116 |         }
117 |     }
118 |     #[derive(
119 |         Clone,
120 |         Debug,
121 |         Default,
122 |         Eq,
123 |         PartialEq,
124 |         ethers :: contract :: EthEvent,
125 |         ethers :: contract :: EthDisplay,
126 |     )]
127 |     #[ethevent(name = "Upgraded", abi = "Upgraded(address)")]
128 |     pub struct UpgradedFilter {
129 |         #[ethevent(indexed)]
130 |         pub implementation: ethers::core::types::Address,
131 |     }
132 | }
133 | 


--------------------------------------------------------------------------------
/compound/src/contracts/c_erc_20_storage.rs:
--------------------------------------------------------------------------------
  1 | pub use c_erc_20_storage::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod c_erc_20_storage {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "CErc20Storage was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static CERC20STORAGE_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[],\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"underlying\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\",\"components\":[]}]}]") . expect ("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static CERC20STORAGE_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x6080604052348015600f57600080fd5b5060938061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c80636f307dc314602d575b600080fd5b6033604f565b604080516001600160a01b039092168252519081900360200190f35b6000546001600160a01b03168156fea265627a7a723158206fc3afcb8b922a5a5069b61a274f81b81ec6903ecce16c7f5d2dabd709020ba164736f6c63430005110032" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct CErc20Storage<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for CErc20Storage<M> {
 30 |         fn clone(&self) -> Self {
 31 |             CErc20Storage(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for CErc20Storage<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for CErc20Storage<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(CErc20Storage))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> CErc20Storage<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), CERC20STORAGE_ABI.clone(), client)
 56 |                 .into()
 57 |         }
 58 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 59 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 60 |         #[doc = r""]
 61 |         #[doc = r" Notes:"]
 62 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 63 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 64 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 65 |         #[doc = r""]
 66 |         #[doc = r""]
 67 |         #[doc = r" # Example"]
 68 |         #[doc = r""]
 69 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 70 |         #[doc = r""]
 71 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 72 |         #[doc = r""]
 73 |         #[doc = r" ```ignore"]
 74 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 75 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 76 |         #[doc = r""]
 77 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 78 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 79 |         #[doc = r" # }"]
 80 |         #[doc = r" ```"]
 81 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 82 |             client: ::std::sync::Arc<M>,
 83 |             constructor_args: T,
 84 |         ) -> ::std::result::Result<
 85 |             ethers::contract::builders::ContractDeployer<M, Self>,
 86 |             ethers::contract::ContractError<M>,
 87 |         > {
 88 |             let factory = ethers::contract::ContractFactory::new(
 89 |                 CERC20STORAGE_ABI.clone(),
 90 |                 CERC20STORAGE_BYTECODE.clone().into(),
 91 |                 client,
 92 |             );
 93 |             let deployer = factory.deploy(constructor_args)?;
 94 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 95 |             Ok(deployer)
 96 |         }
 97 |         #[doc = "Calls the contract's `underlying` (0x6f307dc3) function"]
 98 |         pub fn underlying(
 99 |             &self,
100 |         ) -> ethers::contract::builders::ContractCall<M, ethers::core::types::Address> {
101 |             self.0
102 |                 .method_hash([111, 48, 125, 195], ())
103 |                 .expect("method not found (this should never happen)")
104 |         }
105 |     }
106 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for CErc20Storage<M> {
107 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
108 |             Self(contract)
109 |         }
110 |     }
111 |     #[doc = "Container type for all input parameters for the `underlying` function with signature `underlying()` and selector `[111, 48, 125, 195]`"]
112 |     #[derive(
113 |         Clone,
114 |         Debug,
115 |         Default,
116 |         Eq,
117 |         PartialEq,
118 |         ethers :: contract :: EthCall,
119 |         ethers :: contract :: EthDisplay,
120 |     )]
121 |     #[ethcall(name = "underlying", abi = "underlying()")]
122 |     pub struct UnderlyingCall;
123 |     #[doc = "Container type for all return fields from the `underlying` function with signature `underlying()` and selector `[111, 48, 125, 195]`"]
124 |     #[derive(
125 |         Clone,
126 |         Debug,
127 |         Default,
128 |         Eq,
129 |         PartialEq,
130 |         ethers :: contract :: EthAbiType,
131 |         ethers :: contract :: EthAbiCodec,
132 |     )]
133 |     pub struct UnderlyingReturn(pub ethers::core::types::Address);
134 | }
135 | 


--------------------------------------------------------------------------------
/compound/src/contracts/comptroller_error_reporter.rs:
--------------------------------------------------------------------------------
  1 | pub use comptroller_error_reporter::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod comptroller_error_reporter {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "ComptrollerErrorReporter was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static COMPTROLLERERRORREPORTER_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"error\",\"type\":\"uint256\",\"components\":[],\"indexed\":false},{\"internalType\":\"uint256\",\"name\":\"info\",\"type\":\"uint256\",\"components\":[],\"indexed\":false},{\"internalType\":\"uint256\",\"name\":\"detail\",\"type\":\"uint256\",\"components\":[],\"indexed\":false}],\"type\":\"event\",\"name\":\"Failure\",\"outputs\":[],\"anonymous\":false}]") . expect ("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static COMPTROLLERERRORREPORTER_BYTECODE: ethers::contract::Lazy<
 25 |         ethers::core::types::Bytes,
 26 |     > = ethers::contract::Lazy::new(|| {
 27 |         "0x6080604052348015600f57600080fd5b50603e80601d6000396000f3fe6080604052600080fdfea265627a7a72315820d495d1cfd6be77ab7ecb5b899e0d60a3cb7292d80243811b875b4bd081d4a7a364736f6c63430005110032" . parse () . expect ("invalid bytecode")
 28 |     });
 29 |     pub struct ComptrollerErrorReporter<M>(ethers::contract::Contract<M>);
 30 |     impl<M> Clone for ComptrollerErrorReporter<M> {
 31 |         fn clone(&self) -> Self {
 32 |             ComptrollerErrorReporter(self.0.clone())
 33 |         }
 34 |     }
 35 |     impl<M> std::ops::Deref for ComptrollerErrorReporter<M> {
 36 |         type Target = ethers::contract::Contract<M>;
 37 |         fn deref(&self) -> &Self::Target {
 38 |             &self.0
 39 |         }
 40 |     }
 41 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for ComptrollerErrorReporter<M> {
 42 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 43 |             f.debug_tuple(stringify!(ComptrollerErrorReporter))
 44 |                 .field(&self.address())
 45 |                 .finish()
 46 |         }
 47 |     }
 48 |     impl<M: ethers::providers::Middleware> ComptrollerErrorReporter<M> {
 49 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 50 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 51 |         #[doc = r" object"]
 52 |         pub fn new<T: Into<ethers::core::types::Address>>(
 53 |             address: T,
 54 |             client: ::std::sync::Arc<M>,
 55 |         ) -> Self {
 56 |             ethers::contract::Contract::new(
 57 |                 address.into(),
 58 |                 COMPTROLLERERRORREPORTER_ABI.clone(),
 59 |                 client,
 60 |             )
 61 |             .into()
 62 |         }
 63 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 64 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 65 |         #[doc = r""]
 66 |         #[doc = r" Notes:"]
 67 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 68 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 69 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 70 |         #[doc = r""]
 71 |         #[doc = r""]
 72 |         #[doc = r" # Example"]
 73 |         #[doc = r""]
 74 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 75 |         #[doc = r""]
 76 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 77 |         #[doc = r""]
 78 |         #[doc = r" ```ignore"]
 79 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 80 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 81 |         #[doc = r""]
 82 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 83 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 84 |         #[doc = r" # }"]
 85 |         #[doc = r" ```"]
 86 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 87 |             client: ::std::sync::Arc<M>,
 88 |             constructor_args: T,
 89 |         ) -> ::std::result::Result<
 90 |             ethers::contract::builders::ContractDeployer<M, Self>,
 91 |             ethers::contract::ContractError<M>,
 92 |         > {
 93 |             let factory = ethers::contract::ContractFactory::new(
 94 |                 COMPTROLLERERRORREPORTER_ABI.clone(),
 95 |                 COMPTROLLERERRORREPORTER_BYTECODE.clone().into(),
 96 |                 client,
 97 |             );
 98 |             let deployer = factory.deploy(constructor_args)?;
 99 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
100 |             Ok(deployer)
101 |         }
102 |         #[doc = "Gets the contract's `Failure` event"]
103 |         pub fn failure_filter(&self) -> ethers::contract::builders::Event<M, FailureFilter> {
104 |             self.0.event()
105 |         }
106 |         #[doc = r" Returns an [`Event`](#ethers_contract::builders::Event) builder for all events of this contract"]
107 |         pub fn events(&self) -> ethers::contract::builders::Event<M, FailureFilter> {
108 |             self.0.event_with_filter(Default::default())
109 |         }
110 |     }
111 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>>
112 |         for ComptrollerErrorReporter<M>
113 |     {
114 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
115 |             Self(contract)
116 |         }
117 |     }
118 |     #[derive(
119 |         Clone,
120 |         Debug,
121 |         Default,
122 |         Eq,
123 |         PartialEq,
124 |         ethers :: contract :: EthEvent,
125 |         ethers :: contract :: EthDisplay,
126 |     )]
127 |     #[ethevent(name = "Failure", abi = "Failure(uint256,uint256,uint256)")]
128 |     pub struct FailureFilter {
129 |         pub error: ethers::core::types::U256,
130 |         pub info: ethers::core::types::U256,
131 |         pub detail: ethers::core::types::U256,
132 |     }
133 | }
134 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/isolation_mode_logic.rs:
--------------------------------------------------------------------------------
  1 | pub use isolation_mode_logic::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod isolation_mode_logic {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "IsolationModeLogic was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static ISOLATIONMODELOGIC_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\",\"components\":[],\"indexed\":true},{\"internalType\":\"uint256\",\"name\":\"totalDebt\",\"type\":\"uint256\",\"components\":[],\"indexed\":false}],\"type\":\"event\",\"name\":\"IsolationModeTotalDebtUpdated\",\"outputs\":[],\"anonymous\":false}]") . expect ("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static ISOLATIONMODELOGIC_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212209498989520f8f7538ce765168970d0819cf1627a3d4841e164883f09a606334e64736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct IsolationModeLogic<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for IsolationModeLogic<M> {
 30 |         fn clone(&self) -> Self {
 31 |             IsolationModeLogic(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for IsolationModeLogic<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for IsolationModeLogic<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(IsolationModeLogic))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> IsolationModeLogic<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), ISOLATIONMODELOGIC_ABI.clone(), client)
 56 |                 .into()
 57 |         }
 58 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 59 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 60 |         #[doc = r""]
 61 |         #[doc = r" Notes:"]
 62 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 63 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 64 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 65 |         #[doc = r""]
 66 |         #[doc = r""]
 67 |         #[doc = r" # Example"]
 68 |         #[doc = r""]
 69 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 70 |         #[doc = r""]
 71 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 72 |         #[doc = r""]
 73 |         #[doc = r" ```ignore"]
 74 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 75 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 76 |         #[doc = r""]
 77 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 78 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 79 |         #[doc = r" # }"]
 80 |         #[doc = r" ```"]
 81 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 82 |             client: ::std::sync::Arc<M>,
 83 |             constructor_args: T,
 84 |         ) -> ::std::result::Result<
 85 |             ethers::contract::builders::ContractDeployer<M, Self>,
 86 |             ethers::contract::ContractError<M>,
 87 |         > {
 88 |             let factory = ethers::contract::ContractFactory::new(
 89 |                 ISOLATIONMODELOGIC_ABI.clone(),
 90 |                 ISOLATIONMODELOGIC_BYTECODE.clone().into(),
 91 |                 client,
 92 |             );
 93 |             let deployer = factory.deploy(constructor_args)?;
 94 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 95 |             Ok(deployer)
 96 |         }
 97 |         #[doc = "Gets the contract's `IsolationModeTotalDebtUpdated` event"]
 98 |         pub fn isolation_mode_total_debt_updated_filter(
 99 |             &self,
100 |         ) -> ethers::contract::builders::Event<M, IsolationModeTotalDebtUpdatedFilter> {
101 |             self.0.event()
102 |         }
103 |         #[doc = r" Returns an [`Event`](#ethers_contract::builders::Event) builder for all events of this contract"]
104 |         pub fn events(
105 |             &self,
106 |         ) -> ethers::contract::builders::Event<M, IsolationModeTotalDebtUpdatedFilter> {
107 |             self.0.event_with_filter(Default::default())
108 |         }
109 |     }
110 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>>
111 |         for IsolationModeLogic<M>
112 |     {
113 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
114 |             Self(contract)
115 |         }
116 |     }
117 |     #[derive(
118 |         Clone,
119 |         Debug,
120 |         Default,
121 |         Eq,
122 |         PartialEq,
123 |         ethers :: contract :: EthEvent,
124 |         ethers :: contract :: EthDisplay,
125 |     )]
126 |     #[ethevent(
127 |         name = "IsolationModeTotalDebtUpdated",
128 |         abi = "IsolationModeTotalDebtUpdated(address,uint256)"
129 |     )]
130 |     pub struct IsolationModeTotalDebtUpdatedFilter {
131 |         #[ethevent(indexed)]
132 |         pub asset: ethers::core::types::Address,
133 |         pub total_debt: ethers::core::types::U256,
134 |     }
135 | }
136 | 


--------------------------------------------------------------------------------
/compound/src/contracts/vat_like.rs:
--------------------------------------------------------------------------------
  1 | pub use vat_like::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod vat_like {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "VatLike was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static VATLIKE_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\",\"components\":[]}],\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"dai\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\",\"components\":[]}]},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\",\"components\":[]}],\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"hope\",\"outputs\":[]}]") . expect ("invalid abi")
 22 |         });
 23 |     pub struct VatLike<M>(ethers::contract::Contract<M>);
 24 |     impl<M> Clone for VatLike<M> {
 25 |         fn clone(&self) -> Self {
 26 |             VatLike(self.0.clone())
 27 |         }
 28 |     }
 29 |     impl<M> std::ops::Deref for VatLike<M> {
 30 |         type Target = ethers::contract::Contract<M>;
 31 |         fn deref(&self) -> &Self::Target {
 32 |             &self.0
 33 |         }
 34 |     }
 35 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for VatLike<M> {
 36 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 37 |             f.debug_tuple(stringify!(VatLike))
 38 |                 .field(&self.address())
 39 |                 .finish()
 40 |         }
 41 |     }
 42 |     impl<M: ethers::providers::Middleware> VatLike<M> {
 43 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 44 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 45 |         #[doc = r" object"]
 46 |         pub fn new<T: Into<ethers::core::types::Address>>(
 47 |             address: T,
 48 |             client: ::std::sync::Arc<M>,
 49 |         ) -> Self {
 50 |             ethers::contract::Contract::new(address.into(), VATLIKE_ABI.clone(), client).into()
 51 |         }
 52 |         #[doc = "Calls the contract's `dai` (0x6c25b346) function"]
 53 |         pub fn dai(
 54 |             &self,
 55 |             p0: ethers::core::types::Address,
 56 |         ) -> ethers::contract::builders::ContractCall<M, ethers::core::types::U256> {
 57 |             self.0
 58 |                 .method_hash([108, 37, 179, 70], p0)
 59 |                 .expect("method not found (this should never happen)")
 60 |         }
 61 |         #[doc = "Calls the contract's `hope` (0xa3b22fc4) function"]
 62 |         pub fn hope(
 63 |             &self,
 64 |             p0: ethers::core::types::Address,
 65 |         ) -> ethers::contract::builders::ContractCall<M, ()> {
 66 |             self.0
 67 |                 .method_hash([163, 178, 47, 196], p0)
 68 |                 .expect("method not found (this should never happen)")
 69 |         }
 70 |     }
 71 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for VatLike<M> {
 72 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 73 |             Self(contract)
 74 |         }
 75 |     }
 76 |     #[doc = "Container type for all input parameters for the `dai` function with signature `dai(address)` and selector `[108, 37, 179, 70]`"]
 77 |     #[derive(
 78 |         Clone,
 79 |         Debug,
 80 |         Default,
 81 |         Eq,
 82 |         PartialEq,
 83 |         ethers :: contract :: EthCall,
 84 |         ethers :: contract :: EthDisplay,
 85 |     )]
 86 |     #[ethcall(name = "dai", abi = "dai(address)")]
 87 |     pub struct DaiCall(pub ethers::core::types::Address);
 88 |     #[doc = "Container type for all input parameters for the `hope` function with signature `hope(address)` and selector `[163, 178, 47, 196]`"]
 89 |     #[derive(
 90 |         Clone,
 91 |         Debug,
 92 |         Default,
 93 |         Eq,
 94 |         PartialEq,
 95 |         ethers :: contract :: EthCall,
 96 |         ethers :: contract :: EthDisplay,
 97 |     )]
 98 |     #[ethcall(name = "hope", abi = "hope(address)")]
 99 |     pub struct HopeCall(pub ethers::core::types::Address);
100 |     #[derive(Debug, Clone, PartialEq, Eq, ethers :: contract :: EthAbiType)]
101 |     pub enum VatLikeCalls {
102 |         Dai(DaiCall),
103 |         Hope(HopeCall),
104 |     }
105 |     impl ethers::core::abi::AbiDecode for VatLikeCalls {
106 |         fn decode(
107 |             data: impl AsRef<[u8]>,
108 |         ) -> ::std::result::Result<Self, ethers::core::abi::AbiError> {
109 |             if let Ok(decoded) = <DaiCall as ethers::core::abi::AbiDecode>::decode(data.as_ref()) {
110 |                 return Ok(VatLikeCalls::Dai(decoded));
111 |             }
112 |             if let Ok(decoded) = <HopeCall as ethers::core::abi::AbiDecode>::decode(data.as_ref()) {
113 |                 return Ok(VatLikeCalls::Hope(decoded));
114 |             }
115 |             Err(ethers::core::abi::Error::InvalidData.into())
116 |         }
117 |     }
118 |     impl ethers::core::abi::AbiEncode for VatLikeCalls {
119 |         fn encode(self) -> Vec<u8> {
120 |             match self {
121 |                 VatLikeCalls::Dai(element) => element.encode(),
122 |                 VatLikeCalls::Hope(element) => element.encode(),
123 |             }
124 |         }
125 |     }
126 |     impl ::std::fmt::Display for VatLikeCalls {
127 |         fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
128 |             match self {
129 |                 VatLikeCalls::Dai(element) => element.fmt(f),
130 |                 VatLikeCalls::Hope(element) => element.fmt(f),
131 |             }
132 |         }
133 |     }
134 |     impl ::std::convert::From<DaiCall> for VatLikeCalls {
135 |         fn from(var: DaiCall) -> Self {
136 |             VatLikeCalls::Dai(var)
137 |         }
138 |     }
139 |     impl ::std::convert::From<HopeCall> for VatLikeCalls {
140 |         fn from(var: HopeCall) -> Self {
141 |             VatLikeCalls::Hope(var)
142 |         }
143 |     }
144 |     #[doc = "Container type for all return fields from the `dai` function with signature `dai(address)` and selector `[108, 37, 179, 70]`"]
145 |     #[derive(
146 |         Clone,
147 |         Debug,
148 |         Default,
149 |         Eq,
150 |         PartialEq,
151 |         ethers :: contract :: EthAbiType,
152 |         ethers :: contract :: EthAbiCodec,
153 |     )]
154 |     pub struct DaiReturn(pub ethers::core::types::U256);
155 | }
156 | 


--------------------------------------------------------------------------------
/compound/src/contracts/c_delegation_storage.rs:
--------------------------------------------------------------------------------
  1 | pub use c_delegation_storage::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod c_delegation_storage {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "CDelegationStorage was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static CDELEGATIONSTORAGE_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[],\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"implementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\",\"components\":[]}]}]") . expect ("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static CDELEGATIONSTORAGE_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x6080604052348015600f57600080fd5b5060938061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c80635c60da1b14602d575b600080fd5b6033604f565b604080516001600160a01b039092168252519081900360200190f35b6000546001600160a01b03168156fea265627a7a72315820e6f2b81db997ef7ee263e553256d2614b85cb9f38aa95eb6c6484341dd6e0ba064736f6c63430005110032" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct CDelegationStorage<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for CDelegationStorage<M> {
 30 |         fn clone(&self) -> Self {
 31 |             CDelegationStorage(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for CDelegationStorage<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for CDelegationStorage<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(CDelegationStorage))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> CDelegationStorage<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), CDELEGATIONSTORAGE_ABI.clone(), client)
 56 |                 .into()
 57 |         }
 58 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 59 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 60 |         #[doc = r""]
 61 |         #[doc = r" Notes:"]
 62 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 63 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 64 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 65 |         #[doc = r""]
 66 |         #[doc = r""]
 67 |         #[doc = r" # Example"]
 68 |         #[doc = r""]
 69 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 70 |         #[doc = r""]
 71 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 72 |         #[doc = r""]
 73 |         #[doc = r" ```ignore"]
 74 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 75 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 76 |         #[doc = r""]
 77 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 78 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 79 |         #[doc = r" # }"]
 80 |         #[doc = r" ```"]
 81 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 82 |             client: ::std::sync::Arc<M>,
 83 |             constructor_args: T,
 84 |         ) -> ::std::result::Result<
 85 |             ethers::contract::builders::ContractDeployer<M, Self>,
 86 |             ethers::contract::ContractError<M>,
 87 |         > {
 88 |             let factory = ethers::contract::ContractFactory::new(
 89 |                 CDELEGATIONSTORAGE_ABI.clone(),
 90 |                 CDELEGATIONSTORAGE_BYTECODE.clone().into(),
 91 |                 client,
 92 |             );
 93 |             let deployer = factory.deploy(constructor_args)?;
 94 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 95 |             Ok(deployer)
 96 |         }
 97 |         #[doc = "Calls the contract's `implementation` (0x5c60da1b) function"]
 98 |         pub fn implementation(
 99 |             &self,
100 |         ) -> ethers::contract::builders::ContractCall<M, ethers::core::types::Address> {
101 |             self.0
102 |                 .method_hash([92, 96, 218, 27], ())
103 |                 .expect("method not found (this should never happen)")
104 |         }
105 |     }
106 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>>
107 |         for CDelegationStorage<M>
108 |     {
109 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
110 |             Self(contract)
111 |         }
112 |     }
113 |     #[doc = "Container type for all input parameters for the `implementation` function with signature `implementation()` and selector `[92, 96, 218, 27]`"]
114 |     #[derive(
115 |         Clone,
116 |         Debug,
117 |         Default,
118 |         Eq,
119 |         PartialEq,
120 |         ethers :: contract :: EthCall,
121 |         ethers :: contract :: EthDisplay,
122 |     )]
123 |     #[ethcall(name = "implementation", abi = "implementation()")]
124 |     pub struct ImplementationCall;
125 |     #[doc = "Container type for all return fields from the `implementation` function with signature `implementation()` and selector `[92, 96, 218, 27]`"]
126 |     #[derive(
127 |         Clone,
128 |         Debug,
129 |         Default,
130 |         Eq,
131 |         PartialEq,
132 |         ethers :: contract :: EthAbiType,
133 |         ethers :: contract :: EthAbiCodec,
134 |     )]
135 |     pub struct ImplementationReturn(pub ethers::core::types::Address);
136 | }
137 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/reserve_logic.rs:
--------------------------------------------------------------------------------
  1 | pub use reserve_logic::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod reserve_logic {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "ReserveLogic was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static RESERVELOGIC_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"reserve\",\"type\":\"address\",\"components\":[],\"indexed\":true},{\"internalType\":\"uint256\",\"name\":\"liquidityRate\",\"type\":\"uint256\",\"components\":[],\"indexed\":false},{\"internalType\":\"uint256\",\"name\":\"stableBorrowRate\",\"type\":\"uint256\",\"components\":[],\"indexed\":false},{\"internalType\":\"uint256\",\"name\":\"variableBorrowRate\",\"type\":\"uint256\",\"components\":[],\"indexed\":false},{\"internalType\":\"uint256\",\"name\":\"liquidityIndex\",\"type\":\"uint256\",\"components\":[],\"indexed\":false},{\"internalType\":\"uint256\",\"name\":\"variableBorrowIndex\",\"type\":\"uint256\",\"components\":[],\"indexed\":false}],\"type\":\"event\",\"name\":\"ReserveDataUpdated\",\"outputs\":[],\"anonymous\":false}]") . expect ("invalid abi")
 22 |         });
 23 |     #[doc = r" Bytecode of the #name contract"]
 24 |     pub static RESERVELOGIC_BYTECODE: ethers::contract::Lazy<ethers::core::types::Bytes> =
 25 |         ethers::contract::Lazy::new(|| {
 26 |             "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212206feb1ef3e4beecfe12827ceb425ef3a68ce7b6bc079ded7142c234476b751d3664736f6c634300080a0033" . parse () . expect ("invalid bytecode")
 27 |         });
 28 |     pub struct ReserveLogic<M>(ethers::contract::Contract<M>);
 29 |     impl<M> Clone for ReserveLogic<M> {
 30 |         fn clone(&self) -> Self {
 31 |             ReserveLogic(self.0.clone())
 32 |         }
 33 |     }
 34 |     impl<M> std::ops::Deref for ReserveLogic<M> {
 35 |         type Target = ethers::contract::Contract<M>;
 36 |         fn deref(&self) -> &Self::Target {
 37 |             &self.0
 38 |         }
 39 |     }
 40 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for ReserveLogic<M> {
 41 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 42 |             f.debug_tuple(stringify!(ReserveLogic))
 43 |                 .field(&self.address())
 44 |                 .finish()
 45 |         }
 46 |     }
 47 |     impl<M: ethers::providers::Middleware> ReserveLogic<M> {
 48 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 49 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 50 |         #[doc = r" object"]
 51 |         pub fn new<T: Into<ethers::core::types::Address>>(
 52 |             address: T,
 53 |             client: ::std::sync::Arc<M>,
 54 |         ) -> Self {
 55 |             ethers::contract::Contract::new(address.into(), RESERVELOGIC_ABI.clone(), client).into()
 56 |         }
 57 |         #[doc = r" Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it."]
 58 |         #[doc = r" Returns a new instance of a deployer that returns an instance of this contract after sending the transaction"]
 59 |         #[doc = r""]
 60 |         #[doc = r" Notes:"]
 61 |         #[doc = r" 1. If there are no constructor arguments, you should pass `()` as the argument."]
 62 |         #[doc = r" 1. The default poll duration is 7 seconds."]
 63 |         #[doc = r" 1. The default number of confirmations is 1 block."]
 64 |         #[doc = r""]
 65 |         #[doc = r""]
 66 |         #[doc = r" # Example"]
 67 |         #[doc = r""]
 68 |         #[doc = r" Generate contract bindings with `abigen!` and deploy a new contract instance."]
 69 |         #[doc = r""]
 70 |         #[doc = r" *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact."]
 71 |         #[doc = r""]
 72 |         #[doc = r" ```ignore"]
 73 |         #[doc = r" # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {"]
 74 |         #[doc = r#"     abigen!(Greeter,"../greeter.json");"#]
 75 |         #[doc = r""]
 76 |         #[doc = r#"    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();"#]
 77 |         #[doc = r"    let msg = greeter_contract.greet().call().await.unwrap();"]
 78 |         #[doc = r" # }"]
 79 |         #[doc = r" ```"]
 80 |         pub fn deploy<T: ethers::core::abi::Tokenize>(
 81 |             client: ::std::sync::Arc<M>,
 82 |             constructor_args: T,
 83 |         ) -> ::std::result::Result<
 84 |             ethers::contract::builders::ContractDeployer<M, Self>,
 85 |             ethers::contract::ContractError<M>,
 86 |         > {
 87 |             let factory = ethers::contract::ContractFactory::new(
 88 |                 RESERVELOGIC_ABI.clone(),
 89 |                 RESERVELOGIC_BYTECODE.clone().into(),
 90 |                 client,
 91 |             );
 92 |             let deployer = factory.deploy(constructor_args)?;
 93 |             let deployer = ethers::contract::ContractDeployer::new(deployer);
 94 |             Ok(deployer)
 95 |         }
 96 |         #[doc = "Gets the contract's `ReserveDataUpdated` event"]
 97 |         pub fn reserve_data_updated_filter(
 98 |             &self,
 99 |         ) -> ethers::contract::builders::Event<M, ReserveDataUpdatedFilter> {
100 |             self.0.event()
101 |         }
102 |         #[doc = r" Returns an [`Event`](#ethers_contract::builders::Event) builder for all events of this contract"]
103 |         pub fn events(&self) -> ethers::contract::builders::Event<M, ReserveDataUpdatedFilter> {
104 |             self.0.event_with_filter(Default::default())
105 |         }
106 |     }
107 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for ReserveLogic<M> {
108 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
109 |             Self(contract)
110 |         }
111 |     }
112 |     #[derive(
113 |         Clone,
114 |         Debug,
115 |         Default,
116 |         Eq,
117 |         PartialEq,
118 |         ethers :: contract :: EthEvent,
119 |         ethers :: contract :: EthDisplay,
120 |     )]
121 |     #[ethevent(
122 |         name = "ReserveDataUpdated",
123 |         abi = "ReserveDataUpdated(address,uint256,uint256,uint256,uint256,uint256)"
124 |     )]
125 |     pub struct ReserveDataUpdatedFilter {
126 |         #[ethevent(indexed)]
127 |         pub reserve: ethers::core::types::Address,
128 |         pub liquidity_rate: ethers::core::types::U256,
129 |         pub stable_borrow_rate: ethers::core::types::U256,
130 |         pub variable_borrow_rate: ethers::core::types::U256,
131 |         pub liquidity_index: ethers::core::types::U256,
132 |         pub variable_borrow_index: ethers::core::types::U256,
133 |     }
134 | }
135 | 


--------------------------------------------------------------------------------
/aave-v3/src/contracts/i_price_oracle.rs:
--------------------------------------------------------------------------------
  1 | pub use i_price_oracle::*;
  2 | #[allow(clippy::too_many_arguments, non_camel_case_types)]
  3 | pub mod i_price_oracle {
  4 |     #![allow(clippy::enum_variant_names)]
  5 |     #![allow(dead_code)]
  6 |     #![allow(clippy::type_complexity)]
  7 |     #![allow(unused_imports)]
  8 |     use ethers::contract::{
  9 |         builders::{ContractCall, Event},
 10 |         Contract, Lazy,
 11 |     };
 12 |     use ethers::core::{
 13 |         abi::{Abi, Detokenize, InvalidOutputType, Token, Tokenizable},
 14 |         types::*,
 15 |     };
 16 |     use ethers::providers::Middleware;
 17 |     #[doc = "IPriceOracle was auto-generated with ethers-rs Abigen. More information at: https://github.com/gakonst/ethers-rs"]
 18 |     use std::sync::Arc;
 19 |     pub static IPRICEORACLE_ABI: ethers::contract::Lazy<ethers::core::abi::Abi> =
 20 |         ethers::contract::Lazy::new(|| {
 21 |             ethers :: core :: utils :: __serde_json :: from_str ("[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\",\"components\":[]}],\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"getAssetPrice\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\",\"components\":[]}]},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\",\"components\":[]},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\",\"components\":[]}],\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"setAssetPrice\",\"outputs\":[]}]") . expect ("invalid abi")
 22 |         });
 23 |     pub struct IPriceOracle<M>(ethers::contract::Contract<M>);
 24 |     impl<M> Clone for IPriceOracle<M> {
 25 |         fn clone(&self) -> Self {
 26 |             IPriceOracle(self.0.clone())
 27 |         }
 28 |     }
 29 |     impl<M> std::ops::Deref for IPriceOracle<M> {
 30 |         type Target = ethers::contract::Contract<M>;
 31 |         fn deref(&self) -> &Self::Target {
 32 |             &self.0
 33 |         }
 34 |     }
 35 |     impl<M: ethers::providers::Middleware> std::fmt::Debug for IPriceOracle<M> {
 36 |         fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 37 |             f.debug_tuple(stringify!(IPriceOracle))
 38 |                 .field(&self.address())
 39 |                 .finish()
 40 |         }
 41 |     }
 42 |     impl<M: ethers::providers::Middleware> IPriceOracle<M> {
 43 |         #[doc = r" Creates a new contract instance with the specified `ethers`"]
 44 |         #[doc = r" client at the given `Address`. The contract derefs to a `ethers::Contract`"]
 45 |         #[doc = r" object"]
 46 |         pub fn new<T: Into<ethers::core::types::Address>>(
 47 |             address: T,
 48 |             client: ::std::sync::Arc<M>,
 49 |         ) -> Self {
 50 |             ethers::contract::Contract::new(address.into(), IPRICEORACLE_ABI.clone(), client).into()
 51 |         }
 52 |         #[doc = "Calls the contract's `getAssetPrice` (0xb3596f07) function"]
 53 |         pub fn get_asset_price(
 54 |             &self,
 55 |             asset: ethers::core::types::Address,
 56 |         ) -> ethers::contract::builders::ContractCall<M, ethers::core::types::U256> {
 57 |             self.0
 58 |                 .method_hash([179, 89, 111, 7], asset)
 59 |                 .expect("method not found (this should never happen)")
 60 |         }
 61 |         #[doc = "Calls the contract's `setAssetPrice` (0x51323f72) function"]
 62 |         pub fn set_asset_price(
 63 |             &self,
 64 |             asset: ethers::core::types::Address,
 65 |             price: ethers::core::types::U256,
 66 |         ) -> ethers::contract::builders::ContractCall<M, ()> {
 67 |             self.0
 68 |                 .method_hash([81, 50, 63, 114], (asset, price))
 69 |                 .expect("method not found (this should never happen)")
 70 |         }
 71 |     }
 72 |     impl<M: ethers::providers::Middleware> From<ethers::contract::Contract<M>> for IPriceOracle<M> {
 73 |         fn from(contract: ethers::contract::Contract<M>) -> Self {
 74 |             Self(contract)
 75 |         }
 76 |     }
 77 |     #[doc = "Container type for all input parameters for the `getAssetPrice` function with signature `getAssetPrice(address)` and selector `[179, 89, 111, 7]`"]
 78 |     #[derive(
 79 |         Clone,
 80 |         Debug,
 81 |         Default,
 82 |         Eq,
 83 |         PartialEq,
 84 |         ethers :: contract :: EthCall,
 85 |         ethers :: contract :: EthDisplay,
 86 |     )]
 87 |     #[ethcall(name = "getAssetPrice", abi = "getAssetPrice(address)")]
 88 |     pub struct GetAssetPriceCall {
 89 |         pub asset: ethers::core::types::Address,
 90 |     }
 91 |     #[doc = "Container type for all input parameters for the `setAssetPrice` function with signature `setAssetPrice(address,uint256)` and selector `[81, 50, 63, 114]`"]
 92 |     #[derive(
 93 |         Clone,
 94 |         Debug,
 95 |         Default,
 96 |         Eq,
 97 |         PartialEq,
 98 |         ethers :: contract :: EthCall,
 99 |         ethers :: contract :: EthDisplay,
100 |     )]
101 |     #[ethcall(name = "setAssetPrice", abi = "setAssetPrice(address,uint256)")]
102 |     pub struct SetAssetPriceCall {
103 |         pub asset: ethers::core::types::Address,
104 |         pub price: ethers::core::types::U256,
105 |     }
106 |     #[derive(Debug, Clone, PartialEq, Eq, ethers :: contract :: EthAbiType)]
107 |     pub enum IPriceOracleCalls {
108 |         GetAssetPrice(GetAssetPriceCall),
109 |         SetAssetPrice(SetAssetPriceCall),
110 |     }
111 |     impl ethers::core::abi::AbiDecode for IPriceOracleCalls {
112 |         fn decode(
113 |             data: impl AsRef<[u8]>,
114 |         ) -> ::std::result::Result<Self, ethers::core::abi::AbiError> {
115 |             if let Ok(decoded) =
116 |                 <GetAssetPriceCall as ethers::core::abi::AbiDecode>::decode(data.as_ref())
117 |             {
118 |                 return Ok(IPriceOracleCalls::GetAssetPrice(decoded));
119 |             }
120 |             if let Ok(decoded) =
121 |                 <SetAssetPriceCall as ethers::core::abi::AbiDecode>::decode(data.as_ref())
122 |             {
123 |                 return Ok(IPriceOracleCalls::SetAssetPrice(decoded));
124 |             }
125 |             Err(ethers::core::abi::Error::InvalidData.into())
126 |         }
127 |     }
128 |     impl ethers::core::abi::AbiEncode for IPriceOracleCalls {
129 |         fn encode(self) -> Vec<u8> {
130 |             match self {
131 |                 IPriceOracleCalls::GetAssetPrice(element) => element.encode(),
132 |                 IPriceOracleCalls::SetAssetPrice(element) => element.encode(),
133 |             }
134 |         }
135 |     }
136 |     impl ::std::fmt::Display for IPriceOracleCalls {
137 |         fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
138 |             match self {
139 |                 IPriceOracleCalls::GetAssetPrice(element) => element.fmt(f),
140 |                 IPriceOracleCalls::SetAssetPrice(element) => element.fmt(f),
141 |             }
142 |         }
143 |     }
144 |     impl ::std::convert::From<GetAssetPriceCall> for IPriceOracleCalls {
145 |         fn from(var: GetAssetPriceCall) -> Self {
146 |             IPriceOracleCalls::GetAssetPrice(var)
147 |         }
148 |     }
149 |     impl ::std::convert::From<SetAssetPriceCall> for IPriceOracleCalls {
150 |         fn from(var: SetAssetPriceCall) -> Self {
151 |             IPriceOracleCalls::SetAssetPrice(var)
152 |         }
153 |     }
154 |     #[doc = "Container type for all return fields from the `getAssetPrice` function with signature `getAssetPrice(address)` and selector `[179, 89, 111, 7]`"]
155 |     #[derive(
156 |         Clone,
157 |         Debug,
158 |         Default,
159 |         Eq,
160 |         PartialEq,
161 |         ethers :: contract :: EthAbiType,
162 |         ethers :: contract :: EthAbiCodec,
163 |     )]
164 |     pub struct GetAssetPriceReturn(pub ethers::core::types::U256);
165 | }
166 | 


--------------------------------------------------------------------------------