openzeppelin_rs/contracts/
LibArbitrumL2.rs

1pub use lib_arbitrum_l2::*;
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 lib_arbitrum_l2 {
13    #[rustfmt::skip]
14    const __ABI: &str = "[{\"inputs\":[],\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"ARBSYS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\",\"components\":[]}]}]";
15    ///The parsed JSON ABI of the contract.
16    pub static LIBARBITRUML2_ABI: ::ethers_contract::Lazy<::ethers_core::abi::Abi> = ::ethers_contract::Lazy::new(||
17    ::ethers_core::utils::__serde_json::from_str(__ABI).expect("ABI is always valid"));
18    #[rustfmt::skip]
19    const __BYTECODE: &[u8] = &[
20        96,
21        145,
22        97,
23        0,
24        56,
25        96,
26        11,
27        130,
28        130,
29        130,
30        57,
31        128,
32        81,
33        96,
34        0,
35        26,
36        96,
37        115,
38        20,
39        96,
40        43,
41        87,
42        99,
43        78,
44        72,
45        123,
46        113,
47        96,
48        224,
49        27,
50        96,
51        0,
52        82,
53        96,
54        0,
55        96,
56        4,
57        82,
58        96,
59        36,
60        96,
61        0,
62        253,
63        91,
64        48,
65        96,
66        0,
67        82,
68        96,
69        115,
70        129,
71        83,
72        130,
73        129,
74        243,
75        254,
76        115,
77        0,
78        0,
79        0,
80        0,
81        0,
82        0,
83        0,
84        0,
85        0,
86        0,
87        0,
88        0,
89        0,
90        0,
91        0,
92        0,
93        0,
94        0,
95        0,
96        0,
97        48,
98        20,
99        96,
100        128,
101        96,
102        64,
103        82,
104        96,
105        4,
106        54,
107        16,
108        96,
109        51,
110        87,
111        96,
112        0,
113        53,
114        96,
115        224,
116        28,
117        128,
118        99,
119        191,
120        10,
121        18,
122        207,
123        20,
124        96,
125        56,
126        87,
127        91,
128        96,
129        0,
130        128,
131        253,
132        91,
133        96,
134        63,
135        96,
136        100,
137        129,
138        86,
139        91,
140        96,
141        64,
142        81,
143        96,
144        1,
145        96,
146        1,
147        96,
148        160,
149        27,
150        3,
151        144,
152        145,
153        22,
154        129,
155        82,
156        96,
157        32,
158        1,
159        96,
160        64,
161        81,
162        128,
163        145,
164        3,
165        144,
166        243,
167        254,
168        162,
169        100,
170        105,
171        112,
172        102,
173        115,
174        88,
175        34,
176        18,
177        32,
178        169,
179        151,
180        233,
181        169,
182        190,
183        210,
184        71,
185        174,
186        90,
187        32,
188        76,
189        91,
190        236,
191        183,
192        43,
193        105,
194        101,
195        87,
196        211,
197        248,
198        193,
199        149,
200        140,
201        129,
202        147,
203        40,
204        49,
205        63,
206        86,
207        217,
208        77,
209        159,
210        100,
211        115,
212        111,
213        108,
214        99,
215        67,
216        0,
217        8,
218        13,
219        0,
220        51,
221    ];
222    ///The bytecode of the contract.
223    pub static LIBARBITRUML2_BYTECODE: ::ethers_core::types::Bytes = ::ethers_core::types::Bytes::from_static(
224        __BYTECODE,
225    );
226    #[rustfmt::skip]
227    const __DEPLOYED_BYTECODE: &[u8] = &[
228        115,
229        0,
230        0,
231        0,
232        0,
233        0,
234        0,
235        0,
236        0,
237        0,
238        0,
239        0,
240        0,
241        0,
242        0,
243        0,
244        0,
245        0,
246        0,
247        0,
248        0,
249        48,
250        20,
251        96,
252        128,
253        96,
254        64,
255        82,
256        96,
257        4,
258        54,
259        16,
260        96,
261        51,
262        87,
263        96,
264        0,
265        53,
266        96,
267        224,
268        28,
269        128,
270        99,
271        191,
272        10,
273        18,
274        207,
275        20,
276        96,
277        56,
278        87,
279        91,
280        96,
281        0,
282        128,
283        253,
284        91,
285        96,
286        63,
287        96,
288        100,
289        129,
290        86,
291        91,
292        96,
293        64,
294        81,
295        96,
296        1,
297        96,
298        1,
299        96,
300        160,
301        27,
302        3,
303        144,
304        145,
305        22,
306        129,
307        82,
308        96,
309        32,
310        1,
311        96,
312        64,
313        81,
314        128,
315        145,
316        3,
317        144,
318        243,
319        254,
320        162,
321        100,
322        105,
323        112,
324        102,
325        115,
326        88,
327        34,
328        18,
329        32,
330        169,
331        151,
332        233,
333        169,
334        190,
335        210,
336        71,
337        174,
338        90,
339        32,
340        76,
341        91,
342        236,
343        183,
344        43,
345        105,
346        101,
347        87,
348        211,
349        248,
350        193,
351        149,
352        140,
353        129,
354        147,
355        40,
356        49,
357        63,
358        86,
359        217,
360        77,
361        159,
362        100,
363        115,
364        111,
365        108,
366        99,
367        67,
368        0,
369        8,
370        13,
371        0,
372        51,
373    ];
374    ///The deployed bytecode of the contract.
375    pub static LIBARBITRUML2_DEPLOYED_BYTECODE: ::ethers_core::types::Bytes = ::ethers_core::types::Bytes::from_static(
376        __DEPLOYED_BYTECODE,
377    );
378    pub struct LibArbitrumL2<M>(::ethers_contract::Contract<M>);
379    impl<M> ::core::clone::Clone for LibArbitrumL2<M> {
380        fn clone(&self) -> Self {
381            Self(::core::clone::Clone::clone(&self.0))
382        }
383    }
384    impl<M> ::core::ops::Deref for LibArbitrumL2<M> {
385        type Target = ::ethers_contract::Contract<M>;
386        fn deref(&self) -> &Self::Target {
387            &self.0
388        }
389    }
390    impl<M> ::core::ops::DerefMut for LibArbitrumL2<M> {
391        fn deref_mut(&mut self) -> &mut Self::Target {
392            &mut self.0
393        }
394    }
395    impl<M> ::core::fmt::Debug for LibArbitrumL2<M> {
396        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
397            f.debug_tuple(stringify!(LibArbitrumL2)).field(&self.address()).finish()
398        }
399    }
400    impl<M: ::ethers_providers::Middleware> LibArbitrumL2<M> {
401        /// Creates a new contract instance with the specified `ethers` client at
402        /// `address`. The contract derefs to a `ethers::Contract` object.
403        pub fn new<T: Into<::ethers_core::types::Address>>(
404            address: T,
405            client: ::std::sync::Arc<M>,
406        ) -> Self {
407            Self(
408                ::ethers_contract::Contract::new(
409                    address.into(),
410                    LIBARBITRUML2_ABI.clone(),
411                    client,
412                ),
413            )
414        }
415        /// Constructs the general purpose `Deployer` instance based on the provided constructor arguments and sends it.
416        /// Returns a new instance of a deployer that returns an instance of this contract after sending the transaction
417        ///
418        /// Notes:
419        /// - If there are no constructor arguments, you should pass `()` as the argument.
420        /// - The default poll duration is 7 seconds.
421        /// - The default number of confirmations is 1 block.
422        ///
423        ///
424        /// # Example
425        ///
426        /// Generate contract bindings with `abigen!` and deploy a new contract instance.
427        ///
428        /// *Note*: this requires a `bytecode` and `abi` object in the `greeter.json` artifact.
429        ///
430        /// ```ignore
431        /// # async fn deploy<M: ethers::providers::Middleware>(client: ::std::sync::Arc<M>) {
432        ///     abigen!(Greeter, "../greeter.json");
433        ///
434        ///    let greeter_contract = Greeter::deploy(client, "Hello world!".to_string()).unwrap().send().await.unwrap();
435        ///    let msg = greeter_contract.greet().call().await.unwrap();
436        /// # }
437        /// ```
438        pub fn deploy<T: ::ethers_core::abi::Tokenize>(
439            client: ::std::sync::Arc<M>,
440            constructor_args: T,
441        ) -> ::core::result::Result<
442            ::ethers_contract::builders::ContractDeployer<M, Self>,
443            ::ethers_contract::ContractError<M>,
444        > {
445            let factory = ::ethers_contract::ContractFactory::new(
446                LIBARBITRUML2_ABI.clone(),
447                LIBARBITRUML2_BYTECODE.clone().into(),
448                client,
449            );
450            let deployer = factory.deploy(constructor_args)?;
451            let deployer = ::ethers_contract::ContractDeployer::new(deployer);
452            Ok(deployer)
453        }
454        ///Calls the contract's `ARBSYS` (0xbf0a12cf) function
455        pub fn arbsys(
456            &self,
457        ) -> ::ethers_contract::builders::ContractCall<
458            M,
459            ::ethers_core::types::Address,
460        > {
461            self.0
462                .method_hash([191, 10, 18, 207], ())
463                .expect("method not found (this should never happen)")
464        }
465    }
466    impl<M: ::ethers_providers::Middleware> From<::ethers_contract::Contract<M>>
467    for LibArbitrumL2<M> {
468        fn from(contract: ::ethers_contract::Contract<M>) -> Self {
469            Self::new(contract.address(), contract.client())
470        }
471    }
472    ///Container type for all input parameters for the `ARBSYS` function with signature `ARBSYS()` and selector `0xbf0a12cf`
473    #[derive(
474        Clone,
475        ::ethers_contract::EthCall,
476        ::ethers_contract::EthDisplay,
477        Default,
478        Debug,
479        PartialEq,
480        Eq,
481        Hash
482    )]
483    #[ethcall(name = "ARBSYS", abi = "ARBSYS()")]
484    pub struct ArbsysCall;
485    ///Container type for all return fields from the `ARBSYS` function with signature `ARBSYS()` and selector `0xbf0a12cf`
486    #[derive(
487        Clone,
488        ::ethers_contract::EthAbiType,
489        ::ethers_contract::EthAbiCodec,
490        Default,
491        Debug,
492        PartialEq,
493        Eq,
494        Hash
495    )]
496    pub struct ArbsysReturn(pub ::ethers_core::types::Address);
497}