Skip to main content

cartesi_rollups_contracts/
input_box.rs

1/**
2
3Generated by the following Solidity interface...
4```solidity
5interface InputBox {
6    error InputTooLarge(address appContract, uint256 inputLength, uint256 maxInputLength);
7
8    event InputAdded(address indexed appContract, uint256 indexed index, bytes input);
9
10    function addInput(address appContract, bytes memory payload) external returns (bytes32);
11    function getDeploymentBlockNumber() external view returns (uint256);
12    function getInputHash(address appContract, uint256 index) external view returns (bytes32);
13    function getNumberOfInputs(address appContract) external view returns (uint256);
14}
15```
16
17...which was generated by the following JSON ABI:
18```json
19[
20  {
21    "type": "function",
22    "name": "addInput",
23    "inputs": [
24      {
25        "name": "appContract",
26        "type": "address",
27        "internalType": "address"
28      },
29      {
30        "name": "payload",
31        "type": "bytes",
32        "internalType": "bytes"
33      }
34    ],
35    "outputs": [
36      {
37        "name": "",
38        "type": "bytes32",
39        "internalType": "bytes32"
40      }
41    ],
42    "stateMutability": "nonpayable"
43  },
44  {
45    "type": "function",
46    "name": "getDeploymentBlockNumber",
47    "inputs": [],
48    "outputs": [
49      {
50        "name": "",
51        "type": "uint256",
52        "internalType": "uint256"
53      }
54    ],
55    "stateMutability": "view"
56  },
57  {
58    "type": "function",
59    "name": "getInputHash",
60    "inputs": [
61      {
62        "name": "appContract",
63        "type": "address",
64        "internalType": "address"
65      },
66      {
67        "name": "index",
68        "type": "uint256",
69        "internalType": "uint256"
70      }
71    ],
72    "outputs": [
73      {
74        "name": "",
75        "type": "bytes32",
76        "internalType": "bytes32"
77      }
78    ],
79    "stateMutability": "view"
80  },
81  {
82    "type": "function",
83    "name": "getNumberOfInputs",
84    "inputs": [
85      {
86        "name": "appContract",
87        "type": "address",
88        "internalType": "address"
89      }
90    ],
91    "outputs": [
92      {
93        "name": "",
94        "type": "uint256",
95        "internalType": "uint256"
96      }
97    ],
98    "stateMutability": "view"
99  },
100  {
101    "type": "event",
102    "name": "InputAdded",
103    "inputs": [
104      {
105        "name": "appContract",
106        "type": "address",
107        "indexed": true,
108        "internalType": "address"
109      },
110      {
111        "name": "index",
112        "type": "uint256",
113        "indexed": true,
114        "internalType": "uint256"
115      },
116      {
117        "name": "input",
118        "type": "bytes",
119        "indexed": false,
120        "internalType": "bytes"
121      }
122    ],
123    "anonymous": false
124  },
125  {
126    "type": "error",
127    "name": "InputTooLarge",
128    "inputs": [
129      {
130        "name": "appContract",
131        "type": "address",
132        "internalType": "address"
133      },
134      {
135        "name": "inputLength",
136        "type": "uint256",
137        "internalType": "uint256"
138      },
139      {
140        "name": "maxInputLength",
141        "type": "uint256",
142        "internalType": "uint256"
143      }
144    ]
145  }
146]
147```*/
148#[allow(
149    non_camel_case_types,
150    non_snake_case,
151    clippy::pub_underscore_fields,
152    clippy::style,
153    clippy::empty_structs_with_brackets
154)]
155pub mod InputBox {
156    use super::*;
157    use alloy::sol_types as alloy_sol_types;
158    /// The creation / init bytecode of the contract.
159    ///
160    /// ```text
161    ///0x60a08060405234602157436080526103439081610026823960805181605f0152f35b5f80fdfe6080806040526004361015610012575f80fd5b5f3560e01c9081631789cd63146101055750806361a93c87146100ce578063677087c9146100865763b3a1acd814610048575f80fd5b34610082575f3660031901126100825760206040517f00000000000000000000000000000000000000000000000000000000000000008152f35b5f80fd5b34610082576040366003190112610082576001600160a01b036100a76102ce565b165f525f60205260206100bf60243560405f206102e4565b90549060031b1c604051908152f35b34610082576020366003190112610082576001600160a01b036100ef6102ce565b165f525f602052602060405f2054604051908152f35b346100825760403660031901126100825761011e6102ce565b6024359067ffffffffffffffff821161008257366023830112156100825781600401359067ffffffffffffffff82116100825736602483850101116100825760018060a01b0316805f525f60205260405f209361014481865494806024602084019863415bf36360e01b8a5246828601528760448601523360648601524360848601524260a48601524460c48601528860e48601526101006101048601528261012486015201848401375f838284010152601f801991011681010301601f1981018252601f8019910116810181811067ffffffffffffffff82111761029d5760405280516201000081116102b1575080518420936801000000000000000084101561029d5760407fc05d337121a6e8605c6ec0b72aa29c4210ffe6e5b9cefdd6a7058188a8f66f9892610259866020996001820181556102e4565b81549060031b9089821b915f19901b19161790558151928391898352518091818b8501528484015e5f828201840152601f01601f19168101030190a3604051908152f35b634e487b7160e01b5f52604160045260245ffd5b826304f90dc560e51b5f526004526024526201000060445260645ffd5b600435906001600160a01b038216820361008257565b80548210156102f9575f5260205f2001905f90565b634e487b7160e01b5f52603260045260245ffdfea2646970667358221220740e707924e66901499926e120c4cd36be0acfdb674fa0a53a2a8e759c6771cb64736f6c634300081e0033
162    /// ```
163    #[rustfmt::skip]
164    #[allow(clippy::all)]
165    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
166        b"`\xA0\x80`@R4`!WC`\x80Ra\x03C\x90\x81a\0&\x829`\x80Q\x81`_\x01R\xF3[_\x80\xFD\xFE`\x80\x80`@R`\x046\x10\x15a\0\x12W_\x80\xFD[_5`\xE0\x1C\x90\x81c\x17\x89\xCDc\x14a\x01\x05WP\x80ca\xA9<\x87\x14a\0\xCEW\x80cgp\x87\xC9\x14a\0\x86Wc\xB3\xA1\xAC\xD8\x14a\0HW_\x80\xFD[4a\0\x82W_6`\x03\x19\x01\x12a\0\x82W` `@Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\xF3[_\x80\xFD[4a\0\x82W`@6`\x03\x19\x01\x12a\0\x82W`\x01`\x01`\xA0\x1B\x03a\0\xA7a\x02\xCEV[\x16_R_` R` a\0\xBF`$5`@_ a\x02\xE4V[\x90T\x90`\x03\x1B\x1C`@Q\x90\x81R\xF3[4a\0\x82W` 6`\x03\x19\x01\x12a\0\x82W`\x01`\x01`\xA0\x1B\x03a\0\xEFa\x02\xCEV[\x16_R_` R` `@_ T`@Q\x90\x81R\xF3[4a\0\x82W`@6`\x03\x19\x01\x12a\0\x82Wa\x01\x1Ea\x02\xCEV[`$5\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\0\x82W6`#\x83\x01\x12\x15a\0\x82W\x81`\x04\x015\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\0\x82W6`$\x83\x85\x01\x01\x11a\0\x82W`\x01\x80`\xA0\x1B\x03\x16\x80_R_` R`@_ \x93a\x01D\x81\x86T\x94\x80`$` \x84\x01\x98cA[\xF3c`\xE0\x1B\x8ARF\x82\x86\x01R\x87`D\x86\x01R3`d\x86\x01RC`\x84\x86\x01RB`\xA4\x86\x01RD`\xC4\x86\x01R\x88`\xE4\x86\x01Ra\x01\0a\x01\x04\x86\x01R\x82a\x01$\x86\x01R\x01\x84\x84\x017_\x83\x82\x84\x01\x01R`\x1F\x80\x19\x91\x01\x16\x81\x01\x03\x01`\x1F\x19\x81\x01\x82R`\x1F\x80\x19\x91\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x02\x9DW`@R\x80Qb\x01\0\0\x81\x11a\x02\xB1WP\x80Q\x84 \x93h\x01\0\0\0\0\0\0\0\0\x84\x10\x15a\x02\x9DW`@\x7F\xC0]3q!\xA6\xE8`\\n\xC0\xB7*\xA2\x9CB\x10\xFF\xE6\xE5\xB9\xCE\xFD\xD6\xA7\x05\x81\x88\xA8\xF6o\x98\x92a\x02Y\x86` \x99`\x01\x82\x01\x81Ua\x02\xE4V[\x81T\x90`\x03\x1B\x90\x89\x82\x1B\x91_\x19\x90\x1B\x19\x16\x17\x90U\x81Q\x92\x83\x91\x89\x83RQ\x80\x91\x81\x8B\x85\x01R\x84\x84\x01^_\x82\x82\x01\x84\x01R`\x1F\x01`\x1F\x19\x16\x81\x01\x03\x01\x90\xA3`@Q\x90\x81R\xF3[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[\x82c\x04\xF9\r\xC5`\xE5\x1B_R`\x04R`$Rb\x01\0\0`DR`d_\xFD[`\x045\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\0\x82WV[\x80T\x82\x10\x15a\x02\xF9W_R` _ \x01\x90_\x90V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD\xFE\xA2dipfsX\"\x12 t\x0Epy$\xE6i\x01I\x99&\xE1 \xC4\xCD6\xBE\n\xCF\xDBgO\xA0\xA5:*\x8Eu\x9Cgq\xCBdsolcC\0\x08\x1E\x003",
167    );
168    /// The runtime bytecode of the contract, as deployed on the network.
169    ///
170    /// ```text
171    ///0x6080806040526004361015610012575f80fd5b5f3560e01c9081631789cd63146101055750806361a93c87146100ce578063677087c9146100865763b3a1acd814610048575f80fd5b34610082575f3660031901126100825760206040517f00000000000000000000000000000000000000000000000000000000000000008152f35b5f80fd5b34610082576040366003190112610082576001600160a01b036100a76102ce565b165f525f60205260206100bf60243560405f206102e4565b90549060031b1c604051908152f35b34610082576020366003190112610082576001600160a01b036100ef6102ce565b165f525f602052602060405f2054604051908152f35b346100825760403660031901126100825761011e6102ce565b6024359067ffffffffffffffff821161008257366023830112156100825781600401359067ffffffffffffffff82116100825736602483850101116100825760018060a01b0316805f525f60205260405f209361014481865494806024602084019863415bf36360e01b8a5246828601528760448601523360648601524360848601524260a48601524460c48601528860e48601526101006101048601528261012486015201848401375f838284010152601f801991011681010301601f1981018252601f8019910116810181811067ffffffffffffffff82111761029d5760405280516201000081116102b1575080518420936801000000000000000084101561029d5760407fc05d337121a6e8605c6ec0b72aa29c4210ffe6e5b9cefdd6a7058188a8f66f9892610259866020996001820181556102e4565b81549060031b9089821b915f19901b19161790558151928391898352518091818b8501528484015e5f828201840152601f01601f19168101030190a3604051908152f35b634e487b7160e01b5f52604160045260245ffd5b826304f90dc560e51b5f526004526024526201000060445260645ffd5b600435906001600160a01b038216820361008257565b80548210156102f9575f5260205f2001905f90565b634e487b7160e01b5f52603260045260245ffdfea2646970667358221220740e707924e66901499926e120c4cd36be0acfdb674fa0a53a2a8e759c6771cb64736f6c634300081e0033
172    /// ```
173    #[rustfmt::skip]
174    #[allow(clippy::all)]
175    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
176        b"`\x80\x80`@R`\x046\x10\x15a\0\x12W_\x80\xFD[_5`\xE0\x1C\x90\x81c\x17\x89\xCDc\x14a\x01\x05WP\x80ca\xA9<\x87\x14a\0\xCEW\x80cgp\x87\xC9\x14a\0\x86Wc\xB3\xA1\xAC\xD8\x14a\0HW_\x80\xFD[4a\0\x82W_6`\x03\x19\x01\x12a\0\x82W` `@Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\xF3[_\x80\xFD[4a\0\x82W`@6`\x03\x19\x01\x12a\0\x82W`\x01`\x01`\xA0\x1B\x03a\0\xA7a\x02\xCEV[\x16_R_` R` a\0\xBF`$5`@_ a\x02\xE4V[\x90T\x90`\x03\x1B\x1C`@Q\x90\x81R\xF3[4a\0\x82W` 6`\x03\x19\x01\x12a\0\x82W`\x01`\x01`\xA0\x1B\x03a\0\xEFa\x02\xCEV[\x16_R_` R` `@_ T`@Q\x90\x81R\xF3[4a\0\x82W`@6`\x03\x19\x01\x12a\0\x82Wa\x01\x1Ea\x02\xCEV[`$5\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\0\x82W6`#\x83\x01\x12\x15a\0\x82W\x81`\x04\x015\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11a\0\x82W6`$\x83\x85\x01\x01\x11a\0\x82W`\x01\x80`\xA0\x1B\x03\x16\x80_R_` R`@_ \x93a\x01D\x81\x86T\x94\x80`$` \x84\x01\x98cA[\xF3c`\xE0\x1B\x8ARF\x82\x86\x01R\x87`D\x86\x01R3`d\x86\x01RC`\x84\x86\x01RB`\xA4\x86\x01RD`\xC4\x86\x01R\x88`\xE4\x86\x01Ra\x01\0a\x01\x04\x86\x01R\x82a\x01$\x86\x01R\x01\x84\x84\x017_\x83\x82\x84\x01\x01R`\x1F\x80\x19\x91\x01\x16\x81\x01\x03\x01`\x1F\x19\x81\x01\x82R`\x1F\x80\x19\x91\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17a\x02\x9DW`@R\x80Qb\x01\0\0\x81\x11a\x02\xB1WP\x80Q\x84 \x93h\x01\0\0\0\0\0\0\0\0\x84\x10\x15a\x02\x9DW`@\x7F\xC0]3q!\xA6\xE8`\\n\xC0\xB7*\xA2\x9CB\x10\xFF\xE6\xE5\xB9\xCE\xFD\xD6\xA7\x05\x81\x88\xA8\xF6o\x98\x92a\x02Y\x86` \x99`\x01\x82\x01\x81Ua\x02\xE4V[\x81T\x90`\x03\x1B\x90\x89\x82\x1B\x91_\x19\x90\x1B\x19\x16\x17\x90U\x81Q\x92\x83\x91\x89\x83RQ\x80\x91\x81\x8B\x85\x01R\x84\x84\x01^_\x82\x82\x01\x84\x01R`\x1F\x01`\x1F\x19\x16\x81\x01\x03\x01\x90\xA3`@Q\x90\x81R\xF3[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[\x82c\x04\xF9\r\xC5`\xE5\x1B_R`\x04R`$Rb\x01\0\0`DR`d_\xFD[`\x045\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\0\x82WV[\x80T\x82\x10\x15a\x02\xF9W_R` _ \x01\x90_\x90V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD\xFE\xA2dipfsX\"\x12 t\x0Epy$\xE6i\x01I\x99&\xE1 \xC4\xCD6\xBE\n\xCF\xDBgO\xA0\xA5:*\x8Eu\x9Cgq\xCBdsolcC\0\x08\x1E\x003",
177    );
178    #[derive(serde::Serialize, serde::Deserialize)]
179    #[derive(Default, Debug, PartialEq, Eq, Hash)]
180    /**Custom error with signature `InputTooLarge(address,uint256,uint256)` and selector `0x9f21b8a0`.
181```solidity
182error InputTooLarge(address appContract, uint256 inputLength, uint256 maxInputLength);
183```*/
184    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
185    #[derive(Clone)]
186    pub struct InputTooLarge {
187        #[allow(missing_docs)]
188        pub appContract: alloy::sol_types::private::Address,
189        #[allow(missing_docs)]
190        pub inputLength: alloy::sol_types::private::primitives::aliases::U256,
191        #[allow(missing_docs)]
192        pub maxInputLength: alloy::sol_types::private::primitives::aliases::U256,
193    }
194    #[allow(
195        non_camel_case_types,
196        non_snake_case,
197        clippy::pub_underscore_fields,
198        clippy::style
199    )]
200    const _: () = {
201        use alloy::sol_types as alloy_sol_types;
202        #[doc(hidden)]
203        #[allow(dead_code)]
204        type UnderlyingSolTuple<'a> = (
205            alloy::sol_types::sol_data::Address,
206            alloy::sol_types::sol_data::Uint<256>,
207            alloy::sol_types::sol_data::Uint<256>,
208        );
209        #[doc(hidden)]
210        type UnderlyingRustTuple<'a> = (
211            alloy::sol_types::private::Address,
212            alloy::sol_types::private::primitives::aliases::U256,
213            alloy::sol_types::private::primitives::aliases::U256,
214        );
215        #[cfg(test)]
216        #[allow(dead_code, unreachable_patterns)]
217        fn _type_assertion(
218            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
219        ) {
220            match _t {
221                alloy_sol_types::private::AssertTypeEq::<
222                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
223                >(_) => {}
224            }
225        }
226        #[automatically_derived]
227        #[doc(hidden)]
228        impl ::core::convert::From<InputTooLarge> for UnderlyingRustTuple<'_> {
229            fn from(value: InputTooLarge) -> Self {
230                (value.appContract, value.inputLength, value.maxInputLength)
231            }
232        }
233        #[automatically_derived]
234        #[doc(hidden)]
235        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputTooLarge {
236            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
237                Self {
238                    appContract: tuple.0,
239                    inputLength: tuple.1,
240                    maxInputLength: tuple.2,
241                }
242            }
243        }
244        #[automatically_derived]
245        impl alloy_sol_types::SolError for InputTooLarge {
246            type Parameters<'a> = UnderlyingSolTuple<'a>;
247            type Token<'a> = <Self::Parameters<
248                'a,
249            > as alloy_sol_types::SolType>::Token<'a>;
250            const SIGNATURE: &'static str = "InputTooLarge(address,uint256,uint256)";
251            const SELECTOR: [u8; 4] = [159u8, 33u8, 184u8, 160u8];
252            #[inline]
253            fn new<'a>(
254                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
255            ) -> Self {
256                tuple.into()
257            }
258            #[inline]
259            fn tokenize(&self) -> Self::Token<'_> {
260                (
261                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
262                        &self.appContract,
263                    ),
264                    <alloy::sol_types::sol_data::Uint<
265                        256,
266                    > as alloy_sol_types::SolType>::tokenize(&self.inputLength),
267                    <alloy::sol_types::sol_data::Uint<
268                        256,
269                    > as alloy_sol_types::SolType>::tokenize(&self.maxInputLength),
270                )
271            }
272            #[inline]
273            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
274                <Self::Parameters<
275                    '_,
276                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
277                    .map(Self::new)
278            }
279        }
280    };
281    #[derive(serde::Serialize, serde::Deserialize)]
282    #[derive(Default, Debug, PartialEq, Eq, Hash)]
283    /**Event with signature `InputAdded(address,uint256,bytes)` and selector `0xc05d337121a6e8605c6ec0b72aa29c4210ffe6e5b9cefdd6a7058188a8f66f98`.
284```solidity
285event InputAdded(address indexed appContract, uint256 indexed index, bytes input);
286```*/
287    #[allow(
288        non_camel_case_types,
289        non_snake_case,
290        clippy::pub_underscore_fields,
291        clippy::style
292    )]
293    #[derive(Clone)]
294    pub struct InputAdded {
295        #[allow(missing_docs)]
296        pub appContract: alloy::sol_types::private::Address,
297        #[allow(missing_docs)]
298        pub index: alloy::sol_types::private::primitives::aliases::U256,
299        #[allow(missing_docs)]
300        pub input: alloy::sol_types::private::Bytes,
301    }
302    #[allow(
303        non_camel_case_types,
304        non_snake_case,
305        clippy::pub_underscore_fields,
306        clippy::style
307    )]
308    const _: () = {
309        use alloy::sol_types as alloy_sol_types;
310        #[automatically_derived]
311        impl alloy_sol_types::SolEvent for InputAdded {
312            type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,);
313            type DataToken<'a> = <Self::DataTuple<
314                'a,
315            > as alloy_sol_types::SolType>::Token<'a>;
316            type TopicList = (
317                alloy_sol_types::sol_data::FixedBytes<32>,
318                alloy::sol_types::sol_data::Address,
319                alloy::sol_types::sol_data::Uint<256>,
320            );
321            const SIGNATURE: &'static str = "InputAdded(address,uint256,bytes)";
322            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
323                192u8, 93u8, 51u8, 113u8, 33u8, 166u8, 232u8, 96u8, 92u8, 110u8, 192u8,
324                183u8, 42u8, 162u8, 156u8, 66u8, 16u8, 255u8, 230u8, 229u8, 185u8, 206u8,
325                253u8, 214u8, 167u8, 5u8, 129u8, 136u8, 168u8, 246u8, 111u8, 152u8,
326            ]);
327            const ANONYMOUS: bool = false;
328            #[allow(unused_variables)]
329            #[inline]
330            fn new(
331                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
332                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
333            ) -> Self {
334                Self {
335                    appContract: topics.1,
336                    index: topics.2,
337                    input: data.0,
338                }
339            }
340            #[inline]
341            fn check_signature(
342                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
343            ) -> alloy_sol_types::Result<()> {
344                if topics.0 != Self::SIGNATURE_HASH {
345                    return Err(
346                        alloy_sol_types::Error::invalid_event_signature_hash(
347                            Self::SIGNATURE,
348                            topics.0,
349                            Self::SIGNATURE_HASH,
350                        ),
351                    );
352                }
353                Ok(())
354            }
355            #[inline]
356            fn tokenize_body(&self) -> Self::DataToken<'_> {
357                (
358                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
359                        &self.input,
360                    ),
361                )
362            }
363            #[inline]
364            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
365                (
366                    Self::SIGNATURE_HASH.into(),
367                    self.appContract.clone(),
368                    self.index.clone(),
369                )
370            }
371            #[inline]
372            fn encode_topics_raw(
373                &self,
374                out: &mut [alloy_sol_types::abi::token::WordToken],
375            ) -> alloy_sol_types::Result<()> {
376                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
377                    return Err(alloy_sol_types::Error::Overrun);
378                }
379                out[0usize] = alloy_sol_types::abi::token::WordToken(
380                    Self::SIGNATURE_HASH,
381                );
382                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
383                    &self.appContract,
384                );
385                out[2usize] = <alloy::sol_types::sol_data::Uint<
386                    256,
387                > as alloy_sol_types::EventTopic>::encode_topic(&self.index);
388                Ok(())
389            }
390        }
391        #[automatically_derived]
392        impl alloy_sol_types::private::IntoLogData for InputAdded {
393            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
394                From::from(self)
395            }
396            fn into_log_data(self) -> alloy_sol_types::private::LogData {
397                From::from(&self)
398            }
399        }
400        #[automatically_derived]
401        impl From<&InputAdded> for alloy_sol_types::private::LogData {
402            #[inline]
403            fn from(this: &InputAdded) -> alloy_sol_types::private::LogData {
404                alloy_sol_types::SolEvent::encode_log_data(this)
405            }
406        }
407    };
408    #[derive(serde::Serialize, serde::Deserialize)]
409    #[derive(Default, Debug, PartialEq, Eq, Hash)]
410    /**Function with signature `addInput(address,bytes)` and selector `0x1789cd63`.
411```solidity
412function addInput(address appContract, bytes memory payload) external returns (bytes32);
413```*/
414    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
415    #[derive(Clone)]
416    pub struct addInputCall {
417        #[allow(missing_docs)]
418        pub appContract: alloy::sol_types::private::Address,
419        #[allow(missing_docs)]
420        pub payload: alloy::sol_types::private::Bytes,
421    }
422    #[derive(serde::Serialize, serde::Deserialize)]
423    #[derive(Default, Debug, PartialEq, Eq, Hash)]
424    ///Container type for the return parameters of the [`addInput(address,bytes)`](addInputCall) function.
425    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
426    #[derive(Clone)]
427    pub struct addInputReturn {
428        #[allow(missing_docs)]
429        pub _0: alloy::sol_types::private::FixedBytes<32>,
430    }
431    #[allow(
432        non_camel_case_types,
433        non_snake_case,
434        clippy::pub_underscore_fields,
435        clippy::style
436    )]
437    const _: () = {
438        use alloy::sol_types as alloy_sol_types;
439        {
440            #[doc(hidden)]
441            #[allow(dead_code)]
442            type UnderlyingSolTuple<'a> = (
443                alloy::sol_types::sol_data::Address,
444                alloy::sol_types::sol_data::Bytes,
445            );
446            #[doc(hidden)]
447            type UnderlyingRustTuple<'a> = (
448                alloy::sol_types::private::Address,
449                alloy::sol_types::private::Bytes,
450            );
451            #[cfg(test)]
452            #[allow(dead_code, unreachable_patterns)]
453            fn _type_assertion(
454                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
455            ) {
456                match _t {
457                    alloy_sol_types::private::AssertTypeEq::<
458                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
459                    >(_) => {}
460                }
461            }
462            #[automatically_derived]
463            #[doc(hidden)]
464            impl ::core::convert::From<addInputCall> for UnderlyingRustTuple<'_> {
465                fn from(value: addInputCall) -> Self {
466                    (value.appContract, value.payload)
467                }
468            }
469            #[automatically_derived]
470            #[doc(hidden)]
471            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addInputCall {
472                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
473                    Self {
474                        appContract: tuple.0,
475                        payload: tuple.1,
476                    }
477                }
478            }
479        }
480        {
481            #[doc(hidden)]
482            #[allow(dead_code)]
483            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
484            #[doc(hidden)]
485            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
486            #[cfg(test)]
487            #[allow(dead_code, unreachable_patterns)]
488            fn _type_assertion(
489                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
490            ) {
491                match _t {
492                    alloy_sol_types::private::AssertTypeEq::<
493                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
494                    >(_) => {}
495                }
496            }
497            #[automatically_derived]
498            #[doc(hidden)]
499            impl ::core::convert::From<addInputReturn> for UnderlyingRustTuple<'_> {
500                fn from(value: addInputReturn) -> Self {
501                    (value._0,)
502                }
503            }
504            #[automatically_derived]
505            #[doc(hidden)]
506            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addInputReturn {
507                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
508                    Self { _0: tuple.0 }
509                }
510            }
511        }
512        #[automatically_derived]
513        impl alloy_sol_types::SolCall for addInputCall {
514            type Parameters<'a> = (
515                alloy::sol_types::sol_data::Address,
516                alloy::sol_types::sol_data::Bytes,
517            );
518            type Token<'a> = <Self::Parameters<
519                'a,
520            > as alloy_sol_types::SolType>::Token<'a>;
521            type Return = alloy::sol_types::private::FixedBytes<32>;
522            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
523            type ReturnToken<'a> = <Self::ReturnTuple<
524                'a,
525            > as alloy_sol_types::SolType>::Token<'a>;
526            const SIGNATURE: &'static str = "addInput(address,bytes)";
527            const SELECTOR: [u8; 4] = [23u8, 137u8, 205u8, 99u8];
528            #[inline]
529            fn new<'a>(
530                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
531            ) -> Self {
532                tuple.into()
533            }
534            #[inline]
535            fn tokenize(&self) -> Self::Token<'_> {
536                (
537                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
538                        &self.appContract,
539                    ),
540                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
541                        &self.payload,
542                    ),
543                )
544            }
545            #[inline]
546            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
547                (
548                    <alloy::sol_types::sol_data::FixedBytes<
549                        32,
550                    > as alloy_sol_types::SolType>::tokenize(ret),
551                )
552            }
553            #[inline]
554            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
555                <Self::ReturnTuple<
556                    '_,
557                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
558                    .map(|r| {
559                        let r: addInputReturn = r.into();
560                        r._0
561                    })
562            }
563            #[inline]
564            fn abi_decode_returns_validate(
565                data: &[u8],
566            ) -> alloy_sol_types::Result<Self::Return> {
567                <Self::ReturnTuple<
568                    '_,
569                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
570                    .map(|r| {
571                        let r: addInputReturn = r.into();
572                        r._0
573                    })
574            }
575        }
576    };
577    #[derive(serde::Serialize, serde::Deserialize)]
578    #[derive(Default, Debug, PartialEq, Eq, Hash)]
579    /**Function with signature `getDeploymentBlockNumber()` and selector `0xb3a1acd8`.
580```solidity
581function getDeploymentBlockNumber() external view returns (uint256);
582```*/
583    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
584    #[derive(Clone)]
585    pub struct getDeploymentBlockNumberCall;
586    #[derive(serde::Serialize, serde::Deserialize)]
587    #[derive(Default, Debug, PartialEq, Eq, Hash)]
588    ///Container type for the return parameters of the [`getDeploymentBlockNumber()`](getDeploymentBlockNumberCall) function.
589    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
590    #[derive(Clone)]
591    pub struct getDeploymentBlockNumberReturn {
592        #[allow(missing_docs)]
593        pub _0: alloy::sol_types::private::primitives::aliases::U256,
594    }
595    #[allow(
596        non_camel_case_types,
597        non_snake_case,
598        clippy::pub_underscore_fields,
599        clippy::style
600    )]
601    const _: () = {
602        use alloy::sol_types as alloy_sol_types;
603        {
604            #[doc(hidden)]
605            #[allow(dead_code)]
606            type UnderlyingSolTuple<'a> = ();
607            #[doc(hidden)]
608            type UnderlyingRustTuple<'a> = ();
609            #[cfg(test)]
610            #[allow(dead_code, unreachable_patterns)]
611            fn _type_assertion(
612                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
613            ) {
614                match _t {
615                    alloy_sol_types::private::AssertTypeEq::<
616                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
617                    >(_) => {}
618                }
619            }
620            #[automatically_derived]
621            #[doc(hidden)]
622            impl ::core::convert::From<getDeploymentBlockNumberCall>
623            for UnderlyingRustTuple<'_> {
624                fn from(value: getDeploymentBlockNumberCall) -> Self {
625                    ()
626                }
627            }
628            #[automatically_derived]
629            #[doc(hidden)]
630            impl ::core::convert::From<UnderlyingRustTuple<'_>>
631            for getDeploymentBlockNumberCall {
632                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
633                    Self
634                }
635            }
636        }
637        {
638            #[doc(hidden)]
639            #[allow(dead_code)]
640            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
641            #[doc(hidden)]
642            type UnderlyingRustTuple<'a> = (
643                alloy::sol_types::private::primitives::aliases::U256,
644            );
645            #[cfg(test)]
646            #[allow(dead_code, unreachable_patterns)]
647            fn _type_assertion(
648                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
649            ) {
650                match _t {
651                    alloy_sol_types::private::AssertTypeEq::<
652                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
653                    >(_) => {}
654                }
655            }
656            #[automatically_derived]
657            #[doc(hidden)]
658            impl ::core::convert::From<getDeploymentBlockNumberReturn>
659            for UnderlyingRustTuple<'_> {
660                fn from(value: getDeploymentBlockNumberReturn) -> Self {
661                    (value._0,)
662                }
663            }
664            #[automatically_derived]
665            #[doc(hidden)]
666            impl ::core::convert::From<UnderlyingRustTuple<'_>>
667            for getDeploymentBlockNumberReturn {
668                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
669                    Self { _0: tuple.0 }
670                }
671            }
672        }
673        #[automatically_derived]
674        impl alloy_sol_types::SolCall for getDeploymentBlockNumberCall {
675            type Parameters<'a> = ();
676            type Token<'a> = <Self::Parameters<
677                'a,
678            > as alloy_sol_types::SolType>::Token<'a>;
679            type Return = alloy::sol_types::private::primitives::aliases::U256;
680            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
681            type ReturnToken<'a> = <Self::ReturnTuple<
682                'a,
683            > as alloy_sol_types::SolType>::Token<'a>;
684            const SIGNATURE: &'static str = "getDeploymentBlockNumber()";
685            const SELECTOR: [u8; 4] = [179u8, 161u8, 172u8, 216u8];
686            #[inline]
687            fn new<'a>(
688                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
689            ) -> Self {
690                tuple.into()
691            }
692            #[inline]
693            fn tokenize(&self) -> Self::Token<'_> {
694                ()
695            }
696            #[inline]
697            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
698                (
699                    <alloy::sol_types::sol_data::Uint<
700                        256,
701                    > as alloy_sol_types::SolType>::tokenize(ret),
702                )
703            }
704            #[inline]
705            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
706                <Self::ReturnTuple<
707                    '_,
708                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
709                    .map(|r| {
710                        let r: getDeploymentBlockNumberReturn = r.into();
711                        r._0
712                    })
713            }
714            #[inline]
715            fn abi_decode_returns_validate(
716                data: &[u8],
717            ) -> alloy_sol_types::Result<Self::Return> {
718                <Self::ReturnTuple<
719                    '_,
720                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
721                    .map(|r| {
722                        let r: getDeploymentBlockNumberReturn = r.into();
723                        r._0
724                    })
725            }
726        }
727    };
728    #[derive(serde::Serialize, serde::Deserialize)]
729    #[derive(Default, Debug, PartialEq, Eq, Hash)]
730    /**Function with signature `getInputHash(address,uint256)` and selector `0x677087c9`.
731```solidity
732function getInputHash(address appContract, uint256 index) external view returns (bytes32);
733```*/
734    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
735    #[derive(Clone)]
736    pub struct getInputHashCall {
737        #[allow(missing_docs)]
738        pub appContract: alloy::sol_types::private::Address,
739        #[allow(missing_docs)]
740        pub index: alloy::sol_types::private::primitives::aliases::U256,
741    }
742    #[derive(serde::Serialize, serde::Deserialize)]
743    #[derive(Default, Debug, PartialEq, Eq, Hash)]
744    ///Container type for the return parameters of the [`getInputHash(address,uint256)`](getInputHashCall) function.
745    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
746    #[derive(Clone)]
747    pub struct getInputHashReturn {
748        #[allow(missing_docs)]
749        pub _0: alloy::sol_types::private::FixedBytes<32>,
750    }
751    #[allow(
752        non_camel_case_types,
753        non_snake_case,
754        clippy::pub_underscore_fields,
755        clippy::style
756    )]
757    const _: () = {
758        use alloy::sol_types as alloy_sol_types;
759        {
760            #[doc(hidden)]
761            #[allow(dead_code)]
762            type UnderlyingSolTuple<'a> = (
763                alloy::sol_types::sol_data::Address,
764                alloy::sol_types::sol_data::Uint<256>,
765            );
766            #[doc(hidden)]
767            type UnderlyingRustTuple<'a> = (
768                alloy::sol_types::private::Address,
769                alloy::sol_types::private::primitives::aliases::U256,
770            );
771            #[cfg(test)]
772            #[allow(dead_code, unreachable_patterns)]
773            fn _type_assertion(
774                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
775            ) {
776                match _t {
777                    alloy_sol_types::private::AssertTypeEq::<
778                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
779                    >(_) => {}
780                }
781            }
782            #[automatically_derived]
783            #[doc(hidden)]
784            impl ::core::convert::From<getInputHashCall> for UnderlyingRustTuple<'_> {
785                fn from(value: getInputHashCall) -> Self {
786                    (value.appContract, value.index)
787                }
788            }
789            #[automatically_derived]
790            #[doc(hidden)]
791            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInputHashCall {
792                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
793                    Self {
794                        appContract: tuple.0,
795                        index: tuple.1,
796                    }
797                }
798            }
799        }
800        {
801            #[doc(hidden)]
802            #[allow(dead_code)]
803            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
804            #[doc(hidden)]
805            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
806            #[cfg(test)]
807            #[allow(dead_code, unreachable_patterns)]
808            fn _type_assertion(
809                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
810            ) {
811                match _t {
812                    alloy_sol_types::private::AssertTypeEq::<
813                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
814                    >(_) => {}
815                }
816            }
817            #[automatically_derived]
818            #[doc(hidden)]
819            impl ::core::convert::From<getInputHashReturn> for UnderlyingRustTuple<'_> {
820                fn from(value: getInputHashReturn) -> Self {
821                    (value._0,)
822                }
823            }
824            #[automatically_derived]
825            #[doc(hidden)]
826            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getInputHashReturn {
827                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
828                    Self { _0: tuple.0 }
829                }
830            }
831        }
832        #[automatically_derived]
833        impl alloy_sol_types::SolCall for getInputHashCall {
834            type Parameters<'a> = (
835                alloy::sol_types::sol_data::Address,
836                alloy::sol_types::sol_data::Uint<256>,
837            );
838            type Token<'a> = <Self::Parameters<
839                'a,
840            > as alloy_sol_types::SolType>::Token<'a>;
841            type Return = alloy::sol_types::private::FixedBytes<32>;
842            type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
843            type ReturnToken<'a> = <Self::ReturnTuple<
844                'a,
845            > as alloy_sol_types::SolType>::Token<'a>;
846            const SIGNATURE: &'static str = "getInputHash(address,uint256)";
847            const SELECTOR: [u8; 4] = [103u8, 112u8, 135u8, 201u8];
848            #[inline]
849            fn new<'a>(
850                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
851            ) -> Self {
852                tuple.into()
853            }
854            #[inline]
855            fn tokenize(&self) -> Self::Token<'_> {
856                (
857                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
858                        &self.appContract,
859                    ),
860                    <alloy::sol_types::sol_data::Uint<
861                        256,
862                    > as alloy_sol_types::SolType>::tokenize(&self.index),
863                )
864            }
865            #[inline]
866            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
867                (
868                    <alloy::sol_types::sol_data::FixedBytes<
869                        32,
870                    > as alloy_sol_types::SolType>::tokenize(ret),
871                )
872            }
873            #[inline]
874            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
875                <Self::ReturnTuple<
876                    '_,
877                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
878                    .map(|r| {
879                        let r: getInputHashReturn = r.into();
880                        r._0
881                    })
882            }
883            #[inline]
884            fn abi_decode_returns_validate(
885                data: &[u8],
886            ) -> alloy_sol_types::Result<Self::Return> {
887                <Self::ReturnTuple<
888                    '_,
889                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
890                    .map(|r| {
891                        let r: getInputHashReturn = r.into();
892                        r._0
893                    })
894            }
895        }
896    };
897    #[derive(serde::Serialize, serde::Deserialize)]
898    #[derive(Default, Debug, PartialEq, Eq, Hash)]
899    /**Function with signature `getNumberOfInputs(address)` and selector `0x61a93c87`.
900```solidity
901function getNumberOfInputs(address appContract) external view returns (uint256);
902```*/
903    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
904    #[derive(Clone)]
905    pub struct getNumberOfInputsCall {
906        #[allow(missing_docs)]
907        pub appContract: alloy::sol_types::private::Address,
908    }
909    #[derive(serde::Serialize, serde::Deserialize)]
910    #[derive(Default, Debug, PartialEq, Eq, Hash)]
911    ///Container type for the return parameters of the [`getNumberOfInputs(address)`](getNumberOfInputsCall) function.
912    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
913    #[derive(Clone)]
914    pub struct getNumberOfInputsReturn {
915        #[allow(missing_docs)]
916        pub _0: alloy::sol_types::private::primitives::aliases::U256,
917    }
918    #[allow(
919        non_camel_case_types,
920        non_snake_case,
921        clippy::pub_underscore_fields,
922        clippy::style
923    )]
924    const _: () = {
925        use alloy::sol_types as alloy_sol_types;
926        {
927            #[doc(hidden)]
928            #[allow(dead_code)]
929            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
930            #[doc(hidden)]
931            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
932            #[cfg(test)]
933            #[allow(dead_code, unreachable_patterns)]
934            fn _type_assertion(
935                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
936            ) {
937                match _t {
938                    alloy_sol_types::private::AssertTypeEq::<
939                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
940                    >(_) => {}
941                }
942            }
943            #[automatically_derived]
944            #[doc(hidden)]
945            impl ::core::convert::From<getNumberOfInputsCall>
946            for UnderlyingRustTuple<'_> {
947                fn from(value: getNumberOfInputsCall) -> Self {
948                    (value.appContract,)
949                }
950            }
951            #[automatically_derived]
952            #[doc(hidden)]
953            impl ::core::convert::From<UnderlyingRustTuple<'_>>
954            for getNumberOfInputsCall {
955                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
956                    Self { appContract: tuple.0 }
957                }
958            }
959        }
960        {
961            #[doc(hidden)]
962            #[allow(dead_code)]
963            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
964            #[doc(hidden)]
965            type UnderlyingRustTuple<'a> = (
966                alloy::sol_types::private::primitives::aliases::U256,
967            );
968            #[cfg(test)]
969            #[allow(dead_code, unreachable_patterns)]
970            fn _type_assertion(
971                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
972            ) {
973                match _t {
974                    alloy_sol_types::private::AssertTypeEq::<
975                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
976                    >(_) => {}
977                }
978            }
979            #[automatically_derived]
980            #[doc(hidden)]
981            impl ::core::convert::From<getNumberOfInputsReturn>
982            for UnderlyingRustTuple<'_> {
983                fn from(value: getNumberOfInputsReturn) -> Self {
984                    (value._0,)
985                }
986            }
987            #[automatically_derived]
988            #[doc(hidden)]
989            impl ::core::convert::From<UnderlyingRustTuple<'_>>
990            for getNumberOfInputsReturn {
991                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
992                    Self { _0: tuple.0 }
993                }
994            }
995        }
996        #[automatically_derived]
997        impl alloy_sol_types::SolCall for getNumberOfInputsCall {
998            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
999            type Token<'a> = <Self::Parameters<
1000                'a,
1001            > as alloy_sol_types::SolType>::Token<'a>;
1002            type Return = alloy::sol_types::private::primitives::aliases::U256;
1003            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1004            type ReturnToken<'a> = <Self::ReturnTuple<
1005                'a,
1006            > as alloy_sol_types::SolType>::Token<'a>;
1007            const SIGNATURE: &'static str = "getNumberOfInputs(address)";
1008            const SELECTOR: [u8; 4] = [97u8, 169u8, 60u8, 135u8];
1009            #[inline]
1010            fn new<'a>(
1011                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1012            ) -> Self {
1013                tuple.into()
1014            }
1015            #[inline]
1016            fn tokenize(&self) -> Self::Token<'_> {
1017                (
1018                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1019                        &self.appContract,
1020                    ),
1021                )
1022            }
1023            #[inline]
1024            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1025                (
1026                    <alloy::sol_types::sol_data::Uint<
1027                        256,
1028                    > as alloy_sol_types::SolType>::tokenize(ret),
1029                )
1030            }
1031            #[inline]
1032            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1033                <Self::ReturnTuple<
1034                    '_,
1035                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1036                    .map(|r| {
1037                        let r: getNumberOfInputsReturn = r.into();
1038                        r._0
1039                    })
1040            }
1041            #[inline]
1042            fn abi_decode_returns_validate(
1043                data: &[u8],
1044            ) -> alloy_sol_types::Result<Self::Return> {
1045                <Self::ReturnTuple<
1046                    '_,
1047                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1048                    .map(|r| {
1049                        let r: getNumberOfInputsReturn = r.into();
1050                        r._0
1051                    })
1052            }
1053        }
1054    };
1055    ///Container for all the [`InputBox`](self) function calls.
1056    #[derive(Clone)]
1057    #[derive(serde::Serialize, serde::Deserialize)]
1058    #[derive()]
1059    pub enum InputBoxCalls {
1060        #[allow(missing_docs)]
1061        addInput(addInputCall),
1062        #[allow(missing_docs)]
1063        getDeploymentBlockNumber(getDeploymentBlockNumberCall),
1064        #[allow(missing_docs)]
1065        getInputHash(getInputHashCall),
1066        #[allow(missing_docs)]
1067        getNumberOfInputs(getNumberOfInputsCall),
1068    }
1069    impl InputBoxCalls {
1070        /// All the selectors of this enum.
1071        ///
1072        /// Note that the selectors might not be in the same order as the variants.
1073        /// No guarantees are made about the order of the selectors.
1074        ///
1075        /// Prefer using `SolInterface` methods instead.
1076        pub const SELECTORS: &'static [[u8; 4usize]] = &[
1077            [23u8, 137u8, 205u8, 99u8],
1078            [97u8, 169u8, 60u8, 135u8],
1079            [103u8, 112u8, 135u8, 201u8],
1080            [179u8, 161u8, 172u8, 216u8],
1081        ];
1082        /// The names of the variants in the same order as `SELECTORS`.
1083        pub const VARIANT_NAMES: &'static [&'static str] = &[
1084            ::core::stringify!(addInput),
1085            ::core::stringify!(getNumberOfInputs),
1086            ::core::stringify!(getInputHash),
1087            ::core::stringify!(getDeploymentBlockNumber),
1088        ];
1089        /// The signatures in the same order as `SELECTORS`.
1090        pub const SIGNATURES: &'static [&'static str] = &[
1091            <addInputCall as alloy_sol_types::SolCall>::SIGNATURE,
1092            <getNumberOfInputsCall as alloy_sol_types::SolCall>::SIGNATURE,
1093            <getInputHashCall as alloy_sol_types::SolCall>::SIGNATURE,
1094            <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::SIGNATURE,
1095        ];
1096        /// Returns the signature for the given selector, if known.
1097        #[inline]
1098        pub fn signature_by_selector(
1099            selector: [u8; 4usize],
1100        ) -> ::core::option::Option<&'static str> {
1101            match Self::SELECTORS.binary_search(&selector) {
1102                ::core::result::Result::Ok(idx) => {
1103                    ::core::option::Option::Some(Self::SIGNATURES[idx])
1104                }
1105                ::core::result::Result::Err(_) => ::core::option::Option::None,
1106            }
1107        }
1108        /// Returns the enum variant name for the given selector, if known.
1109        #[inline]
1110        pub fn name_by_selector(
1111            selector: [u8; 4usize],
1112        ) -> ::core::option::Option<&'static str> {
1113            let sig = Self::signature_by_selector(selector)?;
1114            sig.split_once('(').map(|(name, _)| name)
1115        }
1116    }
1117    #[automatically_derived]
1118    impl alloy_sol_types::SolInterface for InputBoxCalls {
1119        const NAME: &'static str = "InputBoxCalls";
1120        const MIN_DATA_LENGTH: usize = 0usize;
1121        const COUNT: usize = 4usize;
1122        #[inline]
1123        fn selector(&self) -> [u8; 4] {
1124            match self {
1125                Self::addInput(_) => <addInputCall as alloy_sol_types::SolCall>::SELECTOR,
1126                Self::getDeploymentBlockNumber(_) => {
1127                    <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::SELECTOR
1128                }
1129                Self::getInputHash(_) => {
1130                    <getInputHashCall as alloy_sol_types::SolCall>::SELECTOR
1131                }
1132                Self::getNumberOfInputs(_) => {
1133                    <getNumberOfInputsCall as alloy_sol_types::SolCall>::SELECTOR
1134                }
1135            }
1136        }
1137        #[inline]
1138        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1139            Self::SELECTORS.get(i).copied()
1140        }
1141        #[inline]
1142        fn valid_selector(selector: [u8; 4]) -> bool {
1143            Self::SELECTORS.binary_search(&selector).is_ok()
1144        }
1145        #[inline]
1146        #[allow(non_snake_case)]
1147        fn abi_decode_raw(
1148            selector: [u8; 4],
1149            data: &[u8],
1150        ) -> alloy_sol_types::Result<Self> {
1151            static DECODE_SHIMS: &[fn(
1152                &[u8],
1153            ) -> alloy_sol_types::Result<InputBoxCalls>] = &[
1154                {
1155                    fn addInput(data: &[u8]) -> alloy_sol_types::Result<InputBoxCalls> {
1156                        <addInputCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
1157                            .map(InputBoxCalls::addInput)
1158                    }
1159                    addInput
1160                },
1161                {
1162                    fn getNumberOfInputs(
1163                        data: &[u8],
1164                    ) -> alloy_sol_types::Result<InputBoxCalls> {
1165                        <getNumberOfInputsCall as alloy_sol_types::SolCall>::abi_decode_raw(
1166                                data,
1167                            )
1168                            .map(InputBoxCalls::getNumberOfInputs)
1169                    }
1170                    getNumberOfInputs
1171                },
1172                {
1173                    fn getInputHash(
1174                        data: &[u8],
1175                    ) -> alloy_sol_types::Result<InputBoxCalls> {
1176                        <getInputHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
1177                                data,
1178                            )
1179                            .map(InputBoxCalls::getInputHash)
1180                    }
1181                    getInputHash
1182                },
1183                {
1184                    fn getDeploymentBlockNumber(
1185                        data: &[u8],
1186                    ) -> alloy_sol_types::Result<InputBoxCalls> {
1187                        <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw(
1188                                data,
1189                            )
1190                            .map(InputBoxCalls::getDeploymentBlockNumber)
1191                    }
1192                    getDeploymentBlockNumber
1193                },
1194            ];
1195            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1196                return Err(
1197                    alloy_sol_types::Error::unknown_selector(
1198                        <Self as alloy_sol_types::SolInterface>::NAME,
1199                        selector,
1200                    ),
1201                );
1202            };
1203            DECODE_SHIMS[idx](data)
1204        }
1205        #[inline]
1206        #[allow(non_snake_case)]
1207        fn abi_decode_raw_validate(
1208            selector: [u8; 4],
1209            data: &[u8],
1210        ) -> alloy_sol_types::Result<Self> {
1211            static DECODE_VALIDATE_SHIMS: &[fn(
1212                &[u8],
1213            ) -> alloy_sol_types::Result<InputBoxCalls>] = &[
1214                {
1215                    fn addInput(data: &[u8]) -> alloy_sol_types::Result<InputBoxCalls> {
1216                        <addInputCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1217                                data,
1218                            )
1219                            .map(InputBoxCalls::addInput)
1220                    }
1221                    addInput
1222                },
1223                {
1224                    fn getNumberOfInputs(
1225                        data: &[u8],
1226                    ) -> alloy_sol_types::Result<InputBoxCalls> {
1227                        <getNumberOfInputsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1228                                data,
1229                            )
1230                            .map(InputBoxCalls::getNumberOfInputs)
1231                    }
1232                    getNumberOfInputs
1233                },
1234                {
1235                    fn getInputHash(
1236                        data: &[u8],
1237                    ) -> alloy_sol_types::Result<InputBoxCalls> {
1238                        <getInputHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1239                                data,
1240                            )
1241                            .map(InputBoxCalls::getInputHash)
1242                    }
1243                    getInputHash
1244                },
1245                {
1246                    fn getDeploymentBlockNumber(
1247                        data: &[u8],
1248                    ) -> alloy_sol_types::Result<InputBoxCalls> {
1249                        <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1250                                data,
1251                            )
1252                            .map(InputBoxCalls::getDeploymentBlockNumber)
1253                    }
1254                    getDeploymentBlockNumber
1255                },
1256            ];
1257            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1258                return Err(
1259                    alloy_sol_types::Error::unknown_selector(
1260                        <Self as alloy_sol_types::SolInterface>::NAME,
1261                        selector,
1262                    ),
1263                );
1264            };
1265            DECODE_VALIDATE_SHIMS[idx](data)
1266        }
1267        #[inline]
1268        fn abi_encoded_size(&self) -> usize {
1269            match self {
1270                Self::addInput(inner) => {
1271                    <addInputCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1272                }
1273                Self::getDeploymentBlockNumber(inner) => {
1274                    <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::abi_encoded_size(
1275                        inner,
1276                    )
1277                }
1278                Self::getInputHash(inner) => {
1279                    <getInputHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
1280                        inner,
1281                    )
1282                }
1283                Self::getNumberOfInputs(inner) => {
1284                    <getNumberOfInputsCall as alloy_sol_types::SolCall>::abi_encoded_size(
1285                        inner,
1286                    )
1287                }
1288            }
1289        }
1290        #[inline]
1291        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1292            match self {
1293                Self::addInput(inner) => {
1294                    <addInputCall as alloy_sol_types::SolCall>::abi_encode_raw(
1295                        inner,
1296                        out,
1297                    )
1298                }
1299                Self::getDeploymentBlockNumber(inner) => {
1300                    <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::abi_encode_raw(
1301                        inner,
1302                        out,
1303                    )
1304                }
1305                Self::getInputHash(inner) => {
1306                    <getInputHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
1307                        inner,
1308                        out,
1309                    )
1310                }
1311                Self::getNumberOfInputs(inner) => {
1312                    <getNumberOfInputsCall as alloy_sol_types::SolCall>::abi_encode_raw(
1313                        inner,
1314                        out,
1315                    )
1316                }
1317            }
1318        }
1319    }
1320    ///Container for all the [`InputBox`](self) custom errors.
1321    #[derive(Clone)]
1322    #[derive(serde::Serialize, serde::Deserialize)]
1323    #[derive(Debug, PartialEq, Eq, Hash)]
1324    pub enum InputBoxErrors {
1325        #[allow(missing_docs)]
1326        InputTooLarge(InputTooLarge),
1327    }
1328    impl InputBoxErrors {
1329        /// All the selectors of this enum.
1330        ///
1331        /// Note that the selectors might not be in the same order as the variants.
1332        /// No guarantees are made about the order of the selectors.
1333        ///
1334        /// Prefer using `SolInterface` methods instead.
1335        pub const SELECTORS: &'static [[u8; 4usize]] = &[[159u8, 33u8, 184u8, 160u8]];
1336        /// The names of the variants in the same order as `SELECTORS`.
1337        pub const VARIANT_NAMES: &'static [&'static str] = &[
1338            ::core::stringify!(InputTooLarge),
1339        ];
1340        /// The signatures in the same order as `SELECTORS`.
1341        pub const SIGNATURES: &'static [&'static str] = &[
1342            <InputTooLarge as alloy_sol_types::SolError>::SIGNATURE,
1343        ];
1344        /// Returns the signature for the given selector, if known.
1345        #[inline]
1346        pub fn signature_by_selector(
1347            selector: [u8; 4usize],
1348        ) -> ::core::option::Option<&'static str> {
1349            match Self::SELECTORS.binary_search(&selector) {
1350                ::core::result::Result::Ok(idx) => {
1351                    ::core::option::Option::Some(Self::SIGNATURES[idx])
1352                }
1353                ::core::result::Result::Err(_) => ::core::option::Option::None,
1354            }
1355        }
1356        /// Returns the enum variant name for the given selector, if known.
1357        #[inline]
1358        pub fn name_by_selector(
1359            selector: [u8; 4usize],
1360        ) -> ::core::option::Option<&'static str> {
1361            let sig = Self::signature_by_selector(selector)?;
1362            sig.split_once('(').map(|(name, _)| name)
1363        }
1364    }
1365    #[automatically_derived]
1366    impl alloy_sol_types::SolInterface for InputBoxErrors {
1367        const NAME: &'static str = "InputBoxErrors";
1368        const MIN_DATA_LENGTH: usize = 96usize;
1369        const COUNT: usize = 1usize;
1370        #[inline]
1371        fn selector(&self) -> [u8; 4] {
1372            match self {
1373                Self::InputTooLarge(_) => {
1374                    <InputTooLarge as alloy_sol_types::SolError>::SELECTOR
1375                }
1376            }
1377        }
1378        #[inline]
1379        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1380            Self::SELECTORS.get(i).copied()
1381        }
1382        #[inline]
1383        fn valid_selector(selector: [u8; 4]) -> bool {
1384            Self::SELECTORS.binary_search(&selector).is_ok()
1385        }
1386        #[inline]
1387        #[allow(non_snake_case)]
1388        fn abi_decode_raw(
1389            selector: [u8; 4],
1390            data: &[u8],
1391        ) -> alloy_sol_types::Result<Self> {
1392            static DECODE_SHIMS: &[fn(
1393                &[u8],
1394            ) -> alloy_sol_types::Result<InputBoxErrors>] = &[
1395                {
1396                    fn InputTooLarge(
1397                        data: &[u8],
1398                    ) -> alloy_sol_types::Result<InputBoxErrors> {
1399                        <InputTooLarge as alloy_sol_types::SolError>::abi_decode_raw(
1400                                data,
1401                            )
1402                            .map(InputBoxErrors::InputTooLarge)
1403                    }
1404                    InputTooLarge
1405                },
1406            ];
1407            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1408                return Err(
1409                    alloy_sol_types::Error::unknown_selector(
1410                        <Self as alloy_sol_types::SolInterface>::NAME,
1411                        selector,
1412                    ),
1413                );
1414            };
1415            DECODE_SHIMS[idx](data)
1416        }
1417        #[inline]
1418        #[allow(non_snake_case)]
1419        fn abi_decode_raw_validate(
1420            selector: [u8; 4],
1421            data: &[u8],
1422        ) -> alloy_sol_types::Result<Self> {
1423            static DECODE_VALIDATE_SHIMS: &[fn(
1424                &[u8],
1425            ) -> alloy_sol_types::Result<InputBoxErrors>] = &[
1426                {
1427                    fn InputTooLarge(
1428                        data: &[u8],
1429                    ) -> alloy_sol_types::Result<InputBoxErrors> {
1430                        <InputTooLarge as alloy_sol_types::SolError>::abi_decode_raw_validate(
1431                                data,
1432                            )
1433                            .map(InputBoxErrors::InputTooLarge)
1434                    }
1435                    InputTooLarge
1436                },
1437            ];
1438            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1439                return Err(
1440                    alloy_sol_types::Error::unknown_selector(
1441                        <Self as alloy_sol_types::SolInterface>::NAME,
1442                        selector,
1443                    ),
1444                );
1445            };
1446            DECODE_VALIDATE_SHIMS[idx](data)
1447        }
1448        #[inline]
1449        fn abi_encoded_size(&self) -> usize {
1450            match self {
1451                Self::InputTooLarge(inner) => {
1452                    <InputTooLarge as alloy_sol_types::SolError>::abi_encoded_size(inner)
1453                }
1454            }
1455        }
1456        #[inline]
1457        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1458            match self {
1459                Self::InputTooLarge(inner) => {
1460                    <InputTooLarge as alloy_sol_types::SolError>::abi_encode_raw(
1461                        inner,
1462                        out,
1463                    )
1464                }
1465            }
1466        }
1467    }
1468    ///Container for all the [`InputBox`](self) events.
1469    #[derive(Clone)]
1470    #[derive(serde::Serialize, serde::Deserialize)]
1471    #[derive(Debug, PartialEq, Eq, Hash)]
1472    pub enum InputBoxEvents {
1473        #[allow(missing_docs)]
1474        InputAdded(InputAdded),
1475    }
1476    impl InputBoxEvents {
1477        /// All the selectors of this enum.
1478        ///
1479        /// Note that the selectors might not be in the same order as the variants.
1480        /// No guarantees are made about the order of the selectors.
1481        ///
1482        /// Prefer using `SolInterface` methods instead.
1483        pub const SELECTORS: &'static [[u8; 32usize]] = &[
1484            [
1485                192u8, 93u8, 51u8, 113u8, 33u8, 166u8, 232u8, 96u8, 92u8, 110u8, 192u8,
1486                183u8, 42u8, 162u8, 156u8, 66u8, 16u8, 255u8, 230u8, 229u8, 185u8, 206u8,
1487                253u8, 214u8, 167u8, 5u8, 129u8, 136u8, 168u8, 246u8, 111u8, 152u8,
1488            ],
1489        ];
1490        /// The names of the variants in the same order as `SELECTORS`.
1491        pub const VARIANT_NAMES: &'static [&'static str] = &[
1492            ::core::stringify!(InputAdded),
1493        ];
1494        /// The signatures in the same order as `SELECTORS`.
1495        pub const SIGNATURES: &'static [&'static str] = &[
1496            <InputAdded as alloy_sol_types::SolEvent>::SIGNATURE,
1497        ];
1498        /// Returns the signature for the given selector, if known.
1499        #[inline]
1500        pub fn signature_by_selector(
1501            selector: [u8; 32usize],
1502        ) -> ::core::option::Option<&'static str> {
1503            match Self::SELECTORS.binary_search(&selector) {
1504                ::core::result::Result::Ok(idx) => {
1505                    ::core::option::Option::Some(Self::SIGNATURES[idx])
1506                }
1507                ::core::result::Result::Err(_) => ::core::option::Option::None,
1508            }
1509        }
1510        /// Returns the enum variant name for the given selector, if known.
1511        #[inline]
1512        pub fn name_by_selector(
1513            selector: [u8; 32usize],
1514        ) -> ::core::option::Option<&'static str> {
1515            let sig = Self::signature_by_selector(selector)?;
1516            sig.split_once('(').map(|(name, _)| name)
1517        }
1518    }
1519    #[automatically_derived]
1520    impl alloy_sol_types::SolEventInterface for InputBoxEvents {
1521        const NAME: &'static str = "InputBoxEvents";
1522        const COUNT: usize = 1usize;
1523        fn decode_raw_log(
1524            topics: &[alloy_sol_types::Word],
1525            data: &[u8],
1526        ) -> alloy_sol_types::Result<Self> {
1527            match topics.first().copied() {
1528                Some(<InputAdded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
1529                    <InputAdded as alloy_sol_types::SolEvent>::decode_raw_log(
1530                            topics,
1531                            data,
1532                        )
1533                        .map(Self::InputAdded)
1534                }
1535                _ => {
1536                    alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
1537                        name: <Self as alloy_sol_types::SolEventInterface>::NAME,
1538                        log: alloy_sol_types::private::Box::new(
1539                            alloy_sol_types::private::LogData::new_unchecked(
1540                                topics.to_vec(),
1541                                data.to_vec().into(),
1542                            ),
1543                        ),
1544                    })
1545                }
1546            }
1547        }
1548    }
1549    #[automatically_derived]
1550    impl alloy_sol_types::private::IntoLogData for InputBoxEvents {
1551        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1552            match self {
1553                Self::InputAdded(inner) => {
1554                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
1555                }
1556            }
1557        }
1558        fn into_log_data(self) -> alloy_sol_types::private::LogData {
1559            match self {
1560                Self::InputAdded(inner) => {
1561                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
1562                }
1563            }
1564        }
1565    }
1566    use alloy::contract as alloy_contract;
1567    /**Creates a new wrapper around an on-chain [`InputBox`](self) contract instance.
1568
1569See the [wrapper's documentation](`InputBoxInstance`) for more details.*/
1570    #[inline]
1571    pub const fn new<
1572        P: alloy_contract::private::Provider<N>,
1573        N: alloy_contract::private::Network,
1574    >(
1575        address: alloy_sol_types::private::Address,
1576        __provider: P,
1577    ) -> InputBoxInstance<P, N> {
1578        InputBoxInstance::<P, N>::new(address, __provider)
1579    }
1580    /**Deploys this contract using the given `provider` and constructor arguments, if any.
1581
1582Returns a new instance of the contract, if the deployment was successful.
1583
1584For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
1585    #[inline]
1586    pub fn deploy<
1587        P: alloy_contract::private::Provider<N>,
1588        N: alloy_contract::private::Network,
1589    >(
1590        __provider: P,
1591    ) -> impl ::core::future::Future<
1592        Output = alloy_contract::Result<InputBoxInstance<P, N>>,
1593    > {
1594        InputBoxInstance::<P, N>::deploy(__provider)
1595    }
1596    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
1597and constructor arguments, if any.
1598
1599This is a simple wrapper around creating a `RawCallBuilder` with the data set to
1600the bytecode concatenated with the constructor's ABI-encoded arguments.*/
1601    #[inline]
1602    pub fn deploy_builder<
1603        P: alloy_contract::private::Provider<N>,
1604        N: alloy_contract::private::Network,
1605    >(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
1606        InputBoxInstance::<P, N>::deploy_builder(__provider)
1607    }
1608    /**A [`InputBox`](self) instance.
1609
1610Contains type-safe methods for interacting with an on-chain instance of the
1611[`InputBox`](self) contract located at a given `address`, using a given
1612provider `P`.
1613
1614If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1615documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1616be used to deploy a new instance of the contract.
1617
1618See the [module-level documentation](self) for all the available methods.*/
1619    #[derive(Clone)]
1620    pub struct InputBoxInstance<P, N = alloy_contract::private::Ethereum> {
1621        address: alloy_sol_types::private::Address,
1622        provider: P,
1623        _network: ::core::marker::PhantomData<N>,
1624    }
1625    #[automatically_derived]
1626    impl<P, N> ::core::fmt::Debug for InputBoxInstance<P, N> {
1627        #[inline]
1628        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1629            f.debug_tuple("InputBoxInstance").field(&self.address).finish()
1630        }
1631    }
1632    /// Instantiation and getters/setters.
1633    impl<
1634        P: alloy_contract::private::Provider<N>,
1635        N: alloy_contract::private::Network,
1636    > InputBoxInstance<P, N> {
1637        /**Creates a new wrapper around an on-chain [`InputBox`](self) contract instance.
1638
1639See the [wrapper's documentation](`InputBoxInstance`) for more details.*/
1640        #[inline]
1641        pub const fn new(
1642            address: alloy_sol_types::private::Address,
1643            __provider: P,
1644        ) -> Self {
1645            Self {
1646                address,
1647                provider: __provider,
1648                _network: ::core::marker::PhantomData,
1649            }
1650        }
1651        /**Deploys this contract using the given `provider` and constructor arguments, if any.
1652
1653Returns a new instance of the contract, if the deployment was successful.
1654
1655For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
1656        #[inline]
1657        pub async fn deploy(
1658            __provider: P,
1659        ) -> alloy_contract::Result<InputBoxInstance<P, N>> {
1660            let call_builder = Self::deploy_builder(__provider);
1661            let contract_address = call_builder.deploy().await?;
1662            Ok(Self::new(contract_address, call_builder.provider))
1663        }
1664        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
1665and constructor arguments, if any.
1666
1667This is a simple wrapper around creating a `RawCallBuilder` with the data set to
1668the bytecode concatenated with the constructor's ABI-encoded arguments.*/
1669        #[inline]
1670        pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
1671            alloy_contract::RawCallBuilder::new_raw_deploy(
1672                __provider,
1673                ::core::clone::Clone::clone(&BYTECODE),
1674            )
1675        }
1676        /// Returns a reference to the address.
1677        #[inline]
1678        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1679            &self.address
1680        }
1681        /// Sets the address.
1682        #[inline]
1683        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1684            self.address = address;
1685        }
1686        /// Sets the address and returns `self`.
1687        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1688            self.set_address(address);
1689            self
1690        }
1691        /// Returns a reference to the provider.
1692        #[inline]
1693        pub const fn provider(&self) -> &P {
1694            &self.provider
1695        }
1696    }
1697    impl<P: ::core::clone::Clone, N> InputBoxInstance<&P, N> {
1698        /// Clones the provider and returns a new instance with the cloned provider.
1699        #[inline]
1700        pub fn with_cloned_provider(self) -> InputBoxInstance<P, N> {
1701            InputBoxInstance {
1702                address: self.address,
1703                provider: ::core::clone::Clone::clone(&self.provider),
1704                _network: ::core::marker::PhantomData,
1705            }
1706        }
1707    }
1708    /// Function calls.
1709    impl<
1710        P: alloy_contract::private::Provider<N>,
1711        N: alloy_contract::private::Network,
1712    > InputBoxInstance<P, N> {
1713        /// Creates a new call builder using this contract instance's provider and address.
1714        ///
1715        /// Note that the call can be any function call, not just those defined in this
1716        /// contract. Prefer using the other methods for building type-safe contract calls.
1717        pub fn call_builder<C: alloy_sol_types::SolCall>(
1718            &self,
1719            call: &C,
1720        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
1721            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1722        }
1723        ///Creates a new call builder for the [`addInput`] function.
1724        pub fn addInput(
1725            &self,
1726            appContract: alloy::sol_types::private::Address,
1727            payload: alloy::sol_types::private::Bytes,
1728        ) -> alloy_contract::SolCallBuilder<&P, addInputCall, N> {
1729            self.call_builder(
1730                &addInputCall {
1731                    appContract,
1732                    payload,
1733                },
1734            )
1735        }
1736        ///Creates a new call builder for the [`getDeploymentBlockNumber`] function.
1737        pub fn getDeploymentBlockNumber(
1738            &self,
1739        ) -> alloy_contract::SolCallBuilder<&P, getDeploymentBlockNumberCall, N> {
1740            self.call_builder(&getDeploymentBlockNumberCall)
1741        }
1742        ///Creates a new call builder for the [`getInputHash`] function.
1743        pub fn getInputHash(
1744            &self,
1745            appContract: alloy::sol_types::private::Address,
1746            index: alloy::sol_types::private::primitives::aliases::U256,
1747        ) -> alloy_contract::SolCallBuilder<&P, getInputHashCall, N> {
1748            self.call_builder(
1749                &getInputHashCall {
1750                    appContract,
1751                    index,
1752                },
1753            )
1754        }
1755        ///Creates a new call builder for the [`getNumberOfInputs`] function.
1756        pub fn getNumberOfInputs(
1757            &self,
1758            appContract: alloy::sol_types::private::Address,
1759        ) -> alloy_contract::SolCallBuilder<&P, getNumberOfInputsCall, N> {
1760            self.call_builder(
1761                &getNumberOfInputsCall {
1762                    appContract,
1763                },
1764            )
1765        }
1766    }
1767    /// Event filters.
1768    impl<
1769        P: alloy_contract::private::Provider<N>,
1770        N: alloy_contract::private::Network,
1771    > InputBoxInstance<P, N> {
1772        /// Creates a new event filter using this contract instance's provider and address.
1773        ///
1774        /// Note that the type can be any event, not just those defined in this contract.
1775        /// Prefer using the other methods for building type-safe event filters.
1776        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1777            &self,
1778        ) -> alloy_contract::Event<&P, E, N> {
1779            alloy_contract::Event::new_sol(&self.provider, &self.address)
1780        }
1781        ///Creates a new event filter for the [`InputAdded`] event.
1782        pub fn InputAdded_filter(&self) -> alloy_contract::Event<&P, InputAdded, N> {
1783            self.event_filter::<InputAdded>()
1784        }
1785    }
1786}