openzeppelin_rs/contracts/
CrossChainEnabledAMB.rs

1pub use cross_chain_enabled_amb::*;
2/// This module was auto-generated with ethers-rs Abigen.
3/// More information at: <https://github.com/gakonst/ethers-rs>
4#[allow(
5    clippy::enum_variant_names,
6    clippy::too_many_arguments,
7    clippy::upper_case_acronyms,
8    clippy::type_complexity,
9    dead_code,
10    non_camel_case_types,
11)]
12pub mod cross_chain_enabled_amb {
13    #[rustfmt::skip]
14    const __ABI: &str = "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"bridge\",\"type\":\"address\",\"components\":[]}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\",\"outputs\":[]}]";
15    ///The parsed JSON ABI of the contract.
16    pub static CROSSCHAINENABLEDAMB_ABI: ::ethers_contract::Lazy<
17        ::ethers_core::abi::Abi,
18    > = ::ethers_contract::Lazy::new(|| {
19        ::ethers_core::utils::__serde_json::from_str(__ABI).expect("ABI is always valid")
20    });
21    #[rustfmt::skip]
22    const __BYTECODE: &[u8] = &[
23        96,
24        160,
25        96,
26        64,
27        82,
28        52,
29        128,
30        21,
31        96,
32        15,
33        87,
34        96,
35        0,
36        128,
37        253,
38        91,
39        80,
40        96,
41        64,
42        81,
43        96,
44        188,
45        56,
46        3,
47        128,
48        96,
49        188,
50        131,
51        57,
52        129,
53        1,
54        96,
55        64,
56        129,
57        144,
58        82,
59        96,
60        42,
61        145,
62        96,
63        58,
64        86,
65        91,
66        96,
67        1,
68        96,
69        1,
70        96,
71        160,
72        27,
73        3,
74        22,
75        96,
76        128,
77        82,
78        96,
79        104,
80        86,
81        91,
82        96,
83        0,
84        96,
85        32,
86        130,
87        132,
88        3,
89        18,
90        21,
91        96,
92        75,
93        87,
94        96,
95        0,
96        128,
97        253,
98        91,
99        129,
100        81,
101        96,
102        1,
103        96,
104        1,
105        96,
106        160,
107        27,
108        3,
109        129,
110        22,
111        129,
112        20,
113        96,
114        97,
115        87,
116        96,
117        0,
118        128,
119        253,
120        91,
121        147,
122        146,
123        80,
124        80,
125        80,
126        86,
127        91,
128        96,
129        128,
130        81,
131        96,
132        63,
133        96,
134        125,
135        96,
136        0,
137        57,
138        96,
139        0,
140        80,
141        80,
142        96,
143        63,
144        96,
145        0,
146        243,
147        254,
148        96,
149        128,
150        96,
151        64,
152        82,
153        96,
154        0,
155        128,
156        253,
157        254,
158        162,
159        100,
160        105,
161        112,
162        102,
163        115,
164        88,
165        34,
166        18,
167        32,
168        211,
169        66,
170        114,
171        86,
172        242,
173        204,
174        57,
175        102,
176        180,
177        50,
178        127,
179        12,
180        221,
181        237,
182        22,
183        243,
184        30,
185        162,
186        255,
187        106,
188        25,
189        215,
190        117,
191        214,
192        101,
193        172,
194        0,
195        41,
196        182,
197        82,
198        1,
199        59,
200        100,
201        115,
202        111,
203        108,
204        99,
205        67,
206        0,
207        8,
208        13,
209        0,
210        51,
211    ];
212    ///The bytecode of the contract.
213    pub static CROSSCHAINENABLEDAMB_BYTECODE: ::ethers_core::types::Bytes = ::ethers_core::types::Bytes::from_static(
214        __BYTECODE,
215    );
216    #[rustfmt::skip]
217    const __DEPLOYED_BYTECODE: &[u8] = &[
218        96,
219        128,
220        96,
221        64,
222        82,
223        96,
224        0,
225        128,
226        253,
227        254,
228        162,
229        100,
230        105,
231        112,
232        102,
233        115,
234        88,
235        34,
236        18,
237        32,
238        211,
239        66,
240        114,
241        86,
242        242,
243        204,
244        57,
245        102,
246        180,
247        50,
248        127,
249        12,
250        221,
251        237,
252        22,
253        243,
254        30,
255        162,
256        255,
257        106,
258        25,
259        215,
260        117,
261        214,
262        101,
263        172,
264        0,
265        41,
266        182,
267        82,
268        1,
269        59,
270        100,
271        115,
272        111,
273        108,
274        99,
275        67,
276        0,
277        8,
278        13,
279        0,
280        51,
281    ];
282    ///The deployed bytecode of the contract.
283    pub static CROSSCHAINENABLEDAMB_DEPLOYED_BYTECODE: ::ethers_core::types::Bytes = ::ethers_core::types::Bytes::from_static(
284        __DEPLOYED_BYTECODE,
285    );
286    pub struct CrossChainEnabledAMB<M>(::ethers_contract::Contract<M>);
287    impl<M> ::core::clone::Clone for CrossChainEnabledAMB<M> {
288        fn clone(&self) -> Self {
289            Self(::core::clone::Clone::clone(&self.0))
290        }
291    }
292    impl<M> ::core::ops::Deref for CrossChainEnabledAMB<M> {
293        type Target = ::ethers_contract::Contract<M>;
294        fn deref(&self) -> &Self::Target {
295            &self.0
296        }
297    }
298    impl<M> ::core::ops::DerefMut for CrossChainEnabledAMB<M> {
299        fn deref_mut(&mut self) -> &mut Self::Target {
300            &mut self.0
301        }
302    }
303    impl<M> ::core::fmt::Debug for CrossChainEnabledAMB<M> {
304        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
305            f.debug_tuple(stringify!(CrossChainEnabledAMB))
306                .field(&self.address())
307                .finish()
308        }
309    }
310    impl<M: ::ethers_providers::Middleware> CrossChainEnabledAMB<M> {
311        /// Creates a new contract instance with the specified `ethers` client at
312        /// `address`. The contract derefs to a `ethers::Contract` object.
313        pub fn new<T: Into<::ethers_core::types::Address>>(
314            address: T,
315            client: ::std::sync::Arc<M>,
316        ) -> Self {
317            Self(
318                ::ethers_contract::Contract::new(
319                    address.into(),
320                    CROSSCHAINENABLEDAMB_ABI.clone(),
321                    client,
322                ),
323            )
324        }
325        /// Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it.
326        /// Returns a new instance of a deployer that returns an instance of this contract after sending the transaction
327        ///
328        /// Notes:
329        /// - If there are no constructor arguments, you should pass `()` as the argument.
330        /// - The default poll duration is 7 seconds.
331        /// - The default number of confirmations is 1 block.
332        ///
333        ///
334        /// # Example
335        ///
336        /// Generate contract bindings with `abigen!` and deploy a new contract instance.
337        ///
338        /// *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact.
339        ///
340        /// ```ignore
341        /// # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {
342        ///     abigen!(Greeter, "../greeter.json");
343        ///
344        ///    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();
345        ///    let msg = greeter_contract.greet().call().await.unwrap();
346        /// # }
347        /// ```
348        pub fn deploy<T: ::ethers_core::abi::Tokenize>(
349            client: ::std::sync::Arc<M>,
350            constructor_args: T,
351        ) -> ::core::result::Result<
352            ::ethers_contract::builders::ContractDeployer<M, Self>,
353            ::ethers_contract::ContractError<M>,
354        > {
355            let factory = ::ethers_contract::ContractFactory::new(
356                CROSSCHAINENABLEDAMB_ABI.clone(),
357                CROSSCHAINENABLEDAMB_BYTECODE.clone().into(),
358                client,
359            );
360            let deployer = factory.deploy(constructor_args)?;
361            let deployer = ::ethers_contract::ContractDeployer::new(deployer);
362            Ok(deployer)
363        }
364    }
365    impl<M: ::ethers_providers::Middleware> From<::ethers_contract::Contract<M>>
366    for CrossChainEnabledAMB<M> {
367        fn from(contract: ::ethers_contract::Contract<M>) -> Self {
368            Self::new(contract.address(), contract.client())
369        }
370    }
371}
openzeppelin_rs/contracts/CrossChainEnabledAMB.rs

openzeppelin_rs/contracts/
CrossChainEnabledAMB.rs
