1#[allow(
10 non_camel_case_types,
11 non_snake_case,
12 clippy::pub_underscore_fields,
13 clippy::style,
14 clippy::empty_structs_with_brackets
15)]
16pub mod TimelockController {
17 use super::*;
18 use alloy::sol_types as alloy_sol_types;
19 #[derive(serde::Serialize, serde::Deserialize)]
20 #[derive(Default, Debug, PartialEq, Eq, Hash)]
21 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
22 #[derive(Clone)]
23 pub struct OperationState(u8);
24 const _: () = {
25 use alloy::sol_types as alloy_sol_types;
26 #[automatically_derived]
27 impl alloy_sol_types::private::SolTypeValue<OperationState> for u8 {
28 #[inline]
29 fn stv_to_tokens(
30 &self,
31 ) -> <alloy::sol_types::sol_data::Uint<
32 8,
33 > as alloy_sol_types::SolType>::Token<'_> {
34 alloy_sol_types::private::SolTypeValue::<
35 alloy::sol_types::sol_data::Uint<8>,
36 >::stv_to_tokens(self)
37 }
38 #[inline]
39 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
40 <alloy::sol_types::sol_data::Uint<
41 8,
42 > as alloy_sol_types::SolType>::tokenize(self)
43 .0
44 }
45 #[inline]
46 fn stv_abi_encode_packed_to(
47 &self,
48 out: &mut alloy_sol_types::private::Vec<u8>,
49 ) {
50 <alloy::sol_types::sol_data::Uint<
51 8,
52 > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
53 }
54 #[inline]
55 fn stv_abi_packed_encoded_size(&self) -> usize {
56 <alloy::sol_types::sol_data::Uint<
57 8,
58 > as alloy_sol_types::SolType>::abi_encoded_size(self)
59 }
60 }
61 #[automatically_derived]
62 impl OperationState {
63 pub const NAME: &'static str = stringify!(@ name);
65 #[inline]
67 pub const fn from_underlying(value: u8) -> Self {
68 Self(value)
69 }
70 #[inline]
72 pub const fn into_underlying(self) -> u8 {
73 self.0
74 }
75 #[inline]
78 pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
79 <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
80 }
81 #[inline]
84 pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
85 <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
86 }
87 }
88 #[automatically_derived]
89 impl From<u8> for OperationState {
90 fn from(value: u8) -> Self {
91 Self::from_underlying(value)
92 }
93 }
94 #[automatically_derived]
95 impl From<OperationState> for u8 {
96 fn from(value: OperationState) -> Self {
97 value.into_underlying()
98 }
99 }
100 #[automatically_derived]
101 impl alloy_sol_types::SolType for OperationState {
102 type RustType = u8;
103 type Token<'a> = <alloy::sol_types::sol_data::Uint<
104 8,
105 > as alloy_sol_types::SolType>::Token<'a>;
106 const SOL_NAME: &'static str = Self::NAME;
107 const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
108 8,
109 > as alloy_sol_types::SolType>::ENCODED_SIZE;
110 const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
111 8,
112 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
113 #[inline]
114 fn valid_token(token: &Self::Token<'_>) -> bool {
115 Self::type_check(token).is_ok()
116 }
117 #[inline]
118 fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
119 <alloy::sol_types::sol_data::Uint<
120 8,
121 > as alloy_sol_types::SolType>::type_check(token)
122 }
123 #[inline]
124 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
125 <alloy::sol_types::sol_data::Uint<
126 8,
127 > as alloy_sol_types::SolType>::detokenize(token)
128 }
129 }
130 #[automatically_derived]
131 impl alloy_sol_types::EventTopic for OperationState {
132 #[inline]
133 fn topic_preimage_length(rust: &Self::RustType) -> usize {
134 <alloy::sol_types::sol_data::Uint<
135 8,
136 > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
137 }
138 #[inline]
139 fn encode_topic_preimage(
140 rust: &Self::RustType,
141 out: &mut alloy_sol_types::private::Vec<u8>,
142 ) {
143 <alloy::sol_types::sol_data::Uint<
144 8,
145 > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
146 }
147 #[inline]
148 fn encode_topic(
149 rust: &Self::RustType,
150 ) -> alloy_sol_types::abi::token::WordToken {
151 <alloy::sol_types::sol_data::Uint<
152 8,
153 > as alloy_sol_types::EventTopic>::encode_topic(rust)
154 }
155 }
156 };
157 use alloy::contract as alloy_contract;
158 #[inline]
162 pub const fn new<
163 P: alloy_contract::private::Provider<N>,
164 N: alloy_contract::private::Network,
165 >(
166 address: alloy_sol_types::private::Address,
167 __provider: P,
168 ) -> TimelockControllerInstance<P, N> {
169 TimelockControllerInstance::<P, N>::new(address, __provider)
170 }
171 #[derive(Clone)]
183 pub struct TimelockControllerInstance<P, N = alloy_contract::private::Ethereum> {
184 address: alloy_sol_types::private::Address,
185 provider: P,
186 _network: ::core::marker::PhantomData<N>,
187 }
188 #[automatically_derived]
189 impl<P, N> ::core::fmt::Debug for TimelockControllerInstance<P, N> {
190 #[inline]
191 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
192 f.debug_tuple("TimelockControllerInstance").field(&self.address).finish()
193 }
194 }
195 #[automatically_derived]
197 impl<
198 P: alloy_contract::private::Provider<N>,
199 N: alloy_contract::private::Network,
200 > TimelockControllerInstance<P, N> {
201 #[inline]
205 pub const fn new(
206 address: alloy_sol_types::private::Address,
207 __provider: P,
208 ) -> Self {
209 Self {
210 address,
211 provider: __provider,
212 _network: ::core::marker::PhantomData,
213 }
214 }
215 #[inline]
217 pub const fn address(&self) -> &alloy_sol_types::private::Address {
218 &self.address
219 }
220 #[inline]
222 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
223 self.address = address;
224 }
225 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
227 self.set_address(address);
228 self
229 }
230 #[inline]
232 pub const fn provider(&self) -> &P {
233 &self.provider
234 }
235 }
236 impl<P: ::core::clone::Clone, N> TimelockControllerInstance<&P, N> {
237 #[inline]
239 pub fn with_cloned_provider(self) -> TimelockControllerInstance<P, N> {
240 TimelockControllerInstance {
241 address: self.address,
242 provider: ::core::clone::Clone::clone(&self.provider),
243 _network: ::core::marker::PhantomData,
244 }
245 }
246 }
247 #[automatically_derived]
249 impl<
250 P: alloy_contract::private::Provider<N>,
251 N: alloy_contract::private::Network,
252 > TimelockControllerInstance<P, N> {
253 pub fn call_builder<C: alloy_sol_types::SolCall>(
258 &self,
259 call: &C,
260 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
261 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
262 }
263 }
264 #[automatically_derived]
266 impl<
267 P: alloy_contract::private::Provider<N>,
268 N: alloy_contract::private::Network,
269 > TimelockControllerInstance<P, N> {
270 pub fn event_filter<E: alloy_sol_types::SolEvent>(
275 &self,
276 ) -> alloy_contract::Event<&P, E, N> {
277 alloy_contract::Event::new_sol(&self.provider, &self.address)
278 }
279 }
280}
281#[allow(
1345 non_camel_case_types,
1346 non_snake_case,
1347 clippy::pub_underscore_fields,
1348 clippy::style,
1349 clippy::empty_structs_with_brackets
1350)]
1351pub mod OpsTimelock {
1352 use super::*;
1353 use alloy::sol_types as alloy_sol_types;
1354 #[rustfmt::skip]
1360 #[allow(clippy::all)]
1361 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
1362 b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x1D\x0B8\x03\x80a\x1D\x0B\x839\x81\x01`@\x81\x90Ra\0.\x91a\x02\xFEV[\x83\x83\x83\x83a\0<_0a\x01\x83V[P`\x01`\x01`\xA0\x1B\x03\x81\x16\x15a\0XWa\0V_\x82a\x01\x83V[P[_[\x83Q\x81\x10\x15a\0\xECWa\0\xAC\x7F\xB0\x9A\xA5\xAE\xB3p,\xFDP\xB6\xB6+\xC4S&\x04\x93\x8F!$\x8A'\xA1\xD5\xCAs`\x82\xB6\x81\x9C\xC1\x85\x83\x81Q\x81\x10a\0\x99Wa\0\x99a\x03}V[` \x02` \x01\x01Qa\x01\x83` \x1B` \x1CV[Pa\0\xE3\x7F\xFDd<rq\x0Cc\xC0\x18\x02Y\xAB\xA6\xB2\xD0TQ\xE3Y\x1A$\xE5\x8Bb#\x93x\x08W&\xF7\x83\x85\x83\x81Q\x81\x10a\0\x99Wa\0\x99a\x03}V[P`\x01\x01a\0ZV[P_[\x82Q\x81\x10\x15a\x017Wa\x01.\x7F\xD8\xAA\x0F1\x94\x97\x1A*\x11fy\xF7\xC2\t\x0Fi9\xC8\xD4\xE0\x1A*\x8D~A\xD5^SQF\x9Ec\x84\x83\x81Q\x81\x10a\0\x99Wa\0\x99a\x03}V[P`\x01\x01a\0\xEFV[P`\x02\x84\x90U`@\x80Q_\x81R` \x81\x01\x86\x90R\x7F\x11\xC2ON\xAD\x16P|i\xACF\x7F\xBD^N\xED_\xB5\xC6\x99bm,\xC6\xD6d!\xDF%8\x86\xD5\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPa\x03\x91V[_\x82\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x85\x16\x84R\x90\x91R\x81 T`\xFF\x16a\x02#W_\x83\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x86\x16\x84R\x90\x91R\x90 \x80T`\xFF\x19\x16`\x01\x17\x90Ua\x01\xDB3\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x84\x7F/\x87\x88\x11~~\xFF\x1D\x82\xE9&\xECyI\x01\xD1|x\x02JP'\t@0E@\xA73eo\r`@Q`@Q\x80\x91\x03\x90\xA4P`\x01a\x02&V[P_[\x92\x91PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[\x80Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x02VW__\xFD[\x91\x90PV[_\x82`\x1F\x83\x01\x12a\x02jW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\x83Wa\x02\x83a\x02,V[`@Q`\x05\x82\x90\x1B\x90`?\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x02\xB1Wa\x02\xB1a\x02,V[`@R\x91\x82R` \x81\x85\x01\x81\x01\x92\x90\x81\x01\x86\x84\x11\x15a\x02\xCEW__\xFD[` \x86\x01\x92P[\x83\x83\x10\x15a\x02\xF4Wa\x02\xE6\x83a\x02@V[\x81R` \x92\x83\x01\x92\x01a\x02\xD5V[P\x95\x94PPPPPV[____`\x80\x85\x87\x03\x12\x15a\x03\x11W__\xFD[\x84Q` \x86\x01Q\x90\x94P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03.W__\xFD[a\x03:\x87\x82\x88\x01a\x02[V[`@\x87\x01Q\x90\x94P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03WW__\xFD[a\x03c\x87\x82\x88\x01a\x02[V[\x92PPa\x03r``\x86\x01a\x02@V[\x90P\x92\x95\x91\x94P\x92PV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[a\x19m\x80a\x03\x9E_9_\xF3\xFE`\x80`@R`\x046\x10a\x01\xB2W_5`\xE0\x1C\x80c\x80ee\x7F\x11a\0\xE7W\x80c\xBC\x19|\x81\x11a\0\x87W\x80c\xD5Gt\x1F\x11a\0bW\x80c\xD5Gt\x1F\x14a\x05FW\x80c\xE3\x835\xE5\x14a\x05eW\x80c\xF2:na\x14a\x05xW\x80c\xF2z\x0C\x92\x14a\x05\xA3W__\xFD[\x80c\xBC\x19|\x81\x14a\x04\xD1W\x80c\xC4\xD2R\xF5\x14a\x04\xFCW\x80c\xD4\\D5\x14a\x05\x1BW__\xFD[\x80c\x91\xD1HT\x11a\0\xC2W\x80c\x91\xD1HT\x14a\x04MW\x80c\xA2\x17\xFD\xDF\x14a\x04lW\x80c\xB0\x8EQ\xC0\x14a\x04\x7FW\x80c\xB1\xC5\xF4'\x14a\x04\xB2W__\xFD[\x80c\x80ee\x7F\x14a\x03\xDCW\x80c\x8F*\x0B\xB0\x14a\x03\xFBW\x80c\x8Fa\xF4\xF5\x14a\x04\x1AW__\xFD[\x80c*\xB0\xF5)\x11a\x01RW\x80c6V\x8A\xBE\x11a\x01-W\x80c6V\x8A\xBE\x14a\x03SW\x80cXK\x15>\x14a\x03rW\x80cd\xD6#S\x14a\x03\x91W\x80cyX\0L\x14a\x03\xB0W__\xFD[\x80c*\xB0\xF5)\x14a\x02\xF6W\x80c//\xF1]\x14a\x03\x15W\x80c1\xD5\x07P\x14a\x034W__\xFD[\x80c\x13@\x08\xD3\x11a\x01\x8DW\x80c\x13@\x08\xD3\x14a\x02SW\x80c\x13\xBC\x9F \x14a\x02fW\x80c\x15\x0Bz\x02\x14a\x02\x85W\x80c$\x8A\x9C\xA3\x14a\x02\xC8W__\xFD[\x80c\x01\xD5\x06*\x14a\x01\xBDW\x80c\x01\xFF\xC9\xA7\x14a\x01\xDEW\x80c\x07\xBD\x02e\x14a\x02\x12W__\xFD[6a\x01\xB9W\0[__\xFD[4\x80\x15a\x01\xC8W__\xFD[Pa\x01\xDCa\x01\xD76`\x04a\x11cV[a\x05\xB7V[\0[4\x80\x15a\x01\xE9W__\xFD[Pa\x01\xFDa\x01\xF86`\x04a\x11\xD1V[a\x06\x8BV[`@Q\x90\x15\x15\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\x1DW__\xFD[Pa\x02E\x7F\xD8\xAA\x0F1\x94\x97\x1A*\x11fy\xF7\xC2\t\x0Fi9\xC8\xD4\xE0\x1A*\x8D~A\xD5^SQF\x9Ec\x81V[`@Q\x90\x81R` \x01a\x02\tV[a\x01\xDCa\x02a6`\x04a\x11\xF8V[a\x06\x9BV[4\x80\x15a\x02qW__\xFD[Pa\x01\xFDa\x02\x806`\x04a\x12^V[a\x07MV[4\x80\x15a\x02\x90W__\xFD[Pa\x02\xAFa\x02\x9F6`\x04a\x13$V[c\n\x85\xBD\x01`\xE1\x1B\x94\x93PPPPV[`@Q`\x01`\x01`\xE0\x1B\x03\x19\x90\x91\x16\x81R` \x01a\x02\tV[4\x80\x15a\x02\xD3W__\xFD[Pa\x02Ea\x02\xE26`\x04a\x12^V[_\x90\x81R` \x81\x90R`@\x90 `\x01\x01T\x90V[4\x80\x15a\x03\x01W__\xFD[Pa\x01\xFDa\x03\x106`\x04a\x12^V[a\x07rV[4\x80\x15a\x03 W__\xFD[Pa\x01\xDCa\x03/6`\x04a\x13\x87V[a\x07zV[4\x80\x15a\x03?W__\xFD[Pa\x01\xFDa\x03N6`\x04a\x12^V[a\x07\xA4V[4\x80\x15a\x03^W__\xFD[Pa\x01\xDCa\x03m6`\x04a\x13\x87V[a\x07\xC8V[4\x80\x15a\x03}W__\xFD[Pa\x01\xFDa\x03\x8C6`\x04a\x12^V[a\x08\0V[4\x80\x15a\x03\x9CW__\xFD[Pa\x01\xDCa\x03\xAB6`\x04a\x12^V[a\x08EV[4\x80\x15a\x03\xBBW__\xFD[Pa\x03\xCFa\x03\xCA6`\x04a\x12^V[a\x08\xB8V[`@Qa\x02\t\x91\x90a\x13\xC5V[4\x80\x15a\x03\xE7W__\xFD[Pa\x02Ea\x03\xF66`\x04a\x11\xF8V[a\t\0V[4\x80\x15a\x04\x06W__\xFD[Pa\x01\xDCa\x04\x156`\x04a\x14+V[a\t>V[4\x80\x15a\x04%W__\xFD[Pa\x02E\x7F\xB0\x9A\xA5\xAE\xB3p,\xFDP\xB6\xB6+\xC4S&\x04\x93\x8F!$\x8A'\xA1\xD5\xCAs`\x82\xB6\x81\x9C\xC1\x81V[4\x80\x15a\x04XW__\xFD[Pa\x01\xFDa\x04g6`\x04a\x13\x87V[a\n\xCAV[4\x80\x15a\x04wW__\xFD[Pa\x02E_\x81V[4\x80\x15a\x04\x8AW__\xFD[Pa\x02E\x7F\xFDd<rq\x0Cc\xC0\x18\x02Y\xAB\xA6\xB2\xD0TQ\xE3Y\x1A$\xE5\x8Bb#\x93x\x08W&\xF7\x83\x81V[4\x80\x15a\x04\xBDW__\xFD[Pa\x02Ea\x04\xCC6`\x04a\x14\xDDV[a\n\xF2V[4\x80\x15a\x04\xDCW__\xFD[Pa\x02\xAFa\x04\xEB6`\x04a\x16\x06V[c\xBC\x19|\x81`\xE0\x1B\x95\x94PPPPPV[4\x80\x15a\x05\x07W__\xFD[Pa\x01\xDCa\x05\x166`\x04a\x12^V[a\x0B6V[4\x80\x15a\x05&W__\xFD[Pa\x02Ea\x0556`\x04a\x12^V[_\x90\x81R`\x01` R`@\x90 T\x90V[4\x80\x15a\x05QW__\xFD[Pa\x01\xDCa\x05`6`\x04a\x13\x87V[a\x0B\xE0V[a\x01\xDCa\x05s6`\x04a\x14\xDDV[a\x0C\x04V[4\x80\x15a\x05\x83W__\xFD[Pa\x02\xAFa\x05\x926`\x04a\x16\xB2V[c\xF2:na`\xE0\x1B\x95\x94PPPPPV[4\x80\x15a\x05\xAEW__\xFD[P`\x02Ta\x02EV[\x7F\xB0\x9A\xA5\xAE\xB3p,\xFDP\xB6\xB6+\xC4S&\x04\x93\x8F!$\x8A'\xA1\xD5\xCAs`\x82\xB6\x81\x9C\xC1a\x05\xE1\x81a\r\x85V[_a\x05\xF0\x89\x89\x89\x89\x89\x89a\t\0V[\x90Pa\x05\xFC\x81\x84a\r\x92V[_\x81\x7FL\xF4A\x0C\xC5p@\xE4Hb\xEF\x0FE\xF3\xDDZ^\x02\xDB\x8E\xB8\xAD\xD6H\xD4\xB0\xE26\xF1\xD0}\xCA\x8B\x8B\x8B\x8B\x8B\x8A`@Qa\x067\x96\x95\x94\x93\x92\x91\x90a\x17-V[`@Q\x80\x91\x03\x90\xA3\x83\x15a\x06\x80W\x80\x7F \xFD\xA5\xFD'\xA1\xEA{\xF5\xB9V\x7F\x14:\xC5G\x0B\xB0Y7J'\xE8\xF6|\xB4O\x94om\x03\x87\x85`@Qa\x06w\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA2[PPPPPPPPPV[_a\x06\x95\x82a\x0E#V[\x92\x91PPV[\x7F\xD8\xAA\x0F1\x94\x97\x1A*\x11fy\xF7\xC2\t\x0Fi9\xC8\xD4\xE0\x1A*\x8D~A\xD5^SQF\x9Eca\x06\xC6\x81_a\n\xCAV[a\x06\xD4Wa\x06\xD4\x813a\x0EGV[_a\x06\xE3\x88\x88\x88\x88\x88\x88a\t\0V[\x90Pa\x06\xEF\x81\x85a\x0E\x84V[a\x06\xFB\x88\x88\x88\x88a\x0E\xD2V[_\x81\x7F\xC2a~\xFAi\xBA\xB6g\x82\xFA!\x95CqC8H\x9CN\x9E\x17\x82qV\n\x91\xB8,?a+X\x8A\x8A\x8A\x8A`@Qa\x072\x94\x93\x92\x91\x90a\x17iV[`@Q\x80\x91\x03\x90\xA3a\x07C\x81a\x0FFV[PPPPPPPPV[_`\x02[a\x07Z\x83a\x08\xB8V[`\x03\x81\x11\x15a\x07kWa\x07ka\x13\xB1V[\x14\x92\x91PPV[_`\x03a\x07QV[_\x82\x81R` \x81\x90R`@\x90 `\x01\x01Ta\x07\x94\x81a\r\x85V[a\x07\x9E\x83\x83a\x0FqV[PPPPV[_\x80a\x07\xAF\x83a\x08\xB8V[`\x03\x81\x11\x15a\x07\xC0Wa\x07\xC0a\x13\xB1V[\x14\x15\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x81\x163\x14a\x07\xF1W`@Qc3K\xD9\x19`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x07\xFB\x82\x82a\x10\0V[PPPV[__a\x08\x0B\x83a\x08\xB8V[\x90P`\x01\x81`\x03\x81\x11\x15a\x08!Wa\x08!a\x13\xB1V[\x14\x80a\x08>WP`\x02\x81`\x03\x81\x11\x15a\x08<Wa\x08<a\x13\xB1V[\x14[\x93\x92PPPV[30\x81\x14a\x08vW`@Qc\xE2\x85\x0CY`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01[`@Q\x80\x91\x03\x90\xFD[`\x02T`@\x80Q\x91\x82R` \x82\x01\x84\x90R\x7F\x11\xC2ON\xAD\x16P|i\xACF\x7F\xBD^N\xED_\xB5\xC6\x99bm,\xC6\xD6d!\xDF%8\x86\xD5\x91\x01`@Q\x80\x91\x03\x90\xA1P`\x02UV[_\x81\x81R`\x01` R`@\x81 T\x80_\x03a\x08\xD5WP_\x92\x91PPV[`\x01\x81\x03a\x08\xE6WP`\x03\x92\x91PPV[B\x81\x11\x15a\x08\xF7WP`\x01\x92\x91PPV[P`\x02\x92\x91PPV[_\x86\x86\x86\x86\x86\x86`@Q` \x01a\t\x1C\x96\x95\x94\x93\x92\x91\x90a\x17-V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x96\x95PPPPPPV[\x7F\xB0\x9A\xA5\xAE\xB3p,\xFDP\xB6\xB6+\xC4S&\x04\x93\x8F!$\x8A'\xA1\xD5\xCAs`\x82\xB6\x81\x9C\xC1a\th\x81a\r\x85V[\x88\x87\x14\x15\x80a\twWP\x88\x85\x14\x15[\x15a\t\xA9W`@Q`\x01bO\xCD\xEF`\xE0\x1B\x03\x19\x81R`\x04\x81\x01\x8A\x90R`$\x81\x01\x86\x90R`D\x81\x01\x88\x90R`d\x01a\x08mV[_a\t\xBA\x8B\x8B\x8B\x8B\x8B\x8B\x8B\x8Ba\n\xF2V[\x90Pa\t\xC6\x81\x84a\r\x92V[_[\x8A\x81\x10\x15a\n{W\x80\x82\x7FL\xF4A\x0C\xC5p@\xE4Hb\xEF\x0FE\xF3\xDDZ^\x02\xDB\x8E\xB8\xAD\xD6H\xD4\xB0\xE26\xF1\xD0}\xCA\x8E\x8E\x85\x81\x81\x10a\n\x05Wa\n\x05a\x17\x90V[\x90P` \x02\x01` \x81\x01\x90a\n\x1A\x91\x90a\x17\xA4V[\x8D\x8D\x86\x81\x81\x10a\n,Wa\n,a\x17\x90V[\x90P` \x02\x015\x8C\x8C\x87\x81\x81\x10a\nEWa\nEa\x17\x90V[\x90P` \x02\x81\x01\x90a\nW\x91\x90a\x17\xBDV[\x8C\x8B`@Qa\nk\x96\x95\x94\x93\x92\x91\x90a\x17-V[`@Q\x80\x91\x03\x90\xA3`\x01\x01a\t\xC8V[P\x83\x15a\n\xBDW\x80\x7F \xFD\xA5\xFD'\xA1\xEA{\xF5\xB9V\x7F\x14:\xC5G\x0B\xB0Y7J'\xE8\xF6|\xB4O\x94om\x03\x87\x85`@Qa\n\xB4\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA2[PPPPPPPPPPPV[_\x91\x82R` \x82\x81R`@\x80\x84 `\x01`\x01`\xA0\x1B\x03\x93\x90\x93\x16\x84R\x91\x90R\x90 T`\xFF\x16\x90V[_\x88\x88\x88\x88\x88\x88\x88\x88`@Q` \x01a\x0B\x12\x98\x97\x96\x95\x94\x93\x92\x91\x90a\x18\x93V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x98\x97PPPPPPPPV[\x7F\xFDd<rq\x0Cc\xC0\x18\x02Y\xAB\xA6\xB2\xD0TQ\xE3Y\x1A$\xE5\x8Bb#\x93x\x08W&\xF7\x83a\x0B`\x81a\r\x85V[a\x0Bi\x82a\x08\0V[a\x0B\xA5W\x81a\x0Bx`\x02a\x10iV[a\x0B\x82`\x01a\x10iV[`@Qc^\xAD\x8E\xB5`\xE0\x1B\x81R`\x04\x81\x01\x93\x90\x93R\x17`$\x82\x01R`D\x01a\x08mV[_\x82\x81R`\x01` R`@\x80\x82 \x82\x90UQ\x83\x91\x7F\xBA\xA1\xEB\"\xF2\xA4\x92\xBA\x1A_\xEAa\xB8\xDFM'\xC6\xC8\xB5\xF3\x97\x1Ec\xBBX\xFA\x14\xFFr\xEE\xDBp\x91\xA2PPV[_\x82\x81R` \x81\x90R`@\x90 `\x01\x01Ta\x0B\xFA\x81a\r\x85V[a\x07\x9E\x83\x83a\x10\0V[\x7F\xD8\xAA\x0F1\x94\x97\x1A*\x11fy\xF7\xC2\t\x0Fi9\xC8\xD4\xE0\x1A*\x8D~A\xD5^SQF\x9Eca\x0C/\x81_a\n\xCAV[a\x0C=Wa\x0C=\x813a\x0EGV[\x87\x86\x14\x15\x80a\x0CLWP\x87\x84\x14\x15[\x15a\x0C~W`@Q`\x01bO\xCD\xEF`\xE0\x1B\x03\x19\x81R`\x04\x81\x01\x89\x90R`$\x81\x01\x85\x90R`D\x81\x01\x87\x90R`d\x01a\x08mV[_a\x0C\x8F\x8A\x8A\x8A\x8A\x8A\x8A\x8A\x8Aa\n\xF2V[\x90Pa\x0C\x9B\x81\x85a\x0E\x84V[_[\x89\x81\x10\x15a\roW_\x8B\x8B\x83\x81\x81\x10a\x0C\xB8Wa\x0C\xB8a\x17\x90V[\x90P` \x02\x01` \x81\x01\x90a\x0C\xCD\x91\x90a\x17\xA4V[\x90P_\x8A\x8A\x84\x81\x81\x10a\x0C\xE2Wa\x0C\xE2a\x17\x90V[\x90P` \x02\x015\x90P6_\x8A\x8A\x86\x81\x81\x10a\x0C\xFFWa\x0C\xFFa\x17\x90V[\x90P` \x02\x81\x01\x90a\r\x11\x91\x90a\x17\xBDV[\x91P\x91Pa\r!\x84\x84\x84\x84a\x0E\xD2V[\x84\x86\x7F\xC2a~\xFAi\xBA\xB6g\x82\xFA!\x95CqC8H\x9CN\x9E\x17\x82qV\n\x91\xB8,?a+X\x86\x86\x86\x86`@Qa\rX\x94\x93\x92\x91\x90a\x17iV[`@Q\x80\x91\x03\x90\xA3PPPP\x80`\x01\x01\x90Pa\x0C\x9DV[Pa\ry\x81a\x0FFV[PPPPPPPPPPV[a\r\x8F\x813a\x0EGV[PV[a\r\x9B\x82a\x07\xA4V[\x15a\r\xCCW\x81a\r\xAA_a\x10iV[`@Qc^\xAD\x8E\xB5`\xE0\x1B\x81R`\x04\x81\x01\x92\x90\x92R`$\x82\x01R`D\x01a\x08mV[_a\r\xD6`\x02T\x90V[\x90P\x80\x82\x10\x15a\x0E\x03W`@QcT3f\t`\xE0\x1B\x81R`\x04\x81\x01\x83\x90R`$\x81\x01\x82\x90R`D\x01a\x08mV[a\x0E\r\x82Ba\x192V[_\x93\x84R`\x01` R`@\x90\x93 \x92\x90\x92UPPV[_`\x01`\x01`\xE0\x1B\x03\x19\x82\x16c\x02q\x18\x97`\xE5\x1B\x14\x80a\x06\x95WPa\x06\x95\x82a\x10\x8BV[a\x0EQ\x82\x82a\n\xCAV[a\x0E\x80W`@Qc\xE2Q}?`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x81\x01\x83\x90R`D\x01a\x08mV[PPV[a\x0E\x8D\x82a\x07MV[a\x0E\x9CW\x81a\r\xAA`\x02a\x10iV[\x80\x15\x80\x15\x90a\x0E\xB1WPa\x0E\xAF\x81a\x07rV[\x15[\x15a\x0E\x80W`@Qc\x12\x154\xC3`\xE3\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x08mV[__\x85`\x01`\x01`\xA0\x1B\x03\x16\x85\x85\x85`@Qa\x0E\xEF\x92\x91\x90a\x19QV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0F)W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0F.V[``\x91P[P\x91P\x91Pa\x0F=\x82\x82a\x10\xBFV[PPPPPPPV[a\x0FO\x81a\x07MV[a\x0F^W\x80a\r\xAA`\x02a\x10iV[_\x90\x81R`\x01` \x81\x90R`@\x90\x91 UV[_a\x0F|\x83\x83a\n\xCAV[a\x0F\xF9W_\x83\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x86\x16\x84R\x90\x91R\x90 \x80T`\xFF\x19\x16`\x01\x17\x90Ua\x0F\xB13\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x84\x7F/\x87\x88\x11~~\xFF\x1D\x82\xE9&\xECyI\x01\xD1|x\x02JP'\t@0E@\xA73eo\r`@Q`@Q\x80\x91\x03\x90\xA4P`\x01a\x06\x95V[P_a\x06\x95V[_a\x10\x0B\x83\x83a\n\xCAV[\x15a\x0F\xF9W_\x83\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x86\x16\x80\x85R\x92R\x80\x83 \x80T`\xFF\x19\x16\x90UQ3\x92\x86\x91\x7F\xF69\x1F\\2\xD9\xC6\x9D*G\xEAg\x0BD)t\xB595\xD1\xED\xC7\xFDd\xEB!\xE0G\xA89\x17\x1B\x91\x90\xA4P`\x01a\x06\x95V[_\x81`\x03\x81\x11\x15a\x10|Wa\x10|a\x13\xB1V[`\x01`\xFF\x91\x90\x91\x16\x1B\x92\x91PPV[_`\x01`\x01`\xE0\x1B\x03\x19\x82\x16cye\xDB\x0B`\xE0\x1B\x14\x80a\x06\x95WPc\x01\xFF\xC9\xA7`\xE0\x1B`\x01`\x01`\xE0\x1B\x03\x19\x83\x16\x14a\x06\x95V[``\x82a\x10\xD4Wa\x10\xCF\x82a\x10\xDBV[a\x06\x95V[P\x80a\x06\x95V[\x80Q\x15a\x10\xEBW\x80Q\x80\x82` \x01\xFD[`@Qc\n\x12\xF5!`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x11\x1AW__\xFD[\x91\x90PV[__\x83`\x1F\x84\x01\x12a\x11/W__\xFD[P\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a\x11EW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x11\\W__\xFD[\x92P\x92\x90PV[_______`\xC0\x88\x8A\x03\x12\x15a\x11yW__\xFD[a\x11\x82\x88a\x11\x04V[\x96P` \x88\x015\x95P`@\x88\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x11\xA3W__\xFD[a\x11\xAF\x8A\x82\x8B\x01a\x11\x1FV[\x98\x9B\x97\x9AP\x98``\x81\x015\x97`\x80\x82\x015\x97P`\xA0\x90\x91\x015\x95P\x93PPPPV[_` \x82\x84\x03\x12\x15a\x11\xE1W__\xFD[\x815`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\x08>W__\xFD[______`\xA0\x87\x89\x03\x12\x15a\x12\rW__\xFD[a\x12\x16\x87a\x11\x04V[\x95P` \x87\x015\x94P`@\x87\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x127W__\xFD[a\x12C\x89\x82\x8A\x01a\x11\x1FV[\x97\x9A\x96\x99P\x97``\x81\x015\x96`\x80\x90\x91\x015\x95P\x93PPPPV[_` \x82\x84\x03\x12\x15a\x12nW__\xFD[P5\x91\x90PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x12\xB1Wa\x12\xB1a\x12uV[`@R\x91\x90PV[_\x82`\x1F\x83\x01\x12a\x12\xC8W__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a\x12\xE1Wa\x12\xE1a\x12uV[a\x12\xF4`\x1F\x82\x01`\x1F\x19\x16` \x01a\x12\x89V[\x81\x81R\x84` \x83\x86\x01\x01\x11\x15a\x13\x08W__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[____`\x80\x85\x87\x03\x12\x15a\x137W__\xFD[a\x13@\x85a\x11\x04V[\x93Pa\x13N` \x86\x01a\x11\x04V[\x92P`@\x85\x015\x91P``\x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x13oW__\xFD[a\x13{\x87\x82\x88\x01a\x12\xB9V[\x91PP\x92\x95\x91\x94P\x92PV[__`@\x83\x85\x03\x12\x15a\x13\x98W__\xFD[\x825\x91Pa\x13\xA8` \x84\x01a\x11\x04V[\x90P\x92P\x92\x90PV[cNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[` \x81\x01`\x04\x83\x10a\x13\xE5WcNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[\x91\x90R\x90V[__\x83`\x1F\x84\x01\x12a\x13\xFBW__\xFD[P\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a\x14\x11W__\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x11\\W__\xFD[_________`\xC0\x8A\x8C\x03\x12\x15a\x14CW__\xFD[\x895`\x01`\x01`@\x1B\x03\x81\x11\x15a\x14XW__\xFD[a\x14d\x8C\x82\x8D\x01a\x13\xEBV[\x90\x9AP\x98PP` \x8A\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x14\x82W__\xFD[a\x14\x8E\x8C\x82\x8D\x01a\x13\xEBV[\x90\x98P\x96PP`@\x8A\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x14\xACW__\xFD[a\x14\xB8\x8C\x82\x8D\x01a\x13\xEBV[\x9A\x9D\x99\x9CP\x97\x9A\x96\x99\x97\x98``\x88\x015\x97`\x80\x81\x015\x97P`\xA0\x015\x95P\x93PPPPV[________`\xA0\x89\x8B\x03\x12\x15a\x14\xF4W__\xFD[\x885`\x01`\x01`@\x1B\x03\x81\x11\x15a\x15\tW__\xFD[a\x15\x15\x8B\x82\x8C\x01a\x13\xEBV[\x90\x99P\x97PP` \x89\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x153W__\xFD[a\x15?\x8B\x82\x8C\x01a\x13\xEBV[\x90\x97P\x95PP`@\x89\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x15]W__\xFD[a\x15i\x8B\x82\x8C\x01a\x13\xEBV[\x99\x9C\x98\x9BP\x96\x99\x95\x98\x96\x97``\x87\x015\x96`\x80\x015\x95P\x93PPPPV[_\x82`\x1F\x83\x01\x12a\x15\x96W__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a\x15\xAFWa\x15\xAFa\x12uV[\x80`\x05\x1Ba\x15\xBF` \x82\x01a\x12\x89V[\x91\x82R` \x81\x85\x01\x81\x01\x92\x90\x81\x01\x90\x86\x84\x11\x15a\x15\xDAW__\xFD[` \x86\x01\x92P[\x83\x83\x10\x15a\x15\xFCW\x825\x82R` \x92\x83\x01\x92\x90\x91\x01\x90a\x15\xE1V[\x96\x95PPPPPPV[_____`\xA0\x86\x88\x03\x12\x15a\x16\x1AW__\xFD[a\x16#\x86a\x11\x04V[\x94Pa\x161` \x87\x01a\x11\x04V[\x93P`@\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x16KW__\xFD[a\x16W\x88\x82\x89\x01a\x15\x87V[\x93PP``\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x16rW__\xFD[a\x16~\x88\x82\x89\x01a\x15\x87V[\x92PP`\x80\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x16\x99W__\xFD[a\x16\xA5\x88\x82\x89\x01a\x12\xB9V[\x91PP\x92\x95P\x92\x95\x90\x93PV[_____`\xA0\x86\x88\x03\x12\x15a\x16\xC6W__\xFD[a\x16\xCF\x86a\x11\x04V[\x94Pa\x16\xDD` \x87\x01a\x11\x04V[\x93P`@\x86\x015\x92P``\x86\x015\x91P`\x80\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x16\x99W__\xFD[\x81\x83R\x81\x81` \x85\x017P_\x82\x82\x01` \x90\x81\x01\x91\x90\x91R`\x1F\x90\x91\x01`\x1F\x19\x16\x90\x91\x01\x01\x90V[`\x01\x80`\xA0\x1B\x03\x87\x16\x81R\x85` \x82\x01R`\xA0`@\x82\x01R_a\x17T`\xA0\x83\x01\x86\x88a\x17\x05V[``\x83\x01\x94\x90\x94RP`\x80\x01R\x94\x93PPPPV[`\x01\x80`\xA0\x1B\x03\x85\x16\x81R\x83` \x82\x01R```@\x82\x01R_a\x15\xFC``\x83\x01\x84\x86a\x17\x05V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x17\xB4W__\xFD[a\x08>\x82a\x11\x04V[__\x835`\x1E\x19\x846\x03\x01\x81\x12a\x17\xD2W__\xFD[\x83\x01\x805\x91P`\x01`\x01`@\x1B\x03\x82\x11\x15a\x17\xEBW__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x11\\W__\xFD[_\x83\x83\x85R` \x85\x01\x94P` \x84`\x05\x1B\x82\x01\x01\x83_[\x86\x81\x10\x15a\x18\x87W\x83\x83\x03`\x1F\x19\x01\x88R\x8156\x87\x90\x03`\x1E\x19\x01\x81\x12a\x18;W__\xFD[\x86\x01` \x81\x01\x905`\x01`\x01`@\x1B\x03\x81\x11\x15a\x18VW__\xFD[\x806\x03\x82\x13\x15a\x18dW__\xFD[a\x18o\x85\x82\x84a\x17\x05V[` \x9A\x8B\x01\x9A\x90\x95P\x93\x90\x93\x01\x92PP`\x01\x01a\x18\x16V[P\x90\x96\x95PPPPPPV[`\xA0\x80\x82R\x81\x01\x88\x90R_\x89`\xC0\x83\x01\x82[\x8B\x81\x10\x15a\x18\xD3W`\x01`\x01`\xA0\x1B\x03a\x18\xBE\x84a\x11\x04V[\x16\x82R` \x92\x83\x01\x92\x90\x91\x01\x90`\x01\x01a\x18\xA5V[P\x83\x81\x03` \x85\x01R\x88\x81R`\x01`\x01`\xFB\x1B\x03\x89\x11\x15a\x18\xF2W__\xFD[\x88`\x05\x1B\x91P\x81\x8A` \x83\x017\x01\x82\x81\x03` \x90\x81\x01`@\x85\x01Ra\x19\x1A\x90\x82\x01\x87\x89a\x17\xFFV[``\x84\x01\x95\x90\x95RPP`\x80\x01R\x96\x95PPPPPPV[\x80\x82\x01\x80\x82\x11\x15a\x06\x95WcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x83\x827_\x91\x01\x90\x81R\x91\x90PV\xFE\xA1dsolcC\0\x08\x1C\0\n",
1363 );
1364 #[rustfmt::skip]
1370 #[allow(clippy::all)]
1371 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
1372 b"`\x80`@R`\x046\x10a\x01\xB2W_5`\xE0\x1C\x80c\x80ee\x7F\x11a\0\xE7W\x80c\xBC\x19|\x81\x11a\0\x87W\x80c\xD5Gt\x1F\x11a\0bW\x80c\xD5Gt\x1F\x14a\x05FW\x80c\xE3\x835\xE5\x14a\x05eW\x80c\xF2:na\x14a\x05xW\x80c\xF2z\x0C\x92\x14a\x05\xA3W__\xFD[\x80c\xBC\x19|\x81\x14a\x04\xD1W\x80c\xC4\xD2R\xF5\x14a\x04\xFCW\x80c\xD4\\D5\x14a\x05\x1BW__\xFD[\x80c\x91\xD1HT\x11a\0\xC2W\x80c\x91\xD1HT\x14a\x04MW\x80c\xA2\x17\xFD\xDF\x14a\x04lW\x80c\xB0\x8EQ\xC0\x14a\x04\x7FW\x80c\xB1\xC5\xF4'\x14a\x04\xB2W__\xFD[\x80c\x80ee\x7F\x14a\x03\xDCW\x80c\x8F*\x0B\xB0\x14a\x03\xFBW\x80c\x8Fa\xF4\xF5\x14a\x04\x1AW__\xFD[\x80c*\xB0\xF5)\x11a\x01RW\x80c6V\x8A\xBE\x11a\x01-W\x80c6V\x8A\xBE\x14a\x03SW\x80cXK\x15>\x14a\x03rW\x80cd\xD6#S\x14a\x03\x91W\x80cyX\0L\x14a\x03\xB0W__\xFD[\x80c*\xB0\xF5)\x14a\x02\xF6W\x80c//\xF1]\x14a\x03\x15W\x80c1\xD5\x07P\x14a\x034W__\xFD[\x80c\x13@\x08\xD3\x11a\x01\x8DW\x80c\x13@\x08\xD3\x14a\x02SW\x80c\x13\xBC\x9F \x14a\x02fW\x80c\x15\x0Bz\x02\x14a\x02\x85W\x80c$\x8A\x9C\xA3\x14a\x02\xC8W__\xFD[\x80c\x01\xD5\x06*\x14a\x01\xBDW\x80c\x01\xFF\xC9\xA7\x14a\x01\xDEW\x80c\x07\xBD\x02e\x14a\x02\x12W__\xFD[6a\x01\xB9W\0[__\xFD[4\x80\x15a\x01\xC8W__\xFD[Pa\x01\xDCa\x01\xD76`\x04a\x11cV[a\x05\xB7V[\0[4\x80\x15a\x01\xE9W__\xFD[Pa\x01\xFDa\x01\xF86`\x04a\x11\xD1V[a\x06\x8BV[`@Q\x90\x15\x15\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02\x1DW__\xFD[Pa\x02E\x7F\xD8\xAA\x0F1\x94\x97\x1A*\x11fy\xF7\xC2\t\x0Fi9\xC8\xD4\xE0\x1A*\x8D~A\xD5^SQF\x9Ec\x81V[`@Q\x90\x81R` \x01a\x02\tV[a\x01\xDCa\x02a6`\x04a\x11\xF8V[a\x06\x9BV[4\x80\x15a\x02qW__\xFD[Pa\x01\xFDa\x02\x806`\x04a\x12^V[a\x07MV[4\x80\x15a\x02\x90W__\xFD[Pa\x02\xAFa\x02\x9F6`\x04a\x13$V[c\n\x85\xBD\x01`\xE1\x1B\x94\x93PPPPV[`@Q`\x01`\x01`\xE0\x1B\x03\x19\x90\x91\x16\x81R` \x01a\x02\tV[4\x80\x15a\x02\xD3W__\xFD[Pa\x02Ea\x02\xE26`\x04a\x12^V[_\x90\x81R` \x81\x90R`@\x90 `\x01\x01T\x90V[4\x80\x15a\x03\x01W__\xFD[Pa\x01\xFDa\x03\x106`\x04a\x12^V[a\x07rV[4\x80\x15a\x03 W__\xFD[Pa\x01\xDCa\x03/6`\x04a\x13\x87V[a\x07zV[4\x80\x15a\x03?W__\xFD[Pa\x01\xFDa\x03N6`\x04a\x12^V[a\x07\xA4V[4\x80\x15a\x03^W__\xFD[Pa\x01\xDCa\x03m6`\x04a\x13\x87V[a\x07\xC8V[4\x80\x15a\x03}W__\xFD[Pa\x01\xFDa\x03\x8C6`\x04a\x12^V[a\x08\0V[4\x80\x15a\x03\x9CW__\xFD[Pa\x01\xDCa\x03\xAB6`\x04a\x12^V[a\x08EV[4\x80\x15a\x03\xBBW__\xFD[Pa\x03\xCFa\x03\xCA6`\x04a\x12^V[a\x08\xB8V[`@Qa\x02\t\x91\x90a\x13\xC5V[4\x80\x15a\x03\xE7W__\xFD[Pa\x02Ea\x03\xF66`\x04a\x11\xF8V[a\t\0V[4\x80\x15a\x04\x06W__\xFD[Pa\x01\xDCa\x04\x156`\x04a\x14+V[a\t>V[4\x80\x15a\x04%W__\xFD[Pa\x02E\x7F\xB0\x9A\xA5\xAE\xB3p,\xFDP\xB6\xB6+\xC4S&\x04\x93\x8F!$\x8A'\xA1\xD5\xCAs`\x82\xB6\x81\x9C\xC1\x81V[4\x80\x15a\x04XW__\xFD[Pa\x01\xFDa\x04g6`\x04a\x13\x87V[a\n\xCAV[4\x80\x15a\x04wW__\xFD[Pa\x02E_\x81V[4\x80\x15a\x04\x8AW__\xFD[Pa\x02E\x7F\xFDd<rq\x0Cc\xC0\x18\x02Y\xAB\xA6\xB2\xD0TQ\xE3Y\x1A$\xE5\x8Bb#\x93x\x08W&\xF7\x83\x81V[4\x80\x15a\x04\xBDW__\xFD[Pa\x02Ea\x04\xCC6`\x04a\x14\xDDV[a\n\xF2V[4\x80\x15a\x04\xDCW__\xFD[Pa\x02\xAFa\x04\xEB6`\x04a\x16\x06V[c\xBC\x19|\x81`\xE0\x1B\x95\x94PPPPPV[4\x80\x15a\x05\x07W__\xFD[Pa\x01\xDCa\x05\x166`\x04a\x12^V[a\x0B6V[4\x80\x15a\x05&W__\xFD[Pa\x02Ea\x0556`\x04a\x12^V[_\x90\x81R`\x01` R`@\x90 T\x90V[4\x80\x15a\x05QW__\xFD[Pa\x01\xDCa\x05`6`\x04a\x13\x87V[a\x0B\xE0V[a\x01\xDCa\x05s6`\x04a\x14\xDDV[a\x0C\x04V[4\x80\x15a\x05\x83W__\xFD[Pa\x02\xAFa\x05\x926`\x04a\x16\xB2V[c\xF2:na`\xE0\x1B\x95\x94PPPPPV[4\x80\x15a\x05\xAEW__\xFD[P`\x02Ta\x02EV[\x7F\xB0\x9A\xA5\xAE\xB3p,\xFDP\xB6\xB6+\xC4S&\x04\x93\x8F!$\x8A'\xA1\xD5\xCAs`\x82\xB6\x81\x9C\xC1a\x05\xE1\x81a\r\x85V[_a\x05\xF0\x89\x89\x89\x89\x89\x89a\t\0V[\x90Pa\x05\xFC\x81\x84a\r\x92V[_\x81\x7FL\xF4A\x0C\xC5p@\xE4Hb\xEF\x0FE\xF3\xDDZ^\x02\xDB\x8E\xB8\xAD\xD6H\xD4\xB0\xE26\xF1\xD0}\xCA\x8B\x8B\x8B\x8B\x8B\x8A`@Qa\x067\x96\x95\x94\x93\x92\x91\x90a\x17-V[`@Q\x80\x91\x03\x90\xA3\x83\x15a\x06\x80W\x80\x7F \xFD\xA5\xFD'\xA1\xEA{\xF5\xB9V\x7F\x14:\xC5G\x0B\xB0Y7J'\xE8\xF6|\xB4O\x94om\x03\x87\x85`@Qa\x06w\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA2[PPPPPPPPPV[_a\x06\x95\x82a\x0E#V[\x92\x91PPV[\x7F\xD8\xAA\x0F1\x94\x97\x1A*\x11fy\xF7\xC2\t\x0Fi9\xC8\xD4\xE0\x1A*\x8D~A\xD5^SQF\x9Eca\x06\xC6\x81_a\n\xCAV[a\x06\xD4Wa\x06\xD4\x813a\x0EGV[_a\x06\xE3\x88\x88\x88\x88\x88\x88a\t\0V[\x90Pa\x06\xEF\x81\x85a\x0E\x84V[a\x06\xFB\x88\x88\x88\x88a\x0E\xD2V[_\x81\x7F\xC2a~\xFAi\xBA\xB6g\x82\xFA!\x95CqC8H\x9CN\x9E\x17\x82qV\n\x91\xB8,?a+X\x8A\x8A\x8A\x8A`@Qa\x072\x94\x93\x92\x91\x90a\x17iV[`@Q\x80\x91\x03\x90\xA3a\x07C\x81a\x0FFV[PPPPPPPPV[_`\x02[a\x07Z\x83a\x08\xB8V[`\x03\x81\x11\x15a\x07kWa\x07ka\x13\xB1V[\x14\x92\x91PPV[_`\x03a\x07QV[_\x82\x81R` \x81\x90R`@\x90 `\x01\x01Ta\x07\x94\x81a\r\x85V[a\x07\x9E\x83\x83a\x0FqV[PPPPV[_\x80a\x07\xAF\x83a\x08\xB8V[`\x03\x81\x11\x15a\x07\xC0Wa\x07\xC0a\x13\xB1V[\x14\x15\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x81\x163\x14a\x07\xF1W`@Qc3K\xD9\x19`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x07\xFB\x82\x82a\x10\0V[PPPV[__a\x08\x0B\x83a\x08\xB8V[\x90P`\x01\x81`\x03\x81\x11\x15a\x08!Wa\x08!a\x13\xB1V[\x14\x80a\x08>WP`\x02\x81`\x03\x81\x11\x15a\x08<Wa\x08<a\x13\xB1V[\x14[\x93\x92PPPV[30\x81\x14a\x08vW`@Qc\xE2\x85\x0CY`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01[`@Q\x80\x91\x03\x90\xFD[`\x02T`@\x80Q\x91\x82R` \x82\x01\x84\x90R\x7F\x11\xC2ON\xAD\x16P|i\xACF\x7F\xBD^N\xED_\xB5\xC6\x99bm,\xC6\xD6d!\xDF%8\x86\xD5\x91\x01`@Q\x80\x91\x03\x90\xA1P`\x02UV[_\x81\x81R`\x01` R`@\x81 T\x80_\x03a\x08\xD5WP_\x92\x91PPV[`\x01\x81\x03a\x08\xE6WP`\x03\x92\x91PPV[B\x81\x11\x15a\x08\xF7WP`\x01\x92\x91PPV[P`\x02\x92\x91PPV[_\x86\x86\x86\x86\x86\x86`@Q` \x01a\t\x1C\x96\x95\x94\x93\x92\x91\x90a\x17-V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x96\x95PPPPPPV[\x7F\xB0\x9A\xA5\xAE\xB3p,\xFDP\xB6\xB6+\xC4S&\x04\x93\x8F!$\x8A'\xA1\xD5\xCAs`\x82\xB6\x81\x9C\xC1a\th\x81a\r\x85V[\x88\x87\x14\x15\x80a\twWP\x88\x85\x14\x15[\x15a\t\xA9W`@Q`\x01bO\xCD\xEF`\xE0\x1B\x03\x19\x81R`\x04\x81\x01\x8A\x90R`$\x81\x01\x86\x90R`D\x81\x01\x88\x90R`d\x01a\x08mV[_a\t\xBA\x8B\x8B\x8B\x8B\x8B\x8B\x8B\x8Ba\n\xF2V[\x90Pa\t\xC6\x81\x84a\r\x92V[_[\x8A\x81\x10\x15a\n{W\x80\x82\x7FL\xF4A\x0C\xC5p@\xE4Hb\xEF\x0FE\xF3\xDDZ^\x02\xDB\x8E\xB8\xAD\xD6H\xD4\xB0\xE26\xF1\xD0}\xCA\x8E\x8E\x85\x81\x81\x10a\n\x05Wa\n\x05a\x17\x90V[\x90P` \x02\x01` \x81\x01\x90a\n\x1A\x91\x90a\x17\xA4V[\x8D\x8D\x86\x81\x81\x10a\n,Wa\n,a\x17\x90V[\x90P` \x02\x015\x8C\x8C\x87\x81\x81\x10a\nEWa\nEa\x17\x90V[\x90P` \x02\x81\x01\x90a\nW\x91\x90a\x17\xBDV[\x8C\x8B`@Qa\nk\x96\x95\x94\x93\x92\x91\x90a\x17-V[`@Q\x80\x91\x03\x90\xA3`\x01\x01a\t\xC8V[P\x83\x15a\n\xBDW\x80\x7F \xFD\xA5\xFD'\xA1\xEA{\xF5\xB9V\x7F\x14:\xC5G\x0B\xB0Y7J'\xE8\xF6|\xB4O\x94om\x03\x87\x85`@Qa\n\xB4\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA2[PPPPPPPPPPPV[_\x91\x82R` \x82\x81R`@\x80\x84 `\x01`\x01`\xA0\x1B\x03\x93\x90\x93\x16\x84R\x91\x90R\x90 T`\xFF\x16\x90V[_\x88\x88\x88\x88\x88\x88\x88\x88`@Q` \x01a\x0B\x12\x98\x97\x96\x95\x94\x93\x92\x91\x90a\x18\x93V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x98\x97PPPPPPPPV[\x7F\xFDd<rq\x0Cc\xC0\x18\x02Y\xAB\xA6\xB2\xD0TQ\xE3Y\x1A$\xE5\x8Bb#\x93x\x08W&\xF7\x83a\x0B`\x81a\r\x85V[a\x0Bi\x82a\x08\0V[a\x0B\xA5W\x81a\x0Bx`\x02a\x10iV[a\x0B\x82`\x01a\x10iV[`@Qc^\xAD\x8E\xB5`\xE0\x1B\x81R`\x04\x81\x01\x93\x90\x93R\x17`$\x82\x01R`D\x01a\x08mV[_\x82\x81R`\x01` R`@\x80\x82 \x82\x90UQ\x83\x91\x7F\xBA\xA1\xEB\"\xF2\xA4\x92\xBA\x1A_\xEAa\xB8\xDFM'\xC6\xC8\xB5\xF3\x97\x1Ec\xBBX\xFA\x14\xFFr\xEE\xDBp\x91\xA2PPV[_\x82\x81R` \x81\x90R`@\x90 `\x01\x01Ta\x0B\xFA\x81a\r\x85V[a\x07\x9E\x83\x83a\x10\0V[\x7F\xD8\xAA\x0F1\x94\x97\x1A*\x11fy\xF7\xC2\t\x0Fi9\xC8\xD4\xE0\x1A*\x8D~A\xD5^SQF\x9Eca\x0C/\x81_a\n\xCAV[a\x0C=Wa\x0C=\x813a\x0EGV[\x87\x86\x14\x15\x80a\x0CLWP\x87\x84\x14\x15[\x15a\x0C~W`@Q`\x01bO\xCD\xEF`\xE0\x1B\x03\x19\x81R`\x04\x81\x01\x89\x90R`$\x81\x01\x85\x90R`D\x81\x01\x87\x90R`d\x01a\x08mV[_a\x0C\x8F\x8A\x8A\x8A\x8A\x8A\x8A\x8A\x8Aa\n\xF2V[\x90Pa\x0C\x9B\x81\x85a\x0E\x84V[_[\x89\x81\x10\x15a\roW_\x8B\x8B\x83\x81\x81\x10a\x0C\xB8Wa\x0C\xB8a\x17\x90V[\x90P` \x02\x01` \x81\x01\x90a\x0C\xCD\x91\x90a\x17\xA4V[\x90P_\x8A\x8A\x84\x81\x81\x10a\x0C\xE2Wa\x0C\xE2a\x17\x90V[\x90P` \x02\x015\x90P6_\x8A\x8A\x86\x81\x81\x10a\x0C\xFFWa\x0C\xFFa\x17\x90V[\x90P` \x02\x81\x01\x90a\r\x11\x91\x90a\x17\xBDV[\x91P\x91Pa\r!\x84\x84\x84\x84a\x0E\xD2V[\x84\x86\x7F\xC2a~\xFAi\xBA\xB6g\x82\xFA!\x95CqC8H\x9CN\x9E\x17\x82qV\n\x91\xB8,?a+X\x86\x86\x86\x86`@Qa\rX\x94\x93\x92\x91\x90a\x17iV[`@Q\x80\x91\x03\x90\xA3PPPP\x80`\x01\x01\x90Pa\x0C\x9DV[Pa\ry\x81a\x0FFV[PPPPPPPPPPV[a\r\x8F\x813a\x0EGV[PV[a\r\x9B\x82a\x07\xA4V[\x15a\r\xCCW\x81a\r\xAA_a\x10iV[`@Qc^\xAD\x8E\xB5`\xE0\x1B\x81R`\x04\x81\x01\x92\x90\x92R`$\x82\x01R`D\x01a\x08mV[_a\r\xD6`\x02T\x90V[\x90P\x80\x82\x10\x15a\x0E\x03W`@QcT3f\t`\xE0\x1B\x81R`\x04\x81\x01\x83\x90R`$\x81\x01\x82\x90R`D\x01a\x08mV[a\x0E\r\x82Ba\x192V[_\x93\x84R`\x01` R`@\x90\x93 \x92\x90\x92UPPV[_`\x01`\x01`\xE0\x1B\x03\x19\x82\x16c\x02q\x18\x97`\xE5\x1B\x14\x80a\x06\x95WPa\x06\x95\x82a\x10\x8BV[a\x0EQ\x82\x82a\n\xCAV[a\x0E\x80W`@Qc\xE2Q}?`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x81\x01\x83\x90R`D\x01a\x08mV[PPV[a\x0E\x8D\x82a\x07MV[a\x0E\x9CW\x81a\r\xAA`\x02a\x10iV[\x80\x15\x80\x15\x90a\x0E\xB1WPa\x0E\xAF\x81a\x07rV[\x15[\x15a\x0E\x80W`@Qc\x12\x154\xC3`\xE3\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x08mV[__\x85`\x01`\x01`\xA0\x1B\x03\x16\x85\x85\x85`@Qa\x0E\xEF\x92\x91\x90a\x19QV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0F)W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0F.V[``\x91P[P\x91P\x91Pa\x0F=\x82\x82a\x10\xBFV[PPPPPPPV[a\x0FO\x81a\x07MV[a\x0F^W\x80a\r\xAA`\x02a\x10iV[_\x90\x81R`\x01` \x81\x90R`@\x90\x91 UV[_a\x0F|\x83\x83a\n\xCAV[a\x0F\xF9W_\x83\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x86\x16\x84R\x90\x91R\x90 \x80T`\xFF\x19\x16`\x01\x17\x90Ua\x0F\xB13\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x84\x7F/\x87\x88\x11~~\xFF\x1D\x82\xE9&\xECyI\x01\xD1|x\x02JP'\t@0E@\xA73eo\r`@Q`@Q\x80\x91\x03\x90\xA4P`\x01a\x06\x95V[P_a\x06\x95V[_a\x10\x0B\x83\x83a\n\xCAV[\x15a\x0F\xF9W_\x83\x81R` \x81\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x86\x16\x80\x85R\x92R\x80\x83 \x80T`\xFF\x19\x16\x90UQ3\x92\x86\x91\x7F\xF69\x1F\\2\xD9\xC6\x9D*G\xEAg\x0BD)t\xB595\xD1\xED\xC7\xFDd\xEB!\xE0G\xA89\x17\x1B\x91\x90\xA4P`\x01a\x06\x95V[_\x81`\x03\x81\x11\x15a\x10|Wa\x10|a\x13\xB1V[`\x01`\xFF\x91\x90\x91\x16\x1B\x92\x91PPV[_`\x01`\x01`\xE0\x1B\x03\x19\x82\x16cye\xDB\x0B`\xE0\x1B\x14\x80a\x06\x95WPc\x01\xFF\xC9\xA7`\xE0\x1B`\x01`\x01`\xE0\x1B\x03\x19\x83\x16\x14a\x06\x95V[``\x82a\x10\xD4Wa\x10\xCF\x82a\x10\xDBV[a\x06\x95V[P\x80a\x06\x95V[\x80Q\x15a\x10\xEBW\x80Q\x80\x82` \x01\xFD[`@Qc\n\x12\xF5!`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x11\x1AW__\xFD[\x91\x90PV[__\x83`\x1F\x84\x01\x12a\x11/W__\xFD[P\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a\x11EW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x11\\W__\xFD[\x92P\x92\x90PV[_______`\xC0\x88\x8A\x03\x12\x15a\x11yW__\xFD[a\x11\x82\x88a\x11\x04V[\x96P` \x88\x015\x95P`@\x88\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x11\xA3W__\xFD[a\x11\xAF\x8A\x82\x8B\x01a\x11\x1FV[\x98\x9B\x97\x9AP\x98``\x81\x015\x97`\x80\x82\x015\x97P`\xA0\x90\x91\x015\x95P\x93PPPPV[_` \x82\x84\x03\x12\x15a\x11\xE1W__\xFD[\x815`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\x08>W__\xFD[______`\xA0\x87\x89\x03\x12\x15a\x12\rW__\xFD[a\x12\x16\x87a\x11\x04V[\x95P` \x87\x015\x94P`@\x87\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x127W__\xFD[a\x12C\x89\x82\x8A\x01a\x11\x1FV[\x97\x9A\x96\x99P\x97``\x81\x015\x96`\x80\x90\x91\x015\x95P\x93PPPPV[_` \x82\x84\x03\x12\x15a\x12nW__\xFD[P5\x91\x90PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x12\xB1Wa\x12\xB1a\x12uV[`@R\x91\x90PV[_\x82`\x1F\x83\x01\x12a\x12\xC8W__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a\x12\xE1Wa\x12\xE1a\x12uV[a\x12\xF4`\x1F\x82\x01`\x1F\x19\x16` \x01a\x12\x89V[\x81\x81R\x84` \x83\x86\x01\x01\x11\x15a\x13\x08W__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[____`\x80\x85\x87\x03\x12\x15a\x137W__\xFD[a\x13@\x85a\x11\x04V[\x93Pa\x13N` \x86\x01a\x11\x04V[\x92P`@\x85\x015\x91P``\x85\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x13oW__\xFD[a\x13{\x87\x82\x88\x01a\x12\xB9V[\x91PP\x92\x95\x91\x94P\x92PV[__`@\x83\x85\x03\x12\x15a\x13\x98W__\xFD[\x825\x91Pa\x13\xA8` \x84\x01a\x11\x04V[\x90P\x92P\x92\x90PV[cNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[` \x81\x01`\x04\x83\x10a\x13\xE5WcNH{q`\xE0\x1B_R`!`\x04R`$_\xFD[\x91\x90R\x90V[__\x83`\x1F\x84\x01\x12a\x13\xFBW__\xFD[P\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a\x14\x11W__\xFD[` \x83\x01\x91P\x83` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x11\\W__\xFD[_________`\xC0\x8A\x8C\x03\x12\x15a\x14CW__\xFD[\x895`\x01`\x01`@\x1B\x03\x81\x11\x15a\x14XW__\xFD[a\x14d\x8C\x82\x8D\x01a\x13\xEBV[\x90\x9AP\x98PP` \x8A\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x14\x82W__\xFD[a\x14\x8E\x8C\x82\x8D\x01a\x13\xEBV[\x90\x98P\x96PP`@\x8A\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x14\xACW__\xFD[a\x14\xB8\x8C\x82\x8D\x01a\x13\xEBV[\x9A\x9D\x99\x9CP\x97\x9A\x96\x99\x97\x98``\x88\x015\x97`\x80\x81\x015\x97P`\xA0\x015\x95P\x93PPPPV[________`\xA0\x89\x8B\x03\x12\x15a\x14\xF4W__\xFD[\x885`\x01`\x01`@\x1B\x03\x81\x11\x15a\x15\tW__\xFD[a\x15\x15\x8B\x82\x8C\x01a\x13\xEBV[\x90\x99P\x97PP` \x89\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x153W__\xFD[a\x15?\x8B\x82\x8C\x01a\x13\xEBV[\x90\x97P\x95PP`@\x89\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x15]W__\xFD[a\x15i\x8B\x82\x8C\x01a\x13\xEBV[\x99\x9C\x98\x9BP\x96\x99\x95\x98\x96\x97``\x87\x015\x96`\x80\x015\x95P\x93PPPPV[_\x82`\x1F\x83\x01\x12a\x15\x96W__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a\x15\xAFWa\x15\xAFa\x12uV[\x80`\x05\x1Ba\x15\xBF` \x82\x01a\x12\x89V[\x91\x82R` \x81\x85\x01\x81\x01\x92\x90\x81\x01\x90\x86\x84\x11\x15a\x15\xDAW__\xFD[` \x86\x01\x92P[\x83\x83\x10\x15a\x15\xFCW\x825\x82R` \x92\x83\x01\x92\x90\x91\x01\x90a\x15\xE1V[\x96\x95PPPPPPV[_____`\xA0\x86\x88\x03\x12\x15a\x16\x1AW__\xFD[a\x16#\x86a\x11\x04V[\x94Pa\x161` \x87\x01a\x11\x04V[\x93P`@\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x16KW__\xFD[a\x16W\x88\x82\x89\x01a\x15\x87V[\x93PP``\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x16rW__\xFD[a\x16~\x88\x82\x89\x01a\x15\x87V[\x92PP`\x80\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x16\x99W__\xFD[a\x16\xA5\x88\x82\x89\x01a\x12\xB9V[\x91PP\x92\x95P\x92\x95\x90\x93PV[_____`\xA0\x86\x88\x03\x12\x15a\x16\xC6W__\xFD[a\x16\xCF\x86a\x11\x04V[\x94Pa\x16\xDD` \x87\x01a\x11\x04V[\x93P`@\x86\x015\x92P``\x86\x015\x91P`\x80\x86\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x16\x99W__\xFD[\x81\x83R\x81\x81` \x85\x017P_\x82\x82\x01` \x90\x81\x01\x91\x90\x91R`\x1F\x90\x91\x01`\x1F\x19\x16\x90\x91\x01\x01\x90V[`\x01\x80`\xA0\x1B\x03\x87\x16\x81R\x85` \x82\x01R`\xA0`@\x82\x01R_a\x17T`\xA0\x83\x01\x86\x88a\x17\x05V[``\x83\x01\x94\x90\x94RP`\x80\x01R\x94\x93PPPPV[`\x01\x80`\xA0\x1B\x03\x85\x16\x81R\x83` \x82\x01R```@\x82\x01R_a\x15\xFC``\x83\x01\x84\x86a\x17\x05V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x17\xB4W__\xFD[a\x08>\x82a\x11\x04V[__\x835`\x1E\x19\x846\x03\x01\x81\x12a\x17\xD2W__\xFD[\x83\x01\x805\x91P`\x01`\x01`@\x1B\x03\x82\x11\x15a\x17\xEBW__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x11\\W__\xFD[_\x83\x83\x85R` \x85\x01\x94P` \x84`\x05\x1B\x82\x01\x01\x83_[\x86\x81\x10\x15a\x18\x87W\x83\x83\x03`\x1F\x19\x01\x88R\x8156\x87\x90\x03`\x1E\x19\x01\x81\x12a\x18;W__\xFD[\x86\x01` \x81\x01\x905`\x01`\x01`@\x1B\x03\x81\x11\x15a\x18VW__\xFD[\x806\x03\x82\x13\x15a\x18dW__\xFD[a\x18o\x85\x82\x84a\x17\x05V[` \x9A\x8B\x01\x9A\x90\x95P\x93\x90\x93\x01\x92PP`\x01\x01a\x18\x16V[P\x90\x96\x95PPPPPPV[`\xA0\x80\x82R\x81\x01\x88\x90R_\x89`\xC0\x83\x01\x82[\x8B\x81\x10\x15a\x18\xD3W`\x01`\x01`\xA0\x1B\x03a\x18\xBE\x84a\x11\x04V[\x16\x82R` \x92\x83\x01\x92\x90\x91\x01\x90`\x01\x01a\x18\xA5V[P\x83\x81\x03` \x85\x01R\x88\x81R`\x01`\x01`\xFB\x1B\x03\x89\x11\x15a\x18\xF2W__\xFD[\x88`\x05\x1B\x91P\x81\x8A` \x83\x017\x01\x82\x81\x03` \x90\x81\x01`@\x85\x01Ra\x19\x1A\x90\x82\x01\x87\x89a\x17\xFFV[``\x84\x01\x95\x90\x95RPP`\x80\x01R\x96\x95PPPPPPV[\x80\x82\x01\x80\x82\x11\x15a\x06\x95WcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x83\x827_\x91\x01\x90\x81R\x91\x90PV\xFE\xA1dsolcC\0\x08\x1C\0\n",
1373 );
1374 #[derive(serde::Serialize, serde::Deserialize)]
1375 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1376 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1381 #[derive(Clone)]
1382 pub struct AccessControlBadConfirmation;
1383 #[allow(
1384 non_camel_case_types,
1385 non_snake_case,
1386 clippy::pub_underscore_fields,
1387 clippy::style
1388 )]
1389 const _: () = {
1390 use alloy::sol_types as alloy_sol_types;
1391 #[doc(hidden)]
1392 #[allow(dead_code)]
1393 type UnderlyingSolTuple<'a> = ();
1394 #[doc(hidden)]
1395 type UnderlyingRustTuple<'a> = ();
1396 #[cfg(test)]
1397 #[allow(dead_code, unreachable_patterns)]
1398 fn _type_assertion(
1399 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1400 ) {
1401 match _t {
1402 alloy_sol_types::private::AssertTypeEq::<
1403 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1404 >(_) => {}
1405 }
1406 }
1407 #[automatically_derived]
1408 #[doc(hidden)]
1409 impl ::core::convert::From<AccessControlBadConfirmation>
1410 for UnderlyingRustTuple<'_> {
1411 fn from(value: AccessControlBadConfirmation) -> Self {
1412 ()
1413 }
1414 }
1415 #[automatically_derived]
1416 #[doc(hidden)]
1417 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1418 for AccessControlBadConfirmation {
1419 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1420 Self
1421 }
1422 }
1423 #[automatically_derived]
1424 impl alloy_sol_types::SolError for AccessControlBadConfirmation {
1425 type Parameters<'a> = UnderlyingSolTuple<'a>;
1426 type Token<'a> = <Self::Parameters<
1427 'a,
1428 > as alloy_sol_types::SolType>::Token<'a>;
1429 const SIGNATURE: &'static str = "AccessControlBadConfirmation()";
1430 const SELECTOR: [u8; 4] = [102u8, 151u8, 178u8, 50u8];
1431 #[inline]
1432 fn new<'a>(
1433 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1434 ) -> Self {
1435 tuple.into()
1436 }
1437 #[inline]
1438 fn tokenize(&self) -> Self::Token<'_> {
1439 ()
1440 }
1441 #[inline]
1442 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1443 <Self::Parameters<
1444 '_,
1445 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1446 .map(Self::new)
1447 }
1448 }
1449 };
1450 #[derive(serde::Serialize, serde::Deserialize)]
1451 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1452 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1457 #[derive(Clone)]
1458 pub struct AccessControlUnauthorizedAccount {
1459 #[allow(missing_docs)]
1460 pub account: alloy::sol_types::private::Address,
1461 #[allow(missing_docs)]
1462 pub neededRole: alloy::sol_types::private::FixedBytes<32>,
1463 }
1464 #[allow(
1465 non_camel_case_types,
1466 non_snake_case,
1467 clippy::pub_underscore_fields,
1468 clippy::style
1469 )]
1470 const _: () = {
1471 use alloy::sol_types as alloy_sol_types;
1472 #[doc(hidden)]
1473 #[allow(dead_code)]
1474 type UnderlyingSolTuple<'a> = (
1475 alloy::sol_types::sol_data::Address,
1476 alloy::sol_types::sol_data::FixedBytes<32>,
1477 );
1478 #[doc(hidden)]
1479 type UnderlyingRustTuple<'a> = (
1480 alloy::sol_types::private::Address,
1481 alloy::sol_types::private::FixedBytes<32>,
1482 );
1483 #[cfg(test)]
1484 #[allow(dead_code, unreachable_patterns)]
1485 fn _type_assertion(
1486 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1487 ) {
1488 match _t {
1489 alloy_sol_types::private::AssertTypeEq::<
1490 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1491 >(_) => {}
1492 }
1493 }
1494 #[automatically_derived]
1495 #[doc(hidden)]
1496 impl ::core::convert::From<AccessControlUnauthorizedAccount>
1497 for UnderlyingRustTuple<'_> {
1498 fn from(value: AccessControlUnauthorizedAccount) -> Self {
1499 (value.account, value.neededRole)
1500 }
1501 }
1502 #[automatically_derived]
1503 #[doc(hidden)]
1504 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1505 for AccessControlUnauthorizedAccount {
1506 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1507 Self {
1508 account: tuple.0,
1509 neededRole: tuple.1,
1510 }
1511 }
1512 }
1513 #[automatically_derived]
1514 impl alloy_sol_types::SolError for AccessControlUnauthorizedAccount {
1515 type Parameters<'a> = UnderlyingSolTuple<'a>;
1516 type Token<'a> = <Self::Parameters<
1517 'a,
1518 > as alloy_sol_types::SolType>::Token<'a>;
1519 const SIGNATURE: &'static str = "AccessControlUnauthorizedAccount(address,bytes32)";
1520 const SELECTOR: [u8; 4] = [226u8, 81u8, 125u8, 63u8];
1521 #[inline]
1522 fn new<'a>(
1523 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1524 ) -> Self {
1525 tuple.into()
1526 }
1527 #[inline]
1528 fn tokenize(&self) -> Self::Token<'_> {
1529 (
1530 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1531 &self.account,
1532 ),
1533 <alloy::sol_types::sol_data::FixedBytes<
1534 32,
1535 > as alloy_sol_types::SolType>::tokenize(&self.neededRole),
1536 )
1537 }
1538 #[inline]
1539 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1540 <Self::Parameters<
1541 '_,
1542 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1543 .map(Self::new)
1544 }
1545 }
1546 };
1547 #[derive(serde::Serialize, serde::Deserialize)]
1548 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1549 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1554 #[derive(Clone)]
1555 pub struct FailedInnerCall;
1556 #[allow(
1557 non_camel_case_types,
1558 non_snake_case,
1559 clippy::pub_underscore_fields,
1560 clippy::style
1561 )]
1562 const _: () = {
1563 use alloy::sol_types as alloy_sol_types;
1564 #[doc(hidden)]
1565 #[allow(dead_code)]
1566 type UnderlyingSolTuple<'a> = ();
1567 #[doc(hidden)]
1568 type UnderlyingRustTuple<'a> = ();
1569 #[cfg(test)]
1570 #[allow(dead_code, unreachable_patterns)]
1571 fn _type_assertion(
1572 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1573 ) {
1574 match _t {
1575 alloy_sol_types::private::AssertTypeEq::<
1576 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1577 >(_) => {}
1578 }
1579 }
1580 #[automatically_derived]
1581 #[doc(hidden)]
1582 impl ::core::convert::From<FailedInnerCall> for UnderlyingRustTuple<'_> {
1583 fn from(value: FailedInnerCall) -> Self {
1584 ()
1585 }
1586 }
1587 #[automatically_derived]
1588 #[doc(hidden)]
1589 impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedInnerCall {
1590 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1591 Self
1592 }
1593 }
1594 #[automatically_derived]
1595 impl alloy_sol_types::SolError for FailedInnerCall {
1596 type Parameters<'a> = UnderlyingSolTuple<'a>;
1597 type Token<'a> = <Self::Parameters<
1598 'a,
1599 > as alloy_sol_types::SolType>::Token<'a>;
1600 const SIGNATURE: &'static str = "FailedInnerCall()";
1601 const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8];
1602 #[inline]
1603 fn new<'a>(
1604 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1605 ) -> Self {
1606 tuple.into()
1607 }
1608 #[inline]
1609 fn tokenize(&self) -> Self::Token<'_> {
1610 ()
1611 }
1612 #[inline]
1613 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1614 <Self::Parameters<
1615 '_,
1616 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1617 .map(Self::new)
1618 }
1619 }
1620 };
1621 #[derive(serde::Serialize, serde::Deserialize)]
1622 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1623 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1628 #[derive(Clone)]
1629 pub struct TimelockInsufficientDelay {
1630 #[allow(missing_docs)]
1631 pub delay: alloy::sol_types::private::primitives::aliases::U256,
1632 #[allow(missing_docs)]
1633 pub minDelay: alloy::sol_types::private::primitives::aliases::U256,
1634 }
1635 #[allow(
1636 non_camel_case_types,
1637 non_snake_case,
1638 clippy::pub_underscore_fields,
1639 clippy::style
1640 )]
1641 const _: () = {
1642 use alloy::sol_types as alloy_sol_types;
1643 #[doc(hidden)]
1644 #[allow(dead_code)]
1645 type UnderlyingSolTuple<'a> = (
1646 alloy::sol_types::sol_data::Uint<256>,
1647 alloy::sol_types::sol_data::Uint<256>,
1648 );
1649 #[doc(hidden)]
1650 type UnderlyingRustTuple<'a> = (
1651 alloy::sol_types::private::primitives::aliases::U256,
1652 alloy::sol_types::private::primitives::aliases::U256,
1653 );
1654 #[cfg(test)]
1655 #[allow(dead_code, unreachable_patterns)]
1656 fn _type_assertion(
1657 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1658 ) {
1659 match _t {
1660 alloy_sol_types::private::AssertTypeEq::<
1661 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1662 >(_) => {}
1663 }
1664 }
1665 #[automatically_derived]
1666 #[doc(hidden)]
1667 impl ::core::convert::From<TimelockInsufficientDelay>
1668 for UnderlyingRustTuple<'_> {
1669 fn from(value: TimelockInsufficientDelay) -> Self {
1670 (value.delay, value.minDelay)
1671 }
1672 }
1673 #[automatically_derived]
1674 #[doc(hidden)]
1675 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1676 for TimelockInsufficientDelay {
1677 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1678 Self {
1679 delay: tuple.0,
1680 minDelay: tuple.1,
1681 }
1682 }
1683 }
1684 #[automatically_derived]
1685 impl alloy_sol_types::SolError for TimelockInsufficientDelay {
1686 type Parameters<'a> = UnderlyingSolTuple<'a>;
1687 type Token<'a> = <Self::Parameters<
1688 'a,
1689 > as alloy_sol_types::SolType>::Token<'a>;
1690 const SIGNATURE: &'static str = "TimelockInsufficientDelay(uint256,uint256)";
1691 const SELECTOR: [u8; 4] = [84u8, 51u8, 102u8, 9u8];
1692 #[inline]
1693 fn new<'a>(
1694 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1695 ) -> Self {
1696 tuple.into()
1697 }
1698 #[inline]
1699 fn tokenize(&self) -> Self::Token<'_> {
1700 (
1701 <alloy::sol_types::sol_data::Uint<
1702 256,
1703 > as alloy_sol_types::SolType>::tokenize(&self.delay),
1704 <alloy::sol_types::sol_data::Uint<
1705 256,
1706 > as alloy_sol_types::SolType>::tokenize(&self.minDelay),
1707 )
1708 }
1709 #[inline]
1710 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1711 <Self::Parameters<
1712 '_,
1713 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1714 .map(Self::new)
1715 }
1716 }
1717 };
1718 #[derive(serde::Serialize, serde::Deserialize)]
1719 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1720 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1725 #[derive(Clone)]
1726 pub struct TimelockInvalidOperationLength {
1727 #[allow(missing_docs)]
1728 pub targets: alloy::sol_types::private::primitives::aliases::U256,
1729 #[allow(missing_docs)]
1730 pub payloads: alloy::sol_types::private::primitives::aliases::U256,
1731 #[allow(missing_docs)]
1732 pub values: alloy::sol_types::private::primitives::aliases::U256,
1733 }
1734 #[allow(
1735 non_camel_case_types,
1736 non_snake_case,
1737 clippy::pub_underscore_fields,
1738 clippy::style
1739 )]
1740 const _: () = {
1741 use alloy::sol_types as alloy_sol_types;
1742 #[doc(hidden)]
1743 #[allow(dead_code)]
1744 type UnderlyingSolTuple<'a> = (
1745 alloy::sol_types::sol_data::Uint<256>,
1746 alloy::sol_types::sol_data::Uint<256>,
1747 alloy::sol_types::sol_data::Uint<256>,
1748 );
1749 #[doc(hidden)]
1750 type UnderlyingRustTuple<'a> = (
1751 alloy::sol_types::private::primitives::aliases::U256,
1752 alloy::sol_types::private::primitives::aliases::U256,
1753 alloy::sol_types::private::primitives::aliases::U256,
1754 );
1755 #[cfg(test)]
1756 #[allow(dead_code, unreachable_patterns)]
1757 fn _type_assertion(
1758 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1759 ) {
1760 match _t {
1761 alloy_sol_types::private::AssertTypeEq::<
1762 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1763 >(_) => {}
1764 }
1765 }
1766 #[automatically_derived]
1767 #[doc(hidden)]
1768 impl ::core::convert::From<TimelockInvalidOperationLength>
1769 for UnderlyingRustTuple<'_> {
1770 fn from(value: TimelockInvalidOperationLength) -> Self {
1771 (value.targets, value.payloads, value.values)
1772 }
1773 }
1774 #[automatically_derived]
1775 #[doc(hidden)]
1776 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1777 for TimelockInvalidOperationLength {
1778 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1779 Self {
1780 targets: tuple.0,
1781 payloads: tuple.1,
1782 values: tuple.2,
1783 }
1784 }
1785 }
1786 #[automatically_derived]
1787 impl alloy_sol_types::SolError for TimelockInvalidOperationLength {
1788 type Parameters<'a> = UnderlyingSolTuple<'a>;
1789 type Token<'a> = <Self::Parameters<
1790 'a,
1791 > as alloy_sol_types::SolType>::Token<'a>;
1792 const SIGNATURE: &'static str = "TimelockInvalidOperationLength(uint256,uint256,uint256)";
1793 const SELECTOR: [u8; 4] = [255u8, 176u8, 50u8, 17u8];
1794 #[inline]
1795 fn new<'a>(
1796 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1797 ) -> Self {
1798 tuple.into()
1799 }
1800 #[inline]
1801 fn tokenize(&self) -> Self::Token<'_> {
1802 (
1803 <alloy::sol_types::sol_data::Uint<
1804 256,
1805 > as alloy_sol_types::SolType>::tokenize(&self.targets),
1806 <alloy::sol_types::sol_data::Uint<
1807 256,
1808 > as alloy_sol_types::SolType>::tokenize(&self.payloads),
1809 <alloy::sol_types::sol_data::Uint<
1810 256,
1811 > as alloy_sol_types::SolType>::tokenize(&self.values),
1812 )
1813 }
1814 #[inline]
1815 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1816 <Self::Parameters<
1817 '_,
1818 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1819 .map(Self::new)
1820 }
1821 }
1822 };
1823 #[derive(serde::Serialize, serde::Deserialize)]
1824 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1825 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1830 #[derive(Clone)]
1831 pub struct TimelockUnauthorizedCaller {
1832 #[allow(missing_docs)]
1833 pub caller: alloy::sol_types::private::Address,
1834 }
1835 #[allow(
1836 non_camel_case_types,
1837 non_snake_case,
1838 clippy::pub_underscore_fields,
1839 clippy::style
1840 )]
1841 const _: () = {
1842 use alloy::sol_types as alloy_sol_types;
1843 #[doc(hidden)]
1844 #[allow(dead_code)]
1845 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1846 #[doc(hidden)]
1847 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1848 #[cfg(test)]
1849 #[allow(dead_code, unreachable_patterns)]
1850 fn _type_assertion(
1851 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1852 ) {
1853 match _t {
1854 alloy_sol_types::private::AssertTypeEq::<
1855 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1856 >(_) => {}
1857 }
1858 }
1859 #[automatically_derived]
1860 #[doc(hidden)]
1861 impl ::core::convert::From<TimelockUnauthorizedCaller>
1862 for UnderlyingRustTuple<'_> {
1863 fn from(value: TimelockUnauthorizedCaller) -> Self {
1864 (value.caller,)
1865 }
1866 }
1867 #[automatically_derived]
1868 #[doc(hidden)]
1869 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1870 for TimelockUnauthorizedCaller {
1871 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1872 Self { caller: tuple.0 }
1873 }
1874 }
1875 #[automatically_derived]
1876 impl alloy_sol_types::SolError for TimelockUnauthorizedCaller {
1877 type Parameters<'a> = UnderlyingSolTuple<'a>;
1878 type Token<'a> = <Self::Parameters<
1879 'a,
1880 > as alloy_sol_types::SolType>::Token<'a>;
1881 const SIGNATURE: &'static str = "TimelockUnauthorizedCaller(address)";
1882 const SELECTOR: [u8; 4] = [226u8, 133u8, 12u8, 89u8];
1883 #[inline]
1884 fn new<'a>(
1885 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1886 ) -> Self {
1887 tuple.into()
1888 }
1889 #[inline]
1890 fn tokenize(&self) -> Self::Token<'_> {
1891 (
1892 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1893 &self.caller,
1894 ),
1895 )
1896 }
1897 #[inline]
1898 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1899 <Self::Parameters<
1900 '_,
1901 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1902 .map(Self::new)
1903 }
1904 }
1905 };
1906 #[derive(serde::Serialize, serde::Deserialize)]
1907 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1908 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1913 #[derive(Clone)]
1914 pub struct TimelockUnexecutedPredecessor {
1915 #[allow(missing_docs)]
1916 pub predecessorId: alloy::sol_types::private::FixedBytes<32>,
1917 }
1918 #[allow(
1919 non_camel_case_types,
1920 non_snake_case,
1921 clippy::pub_underscore_fields,
1922 clippy::style
1923 )]
1924 const _: () = {
1925 use alloy::sol_types as alloy_sol_types;
1926 #[doc(hidden)]
1927 #[allow(dead_code)]
1928 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1929 #[doc(hidden)]
1930 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1931 #[cfg(test)]
1932 #[allow(dead_code, unreachable_patterns)]
1933 fn _type_assertion(
1934 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1935 ) {
1936 match _t {
1937 alloy_sol_types::private::AssertTypeEq::<
1938 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1939 >(_) => {}
1940 }
1941 }
1942 #[automatically_derived]
1943 #[doc(hidden)]
1944 impl ::core::convert::From<TimelockUnexecutedPredecessor>
1945 for UnderlyingRustTuple<'_> {
1946 fn from(value: TimelockUnexecutedPredecessor) -> Self {
1947 (value.predecessorId,)
1948 }
1949 }
1950 #[automatically_derived]
1951 #[doc(hidden)]
1952 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1953 for TimelockUnexecutedPredecessor {
1954 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1955 Self { predecessorId: tuple.0 }
1956 }
1957 }
1958 #[automatically_derived]
1959 impl alloy_sol_types::SolError for TimelockUnexecutedPredecessor {
1960 type Parameters<'a> = UnderlyingSolTuple<'a>;
1961 type Token<'a> = <Self::Parameters<
1962 'a,
1963 > as alloy_sol_types::SolType>::Token<'a>;
1964 const SIGNATURE: &'static str = "TimelockUnexecutedPredecessor(bytes32)";
1965 const SELECTOR: [u8; 4] = [144u8, 169u8, 166u8, 24u8];
1966 #[inline]
1967 fn new<'a>(
1968 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1969 ) -> Self {
1970 tuple.into()
1971 }
1972 #[inline]
1973 fn tokenize(&self) -> Self::Token<'_> {
1974 (
1975 <alloy::sol_types::sol_data::FixedBytes<
1976 32,
1977 > as alloy_sol_types::SolType>::tokenize(&self.predecessorId),
1978 )
1979 }
1980 #[inline]
1981 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1982 <Self::Parameters<
1983 '_,
1984 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1985 .map(Self::new)
1986 }
1987 }
1988 };
1989 #[derive(serde::Serialize, serde::Deserialize)]
1990 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1991 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1996 #[derive(Clone)]
1997 pub struct TimelockUnexpectedOperationState {
1998 #[allow(missing_docs)]
1999 pub operationId: alloy::sol_types::private::FixedBytes<32>,
2000 #[allow(missing_docs)]
2001 pub expectedStates: alloy::sol_types::private::FixedBytes<32>,
2002 }
2003 #[allow(
2004 non_camel_case_types,
2005 non_snake_case,
2006 clippy::pub_underscore_fields,
2007 clippy::style
2008 )]
2009 const _: () = {
2010 use alloy::sol_types as alloy_sol_types;
2011 #[doc(hidden)]
2012 #[allow(dead_code)]
2013 type UnderlyingSolTuple<'a> = (
2014 alloy::sol_types::sol_data::FixedBytes<32>,
2015 alloy::sol_types::sol_data::FixedBytes<32>,
2016 );
2017 #[doc(hidden)]
2018 type UnderlyingRustTuple<'a> = (
2019 alloy::sol_types::private::FixedBytes<32>,
2020 alloy::sol_types::private::FixedBytes<32>,
2021 );
2022 #[cfg(test)]
2023 #[allow(dead_code, unreachable_patterns)]
2024 fn _type_assertion(
2025 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2026 ) {
2027 match _t {
2028 alloy_sol_types::private::AssertTypeEq::<
2029 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2030 >(_) => {}
2031 }
2032 }
2033 #[automatically_derived]
2034 #[doc(hidden)]
2035 impl ::core::convert::From<TimelockUnexpectedOperationState>
2036 for UnderlyingRustTuple<'_> {
2037 fn from(value: TimelockUnexpectedOperationState) -> Self {
2038 (value.operationId, value.expectedStates)
2039 }
2040 }
2041 #[automatically_derived]
2042 #[doc(hidden)]
2043 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2044 for TimelockUnexpectedOperationState {
2045 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2046 Self {
2047 operationId: tuple.0,
2048 expectedStates: tuple.1,
2049 }
2050 }
2051 }
2052 #[automatically_derived]
2053 impl alloy_sol_types::SolError for TimelockUnexpectedOperationState {
2054 type Parameters<'a> = UnderlyingSolTuple<'a>;
2055 type Token<'a> = <Self::Parameters<
2056 'a,
2057 > as alloy_sol_types::SolType>::Token<'a>;
2058 const SIGNATURE: &'static str = "TimelockUnexpectedOperationState(bytes32,bytes32)";
2059 const SELECTOR: [u8; 4] = [94u8, 173u8, 142u8, 181u8];
2060 #[inline]
2061 fn new<'a>(
2062 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2063 ) -> Self {
2064 tuple.into()
2065 }
2066 #[inline]
2067 fn tokenize(&self) -> Self::Token<'_> {
2068 (
2069 <alloy::sol_types::sol_data::FixedBytes<
2070 32,
2071 > as alloy_sol_types::SolType>::tokenize(&self.operationId),
2072 <alloy::sol_types::sol_data::FixedBytes<
2073 32,
2074 > as alloy_sol_types::SolType>::tokenize(&self.expectedStates),
2075 )
2076 }
2077 #[inline]
2078 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2079 <Self::Parameters<
2080 '_,
2081 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2082 .map(Self::new)
2083 }
2084 }
2085 };
2086 #[derive(serde::Serialize, serde::Deserialize)]
2087 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2088 #[allow(
2093 non_camel_case_types,
2094 non_snake_case,
2095 clippy::pub_underscore_fields,
2096 clippy::style
2097 )]
2098 #[derive(Clone)]
2099 pub struct CallExecuted {
2100 #[allow(missing_docs)]
2101 pub id: alloy::sol_types::private::FixedBytes<32>,
2102 #[allow(missing_docs)]
2103 pub index: alloy::sol_types::private::primitives::aliases::U256,
2104 #[allow(missing_docs)]
2105 pub target: alloy::sol_types::private::Address,
2106 #[allow(missing_docs)]
2107 pub value: alloy::sol_types::private::primitives::aliases::U256,
2108 #[allow(missing_docs)]
2109 pub data: alloy::sol_types::private::Bytes,
2110 }
2111 #[allow(
2112 non_camel_case_types,
2113 non_snake_case,
2114 clippy::pub_underscore_fields,
2115 clippy::style
2116 )]
2117 const _: () = {
2118 use alloy::sol_types as alloy_sol_types;
2119 #[automatically_derived]
2120 impl alloy_sol_types::SolEvent for CallExecuted {
2121 type DataTuple<'a> = (
2122 alloy::sol_types::sol_data::Address,
2123 alloy::sol_types::sol_data::Uint<256>,
2124 alloy::sol_types::sol_data::Bytes,
2125 );
2126 type DataToken<'a> = <Self::DataTuple<
2127 'a,
2128 > as alloy_sol_types::SolType>::Token<'a>;
2129 type TopicList = (
2130 alloy_sol_types::sol_data::FixedBytes<32>,
2131 alloy::sol_types::sol_data::FixedBytes<32>,
2132 alloy::sol_types::sol_data::Uint<256>,
2133 );
2134 const SIGNATURE: &'static str = "CallExecuted(bytes32,uint256,address,uint256,bytes)";
2135 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2136 194u8, 97u8, 126u8, 250u8, 105u8, 186u8, 182u8, 103u8, 130u8, 250u8,
2137 33u8, 149u8, 67u8, 113u8, 67u8, 56u8, 72u8, 156u8, 78u8, 158u8, 23u8,
2138 130u8, 113u8, 86u8, 10u8, 145u8, 184u8, 44u8, 63u8, 97u8, 43u8, 88u8,
2139 ]);
2140 const ANONYMOUS: bool = false;
2141 #[allow(unused_variables)]
2142 #[inline]
2143 fn new(
2144 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2145 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2146 ) -> Self {
2147 Self {
2148 id: topics.1,
2149 index: topics.2,
2150 target: data.0,
2151 value: data.1,
2152 data: data.2,
2153 }
2154 }
2155 #[inline]
2156 fn check_signature(
2157 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2158 ) -> alloy_sol_types::Result<()> {
2159 if topics.0 != Self::SIGNATURE_HASH {
2160 return Err(
2161 alloy_sol_types::Error::invalid_event_signature_hash(
2162 Self::SIGNATURE,
2163 topics.0,
2164 Self::SIGNATURE_HASH,
2165 ),
2166 );
2167 }
2168 Ok(())
2169 }
2170 #[inline]
2171 fn tokenize_body(&self) -> Self::DataToken<'_> {
2172 (
2173 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2174 &self.target,
2175 ),
2176 <alloy::sol_types::sol_data::Uint<
2177 256,
2178 > as alloy_sol_types::SolType>::tokenize(&self.value),
2179 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
2180 &self.data,
2181 ),
2182 )
2183 }
2184 #[inline]
2185 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2186 (Self::SIGNATURE_HASH.into(), self.id.clone(), self.index.clone())
2187 }
2188 #[inline]
2189 fn encode_topics_raw(
2190 &self,
2191 out: &mut [alloy_sol_types::abi::token::WordToken],
2192 ) -> alloy_sol_types::Result<()> {
2193 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2194 return Err(alloy_sol_types::Error::Overrun);
2195 }
2196 out[0usize] = alloy_sol_types::abi::token::WordToken(
2197 Self::SIGNATURE_HASH,
2198 );
2199 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2200 32,
2201 > as alloy_sol_types::EventTopic>::encode_topic(&self.id);
2202 out[2usize] = <alloy::sol_types::sol_data::Uint<
2203 256,
2204 > as alloy_sol_types::EventTopic>::encode_topic(&self.index);
2205 Ok(())
2206 }
2207 }
2208 #[automatically_derived]
2209 impl alloy_sol_types::private::IntoLogData for CallExecuted {
2210 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2211 From::from(self)
2212 }
2213 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2214 From::from(&self)
2215 }
2216 }
2217 #[automatically_derived]
2218 impl From<&CallExecuted> for alloy_sol_types::private::LogData {
2219 #[inline]
2220 fn from(this: &CallExecuted) -> alloy_sol_types::private::LogData {
2221 alloy_sol_types::SolEvent::encode_log_data(this)
2222 }
2223 }
2224 };
2225 #[derive(serde::Serialize, serde::Deserialize)]
2226 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2227 #[allow(
2232 non_camel_case_types,
2233 non_snake_case,
2234 clippy::pub_underscore_fields,
2235 clippy::style
2236 )]
2237 #[derive(Clone)]
2238 pub struct CallSalt {
2239 #[allow(missing_docs)]
2240 pub id: alloy::sol_types::private::FixedBytes<32>,
2241 #[allow(missing_docs)]
2242 pub salt: alloy::sol_types::private::FixedBytes<32>,
2243 }
2244 #[allow(
2245 non_camel_case_types,
2246 non_snake_case,
2247 clippy::pub_underscore_fields,
2248 clippy::style
2249 )]
2250 const _: () = {
2251 use alloy::sol_types as alloy_sol_types;
2252 #[automatically_derived]
2253 impl alloy_sol_types::SolEvent for CallSalt {
2254 type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2255 type DataToken<'a> = <Self::DataTuple<
2256 'a,
2257 > as alloy_sol_types::SolType>::Token<'a>;
2258 type TopicList = (
2259 alloy_sol_types::sol_data::FixedBytes<32>,
2260 alloy::sol_types::sol_data::FixedBytes<32>,
2261 );
2262 const SIGNATURE: &'static str = "CallSalt(bytes32,bytes32)";
2263 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2264 32u8, 253u8, 165u8, 253u8, 39u8, 161u8, 234u8, 123u8, 245u8, 185u8, 86u8,
2265 127u8, 20u8, 58u8, 197u8, 71u8, 11u8, 176u8, 89u8, 55u8, 74u8, 39u8,
2266 232u8, 246u8, 124u8, 180u8, 79u8, 148u8, 111u8, 109u8, 3u8, 135u8,
2267 ]);
2268 const ANONYMOUS: bool = false;
2269 #[allow(unused_variables)]
2270 #[inline]
2271 fn new(
2272 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2273 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2274 ) -> Self {
2275 Self { id: topics.1, salt: data.0 }
2276 }
2277 #[inline]
2278 fn check_signature(
2279 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2280 ) -> alloy_sol_types::Result<()> {
2281 if topics.0 != Self::SIGNATURE_HASH {
2282 return Err(
2283 alloy_sol_types::Error::invalid_event_signature_hash(
2284 Self::SIGNATURE,
2285 topics.0,
2286 Self::SIGNATURE_HASH,
2287 ),
2288 );
2289 }
2290 Ok(())
2291 }
2292 #[inline]
2293 fn tokenize_body(&self) -> Self::DataToken<'_> {
2294 (
2295 <alloy::sol_types::sol_data::FixedBytes<
2296 32,
2297 > as alloy_sol_types::SolType>::tokenize(&self.salt),
2298 )
2299 }
2300 #[inline]
2301 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2302 (Self::SIGNATURE_HASH.into(), self.id.clone())
2303 }
2304 #[inline]
2305 fn encode_topics_raw(
2306 &self,
2307 out: &mut [alloy_sol_types::abi::token::WordToken],
2308 ) -> alloy_sol_types::Result<()> {
2309 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2310 return Err(alloy_sol_types::Error::Overrun);
2311 }
2312 out[0usize] = alloy_sol_types::abi::token::WordToken(
2313 Self::SIGNATURE_HASH,
2314 );
2315 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2316 32,
2317 > as alloy_sol_types::EventTopic>::encode_topic(&self.id);
2318 Ok(())
2319 }
2320 }
2321 #[automatically_derived]
2322 impl alloy_sol_types::private::IntoLogData for CallSalt {
2323 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2324 From::from(self)
2325 }
2326 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2327 From::from(&self)
2328 }
2329 }
2330 #[automatically_derived]
2331 impl From<&CallSalt> for alloy_sol_types::private::LogData {
2332 #[inline]
2333 fn from(this: &CallSalt) -> alloy_sol_types::private::LogData {
2334 alloy_sol_types::SolEvent::encode_log_data(this)
2335 }
2336 }
2337 };
2338 #[derive(serde::Serialize, serde::Deserialize)]
2339 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2340 #[allow(
2345 non_camel_case_types,
2346 non_snake_case,
2347 clippy::pub_underscore_fields,
2348 clippy::style
2349 )]
2350 #[derive(Clone)]
2351 pub struct CallScheduled {
2352 #[allow(missing_docs)]
2353 pub id: alloy::sol_types::private::FixedBytes<32>,
2354 #[allow(missing_docs)]
2355 pub index: alloy::sol_types::private::primitives::aliases::U256,
2356 #[allow(missing_docs)]
2357 pub target: alloy::sol_types::private::Address,
2358 #[allow(missing_docs)]
2359 pub value: alloy::sol_types::private::primitives::aliases::U256,
2360 #[allow(missing_docs)]
2361 pub data: alloy::sol_types::private::Bytes,
2362 #[allow(missing_docs)]
2363 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
2364 #[allow(missing_docs)]
2365 pub delay: alloy::sol_types::private::primitives::aliases::U256,
2366 }
2367 #[allow(
2368 non_camel_case_types,
2369 non_snake_case,
2370 clippy::pub_underscore_fields,
2371 clippy::style
2372 )]
2373 const _: () = {
2374 use alloy::sol_types as alloy_sol_types;
2375 #[automatically_derived]
2376 impl alloy_sol_types::SolEvent for CallScheduled {
2377 type DataTuple<'a> = (
2378 alloy::sol_types::sol_data::Address,
2379 alloy::sol_types::sol_data::Uint<256>,
2380 alloy::sol_types::sol_data::Bytes,
2381 alloy::sol_types::sol_data::FixedBytes<32>,
2382 alloy::sol_types::sol_data::Uint<256>,
2383 );
2384 type DataToken<'a> = <Self::DataTuple<
2385 'a,
2386 > as alloy_sol_types::SolType>::Token<'a>;
2387 type TopicList = (
2388 alloy_sol_types::sol_data::FixedBytes<32>,
2389 alloy::sol_types::sol_data::FixedBytes<32>,
2390 alloy::sol_types::sol_data::Uint<256>,
2391 );
2392 const SIGNATURE: &'static str = "CallScheduled(bytes32,uint256,address,uint256,bytes,bytes32,uint256)";
2393 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2394 76u8, 244u8, 65u8, 12u8, 197u8, 112u8, 64u8, 228u8, 72u8, 98u8, 239u8,
2395 15u8, 69u8, 243u8, 221u8, 90u8, 94u8, 2u8, 219u8, 142u8, 184u8, 173u8,
2396 214u8, 72u8, 212u8, 176u8, 226u8, 54u8, 241u8, 208u8, 125u8, 202u8,
2397 ]);
2398 const ANONYMOUS: bool = false;
2399 #[allow(unused_variables)]
2400 #[inline]
2401 fn new(
2402 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2403 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2404 ) -> Self {
2405 Self {
2406 id: topics.1,
2407 index: topics.2,
2408 target: data.0,
2409 value: data.1,
2410 data: data.2,
2411 predecessor: data.3,
2412 delay: data.4,
2413 }
2414 }
2415 #[inline]
2416 fn check_signature(
2417 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2418 ) -> alloy_sol_types::Result<()> {
2419 if topics.0 != Self::SIGNATURE_HASH {
2420 return Err(
2421 alloy_sol_types::Error::invalid_event_signature_hash(
2422 Self::SIGNATURE,
2423 topics.0,
2424 Self::SIGNATURE_HASH,
2425 ),
2426 );
2427 }
2428 Ok(())
2429 }
2430 #[inline]
2431 fn tokenize_body(&self) -> Self::DataToken<'_> {
2432 (
2433 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2434 &self.target,
2435 ),
2436 <alloy::sol_types::sol_data::Uint<
2437 256,
2438 > as alloy_sol_types::SolType>::tokenize(&self.value),
2439 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
2440 &self.data,
2441 ),
2442 <alloy::sol_types::sol_data::FixedBytes<
2443 32,
2444 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
2445 <alloy::sol_types::sol_data::Uint<
2446 256,
2447 > as alloy_sol_types::SolType>::tokenize(&self.delay),
2448 )
2449 }
2450 #[inline]
2451 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2452 (Self::SIGNATURE_HASH.into(), self.id.clone(), self.index.clone())
2453 }
2454 #[inline]
2455 fn encode_topics_raw(
2456 &self,
2457 out: &mut [alloy_sol_types::abi::token::WordToken],
2458 ) -> alloy_sol_types::Result<()> {
2459 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2460 return Err(alloy_sol_types::Error::Overrun);
2461 }
2462 out[0usize] = alloy_sol_types::abi::token::WordToken(
2463 Self::SIGNATURE_HASH,
2464 );
2465 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2466 32,
2467 > as alloy_sol_types::EventTopic>::encode_topic(&self.id);
2468 out[2usize] = <alloy::sol_types::sol_data::Uint<
2469 256,
2470 > as alloy_sol_types::EventTopic>::encode_topic(&self.index);
2471 Ok(())
2472 }
2473 }
2474 #[automatically_derived]
2475 impl alloy_sol_types::private::IntoLogData for CallScheduled {
2476 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2477 From::from(self)
2478 }
2479 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2480 From::from(&self)
2481 }
2482 }
2483 #[automatically_derived]
2484 impl From<&CallScheduled> for alloy_sol_types::private::LogData {
2485 #[inline]
2486 fn from(this: &CallScheduled) -> alloy_sol_types::private::LogData {
2487 alloy_sol_types::SolEvent::encode_log_data(this)
2488 }
2489 }
2490 };
2491 #[derive(serde::Serialize, serde::Deserialize)]
2492 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2493 #[allow(
2498 non_camel_case_types,
2499 non_snake_case,
2500 clippy::pub_underscore_fields,
2501 clippy::style
2502 )]
2503 #[derive(Clone)]
2504 pub struct Cancelled {
2505 #[allow(missing_docs)]
2506 pub id: alloy::sol_types::private::FixedBytes<32>,
2507 }
2508 #[allow(
2509 non_camel_case_types,
2510 non_snake_case,
2511 clippy::pub_underscore_fields,
2512 clippy::style
2513 )]
2514 const _: () = {
2515 use alloy::sol_types as alloy_sol_types;
2516 #[automatically_derived]
2517 impl alloy_sol_types::SolEvent for Cancelled {
2518 type DataTuple<'a> = ();
2519 type DataToken<'a> = <Self::DataTuple<
2520 'a,
2521 > as alloy_sol_types::SolType>::Token<'a>;
2522 type TopicList = (
2523 alloy_sol_types::sol_data::FixedBytes<32>,
2524 alloy::sol_types::sol_data::FixedBytes<32>,
2525 );
2526 const SIGNATURE: &'static str = "Cancelled(bytes32)";
2527 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2528 186u8, 161u8, 235u8, 34u8, 242u8, 164u8, 146u8, 186u8, 26u8, 95u8, 234u8,
2529 97u8, 184u8, 223u8, 77u8, 39u8, 198u8, 200u8, 181u8, 243u8, 151u8, 30u8,
2530 99u8, 187u8, 88u8, 250u8, 20u8, 255u8, 114u8, 238u8, 219u8, 112u8,
2531 ]);
2532 const ANONYMOUS: bool = false;
2533 #[allow(unused_variables)]
2534 #[inline]
2535 fn new(
2536 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2537 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2538 ) -> Self {
2539 Self { id: topics.1 }
2540 }
2541 #[inline]
2542 fn check_signature(
2543 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2544 ) -> alloy_sol_types::Result<()> {
2545 if topics.0 != Self::SIGNATURE_HASH {
2546 return Err(
2547 alloy_sol_types::Error::invalid_event_signature_hash(
2548 Self::SIGNATURE,
2549 topics.0,
2550 Self::SIGNATURE_HASH,
2551 ),
2552 );
2553 }
2554 Ok(())
2555 }
2556 #[inline]
2557 fn tokenize_body(&self) -> Self::DataToken<'_> {
2558 ()
2559 }
2560 #[inline]
2561 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2562 (Self::SIGNATURE_HASH.into(), self.id.clone())
2563 }
2564 #[inline]
2565 fn encode_topics_raw(
2566 &self,
2567 out: &mut [alloy_sol_types::abi::token::WordToken],
2568 ) -> alloy_sol_types::Result<()> {
2569 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2570 return Err(alloy_sol_types::Error::Overrun);
2571 }
2572 out[0usize] = alloy_sol_types::abi::token::WordToken(
2573 Self::SIGNATURE_HASH,
2574 );
2575 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2576 32,
2577 > as alloy_sol_types::EventTopic>::encode_topic(&self.id);
2578 Ok(())
2579 }
2580 }
2581 #[automatically_derived]
2582 impl alloy_sol_types::private::IntoLogData for Cancelled {
2583 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2584 From::from(self)
2585 }
2586 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2587 From::from(&self)
2588 }
2589 }
2590 #[automatically_derived]
2591 impl From<&Cancelled> for alloy_sol_types::private::LogData {
2592 #[inline]
2593 fn from(this: &Cancelled) -> alloy_sol_types::private::LogData {
2594 alloy_sol_types::SolEvent::encode_log_data(this)
2595 }
2596 }
2597 };
2598 #[derive(serde::Serialize, serde::Deserialize)]
2599 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2600 #[allow(
2605 non_camel_case_types,
2606 non_snake_case,
2607 clippy::pub_underscore_fields,
2608 clippy::style
2609 )]
2610 #[derive(Clone)]
2611 pub struct MinDelayChange {
2612 #[allow(missing_docs)]
2613 pub oldDuration: alloy::sol_types::private::primitives::aliases::U256,
2614 #[allow(missing_docs)]
2615 pub newDuration: alloy::sol_types::private::primitives::aliases::U256,
2616 }
2617 #[allow(
2618 non_camel_case_types,
2619 non_snake_case,
2620 clippy::pub_underscore_fields,
2621 clippy::style
2622 )]
2623 const _: () = {
2624 use alloy::sol_types as alloy_sol_types;
2625 #[automatically_derived]
2626 impl alloy_sol_types::SolEvent for MinDelayChange {
2627 type DataTuple<'a> = (
2628 alloy::sol_types::sol_data::Uint<256>,
2629 alloy::sol_types::sol_data::Uint<256>,
2630 );
2631 type DataToken<'a> = <Self::DataTuple<
2632 'a,
2633 > as alloy_sol_types::SolType>::Token<'a>;
2634 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
2635 const SIGNATURE: &'static str = "MinDelayChange(uint256,uint256)";
2636 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2637 17u8, 194u8, 79u8, 78u8, 173u8, 22u8, 80u8, 124u8, 105u8, 172u8, 70u8,
2638 127u8, 189u8, 94u8, 78u8, 237u8, 95u8, 181u8, 198u8, 153u8, 98u8, 109u8,
2639 44u8, 198u8, 214u8, 100u8, 33u8, 223u8, 37u8, 56u8, 134u8, 213u8,
2640 ]);
2641 const ANONYMOUS: bool = false;
2642 #[allow(unused_variables)]
2643 #[inline]
2644 fn new(
2645 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2646 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2647 ) -> Self {
2648 Self {
2649 oldDuration: data.0,
2650 newDuration: data.1,
2651 }
2652 }
2653 #[inline]
2654 fn check_signature(
2655 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2656 ) -> alloy_sol_types::Result<()> {
2657 if topics.0 != Self::SIGNATURE_HASH {
2658 return Err(
2659 alloy_sol_types::Error::invalid_event_signature_hash(
2660 Self::SIGNATURE,
2661 topics.0,
2662 Self::SIGNATURE_HASH,
2663 ),
2664 );
2665 }
2666 Ok(())
2667 }
2668 #[inline]
2669 fn tokenize_body(&self) -> Self::DataToken<'_> {
2670 (
2671 <alloy::sol_types::sol_data::Uint<
2672 256,
2673 > as alloy_sol_types::SolType>::tokenize(&self.oldDuration),
2674 <alloy::sol_types::sol_data::Uint<
2675 256,
2676 > as alloy_sol_types::SolType>::tokenize(&self.newDuration),
2677 )
2678 }
2679 #[inline]
2680 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2681 (Self::SIGNATURE_HASH.into(),)
2682 }
2683 #[inline]
2684 fn encode_topics_raw(
2685 &self,
2686 out: &mut [alloy_sol_types::abi::token::WordToken],
2687 ) -> alloy_sol_types::Result<()> {
2688 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2689 return Err(alloy_sol_types::Error::Overrun);
2690 }
2691 out[0usize] = alloy_sol_types::abi::token::WordToken(
2692 Self::SIGNATURE_HASH,
2693 );
2694 Ok(())
2695 }
2696 }
2697 #[automatically_derived]
2698 impl alloy_sol_types::private::IntoLogData for MinDelayChange {
2699 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2700 From::from(self)
2701 }
2702 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2703 From::from(&self)
2704 }
2705 }
2706 #[automatically_derived]
2707 impl From<&MinDelayChange> for alloy_sol_types::private::LogData {
2708 #[inline]
2709 fn from(this: &MinDelayChange) -> alloy_sol_types::private::LogData {
2710 alloy_sol_types::SolEvent::encode_log_data(this)
2711 }
2712 }
2713 };
2714 #[derive(serde::Serialize, serde::Deserialize)]
2715 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2716 #[allow(
2721 non_camel_case_types,
2722 non_snake_case,
2723 clippy::pub_underscore_fields,
2724 clippy::style
2725 )]
2726 #[derive(Clone)]
2727 pub struct RoleAdminChanged {
2728 #[allow(missing_docs)]
2729 pub role: alloy::sol_types::private::FixedBytes<32>,
2730 #[allow(missing_docs)]
2731 pub previousAdminRole: alloy::sol_types::private::FixedBytes<32>,
2732 #[allow(missing_docs)]
2733 pub newAdminRole: alloy::sol_types::private::FixedBytes<32>,
2734 }
2735 #[allow(
2736 non_camel_case_types,
2737 non_snake_case,
2738 clippy::pub_underscore_fields,
2739 clippy::style
2740 )]
2741 const _: () = {
2742 use alloy::sol_types as alloy_sol_types;
2743 #[automatically_derived]
2744 impl alloy_sol_types::SolEvent for RoleAdminChanged {
2745 type DataTuple<'a> = ();
2746 type DataToken<'a> = <Self::DataTuple<
2747 'a,
2748 > as alloy_sol_types::SolType>::Token<'a>;
2749 type TopicList = (
2750 alloy_sol_types::sol_data::FixedBytes<32>,
2751 alloy::sol_types::sol_data::FixedBytes<32>,
2752 alloy::sol_types::sol_data::FixedBytes<32>,
2753 alloy::sol_types::sol_data::FixedBytes<32>,
2754 );
2755 const SIGNATURE: &'static str = "RoleAdminChanged(bytes32,bytes32,bytes32)";
2756 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2757 189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8,
2758 81u8, 66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8,
2759 71u8, 92u8, 58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
2760 ]);
2761 const ANONYMOUS: bool = false;
2762 #[allow(unused_variables)]
2763 #[inline]
2764 fn new(
2765 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2766 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2767 ) -> Self {
2768 Self {
2769 role: topics.1,
2770 previousAdminRole: topics.2,
2771 newAdminRole: topics.3,
2772 }
2773 }
2774 #[inline]
2775 fn check_signature(
2776 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2777 ) -> alloy_sol_types::Result<()> {
2778 if topics.0 != Self::SIGNATURE_HASH {
2779 return Err(
2780 alloy_sol_types::Error::invalid_event_signature_hash(
2781 Self::SIGNATURE,
2782 topics.0,
2783 Self::SIGNATURE_HASH,
2784 ),
2785 );
2786 }
2787 Ok(())
2788 }
2789 #[inline]
2790 fn tokenize_body(&self) -> Self::DataToken<'_> {
2791 ()
2792 }
2793 #[inline]
2794 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2795 (
2796 Self::SIGNATURE_HASH.into(),
2797 self.role.clone(),
2798 self.previousAdminRole.clone(),
2799 self.newAdminRole.clone(),
2800 )
2801 }
2802 #[inline]
2803 fn encode_topics_raw(
2804 &self,
2805 out: &mut [alloy_sol_types::abi::token::WordToken],
2806 ) -> alloy_sol_types::Result<()> {
2807 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2808 return Err(alloy_sol_types::Error::Overrun);
2809 }
2810 out[0usize] = alloy_sol_types::abi::token::WordToken(
2811 Self::SIGNATURE_HASH,
2812 );
2813 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2814 32,
2815 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
2816 out[2usize] = <alloy::sol_types::sol_data::FixedBytes<
2817 32,
2818 > as alloy_sol_types::EventTopic>::encode_topic(&self.previousAdminRole);
2819 out[3usize] = <alloy::sol_types::sol_data::FixedBytes<
2820 32,
2821 > as alloy_sol_types::EventTopic>::encode_topic(&self.newAdminRole);
2822 Ok(())
2823 }
2824 }
2825 #[automatically_derived]
2826 impl alloy_sol_types::private::IntoLogData for RoleAdminChanged {
2827 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2828 From::from(self)
2829 }
2830 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2831 From::from(&self)
2832 }
2833 }
2834 #[automatically_derived]
2835 impl From<&RoleAdminChanged> for alloy_sol_types::private::LogData {
2836 #[inline]
2837 fn from(this: &RoleAdminChanged) -> alloy_sol_types::private::LogData {
2838 alloy_sol_types::SolEvent::encode_log_data(this)
2839 }
2840 }
2841 };
2842 #[derive(serde::Serialize, serde::Deserialize)]
2843 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2844 #[allow(
2849 non_camel_case_types,
2850 non_snake_case,
2851 clippy::pub_underscore_fields,
2852 clippy::style
2853 )]
2854 #[derive(Clone)]
2855 pub struct RoleGranted {
2856 #[allow(missing_docs)]
2857 pub role: alloy::sol_types::private::FixedBytes<32>,
2858 #[allow(missing_docs)]
2859 pub account: alloy::sol_types::private::Address,
2860 #[allow(missing_docs)]
2861 pub sender: alloy::sol_types::private::Address,
2862 }
2863 #[allow(
2864 non_camel_case_types,
2865 non_snake_case,
2866 clippy::pub_underscore_fields,
2867 clippy::style
2868 )]
2869 const _: () = {
2870 use alloy::sol_types as alloy_sol_types;
2871 #[automatically_derived]
2872 impl alloy_sol_types::SolEvent for RoleGranted {
2873 type DataTuple<'a> = ();
2874 type DataToken<'a> = <Self::DataTuple<
2875 'a,
2876 > as alloy_sol_types::SolType>::Token<'a>;
2877 type TopicList = (
2878 alloy_sol_types::sol_data::FixedBytes<32>,
2879 alloy::sol_types::sol_data::FixedBytes<32>,
2880 alloy::sol_types::sol_data::Address,
2881 alloy::sol_types::sol_data::Address,
2882 );
2883 const SIGNATURE: &'static str = "RoleGranted(bytes32,address,address)";
2884 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2885 47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8,
2886 236u8, 121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8,
2887 64u8, 48u8, 69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
2888 ]);
2889 const ANONYMOUS: bool = false;
2890 #[allow(unused_variables)]
2891 #[inline]
2892 fn new(
2893 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2894 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2895 ) -> Self {
2896 Self {
2897 role: topics.1,
2898 account: topics.2,
2899 sender: topics.3,
2900 }
2901 }
2902 #[inline]
2903 fn check_signature(
2904 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2905 ) -> alloy_sol_types::Result<()> {
2906 if topics.0 != Self::SIGNATURE_HASH {
2907 return Err(
2908 alloy_sol_types::Error::invalid_event_signature_hash(
2909 Self::SIGNATURE,
2910 topics.0,
2911 Self::SIGNATURE_HASH,
2912 ),
2913 );
2914 }
2915 Ok(())
2916 }
2917 #[inline]
2918 fn tokenize_body(&self) -> Self::DataToken<'_> {
2919 ()
2920 }
2921 #[inline]
2922 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2923 (
2924 Self::SIGNATURE_HASH.into(),
2925 self.role.clone(),
2926 self.account.clone(),
2927 self.sender.clone(),
2928 )
2929 }
2930 #[inline]
2931 fn encode_topics_raw(
2932 &self,
2933 out: &mut [alloy_sol_types::abi::token::WordToken],
2934 ) -> alloy_sol_types::Result<()> {
2935 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2936 return Err(alloy_sol_types::Error::Overrun);
2937 }
2938 out[0usize] = alloy_sol_types::abi::token::WordToken(
2939 Self::SIGNATURE_HASH,
2940 );
2941 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2942 32,
2943 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
2944 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2945 &self.account,
2946 );
2947 out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2948 &self.sender,
2949 );
2950 Ok(())
2951 }
2952 }
2953 #[automatically_derived]
2954 impl alloy_sol_types::private::IntoLogData for RoleGranted {
2955 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2956 From::from(self)
2957 }
2958 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2959 From::from(&self)
2960 }
2961 }
2962 #[automatically_derived]
2963 impl From<&RoleGranted> for alloy_sol_types::private::LogData {
2964 #[inline]
2965 fn from(this: &RoleGranted) -> alloy_sol_types::private::LogData {
2966 alloy_sol_types::SolEvent::encode_log_data(this)
2967 }
2968 }
2969 };
2970 #[derive(serde::Serialize, serde::Deserialize)]
2971 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2972 #[allow(
2977 non_camel_case_types,
2978 non_snake_case,
2979 clippy::pub_underscore_fields,
2980 clippy::style
2981 )]
2982 #[derive(Clone)]
2983 pub struct RoleRevoked {
2984 #[allow(missing_docs)]
2985 pub role: alloy::sol_types::private::FixedBytes<32>,
2986 #[allow(missing_docs)]
2987 pub account: alloy::sol_types::private::Address,
2988 #[allow(missing_docs)]
2989 pub sender: alloy::sol_types::private::Address,
2990 }
2991 #[allow(
2992 non_camel_case_types,
2993 non_snake_case,
2994 clippy::pub_underscore_fields,
2995 clippy::style
2996 )]
2997 const _: () = {
2998 use alloy::sol_types as alloy_sol_types;
2999 #[automatically_derived]
3000 impl alloy_sol_types::SolEvent for RoleRevoked {
3001 type DataTuple<'a> = ();
3002 type DataToken<'a> = <Self::DataTuple<
3003 'a,
3004 > as alloy_sol_types::SolType>::Token<'a>;
3005 type TopicList = (
3006 alloy_sol_types::sol_data::FixedBytes<32>,
3007 alloy::sol_types::sol_data::FixedBytes<32>,
3008 alloy::sol_types::sol_data::Address,
3009 alloy::sol_types::sol_data::Address,
3010 );
3011 const SIGNATURE: &'static str = "RoleRevoked(bytes32,address,address)";
3012 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
3013 246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8,
3014 103u8, 11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8,
3015 253u8, 100u8, 235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
3016 ]);
3017 const ANONYMOUS: bool = false;
3018 #[allow(unused_variables)]
3019 #[inline]
3020 fn new(
3021 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
3022 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
3023 ) -> Self {
3024 Self {
3025 role: topics.1,
3026 account: topics.2,
3027 sender: topics.3,
3028 }
3029 }
3030 #[inline]
3031 fn check_signature(
3032 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
3033 ) -> alloy_sol_types::Result<()> {
3034 if topics.0 != Self::SIGNATURE_HASH {
3035 return Err(
3036 alloy_sol_types::Error::invalid_event_signature_hash(
3037 Self::SIGNATURE,
3038 topics.0,
3039 Self::SIGNATURE_HASH,
3040 ),
3041 );
3042 }
3043 Ok(())
3044 }
3045 #[inline]
3046 fn tokenize_body(&self) -> Self::DataToken<'_> {
3047 ()
3048 }
3049 #[inline]
3050 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
3051 (
3052 Self::SIGNATURE_HASH.into(),
3053 self.role.clone(),
3054 self.account.clone(),
3055 self.sender.clone(),
3056 )
3057 }
3058 #[inline]
3059 fn encode_topics_raw(
3060 &self,
3061 out: &mut [alloy_sol_types::abi::token::WordToken],
3062 ) -> alloy_sol_types::Result<()> {
3063 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
3064 return Err(alloy_sol_types::Error::Overrun);
3065 }
3066 out[0usize] = alloy_sol_types::abi::token::WordToken(
3067 Self::SIGNATURE_HASH,
3068 );
3069 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
3070 32,
3071 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
3072 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
3073 &self.account,
3074 );
3075 out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
3076 &self.sender,
3077 );
3078 Ok(())
3079 }
3080 }
3081 #[automatically_derived]
3082 impl alloy_sol_types::private::IntoLogData for RoleRevoked {
3083 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3084 From::from(self)
3085 }
3086 fn into_log_data(self) -> alloy_sol_types::private::LogData {
3087 From::from(&self)
3088 }
3089 }
3090 #[automatically_derived]
3091 impl From<&RoleRevoked> for alloy_sol_types::private::LogData {
3092 #[inline]
3093 fn from(this: &RoleRevoked) -> alloy_sol_types::private::LogData {
3094 alloy_sol_types::SolEvent::encode_log_data(this)
3095 }
3096 }
3097 };
3098 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3103 #[derive(Clone)]
3104 pub struct constructorCall {
3105 #[allow(missing_docs)]
3106 pub minDelay: alloy::sol_types::private::primitives::aliases::U256,
3107 #[allow(missing_docs)]
3108 pub proposers: alloy::sol_types::private::Vec<
3109 alloy::sol_types::private::Address,
3110 >,
3111 #[allow(missing_docs)]
3112 pub executors: alloy::sol_types::private::Vec<
3113 alloy::sol_types::private::Address,
3114 >,
3115 #[allow(missing_docs)]
3116 pub admin: alloy::sol_types::private::Address,
3117 }
3118 const _: () = {
3119 use alloy::sol_types as alloy_sol_types;
3120 {
3121 #[doc(hidden)]
3122 #[allow(dead_code)]
3123 type UnderlyingSolTuple<'a> = (
3124 alloy::sol_types::sol_data::Uint<256>,
3125 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3126 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3127 alloy::sol_types::sol_data::Address,
3128 );
3129 #[doc(hidden)]
3130 type UnderlyingRustTuple<'a> = (
3131 alloy::sol_types::private::primitives::aliases::U256,
3132 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3133 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3134 alloy::sol_types::private::Address,
3135 );
3136 #[cfg(test)]
3137 #[allow(dead_code, unreachable_patterns)]
3138 fn _type_assertion(
3139 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3140 ) {
3141 match _t {
3142 alloy_sol_types::private::AssertTypeEq::<
3143 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3144 >(_) => {}
3145 }
3146 }
3147 #[automatically_derived]
3148 #[doc(hidden)]
3149 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
3150 fn from(value: constructorCall) -> Self {
3151 (value.minDelay, value.proposers, value.executors, value.admin)
3152 }
3153 }
3154 #[automatically_derived]
3155 #[doc(hidden)]
3156 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
3157 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3158 Self {
3159 minDelay: tuple.0,
3160 proposers: tuple.1,
3161 executors: tuple.2,
3162 admin: tuple.3,
3163 }
3164 }
3165 }
3166 }
3167 #[automatically_derived]
3168 impl alloy_sol_types::SolConstructor for constructorCall {
3169 type Parameters<'a> = (
3170 alloy::sol_types::sol_data::Uint<256>,
3171 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3172 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3173 alloy::sol_types::sol_data::Address,
3174 );
3175 type Token<'a> = <Self::Parameters<
3176 'a,
3177 > as alloy_sol_types::SolType>::Token<'a>;
3178 #[inline]
3179 fn new<'a>(
3180 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3181 ) -> Self {
3182 tuple.into()
3183 }
3184 #[inline]
3185 fn tokenize(&self) -> Self::Token<'_> {
3186 (
3187 <alloy::sol_types::sol_data::Uint<
3188 256,
3189 > as alloy_sol_types::SolType>::tokenize(&self.minDelay),
3190 <alloy::sol_types::sol_data::Array<
3191 alloy::sol_types::sol_data::Address,
3192 > as alloy_sol_types::SolType>::tokenize(&self.proposers),
3193 <alloy::sol_types::sol_data::Array<
3194 alloy::sol_types::sol_data::Address,
3195 > as alloy_sol_types::SolType>::tokenize(&self.executors),
3196 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3197 &self.admin,
3198 ),
3199 )
3200 }
3201 }
3202 };
3203 #[derive(serde::Serialize, serde::Deserialize)]
3204 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3205 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3210 #[derive(Clone)]
3211 pub struct CANCELLER_ROLECall;
3212 #[derive(serde::Serialize, serde::Deserialize)]
3213 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3214 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3216 #[derive(Clone)]
3217 pub struct CANCELLER_ROLEReturn {
3218 #[allow(missing_docs)]
3219 pub _0: alloy::sol_types::private::FixedBytes<32>,
3220 }
3221 #[allow(
3222 non_camel_case_types,
3223 non_snake_case,
3224 clippy::pub_underscore_fields,
3225 clippy::style
3226 )]
3227 const _: () = {
3228 use alloy::sol_types as alloy_sol_types;
3229 {
3230 #[doc(hidden)]
3231 #[allow(dead_code)]
3232 type UnderlyingSolTuple<'a> = ();
3233 #[doc(hidden)]
3234 type UnderlyingRustTuple<'a> = ();
3235 #[cfg(test)]
3236 #[allow(dead_code, unreachable_patterns)]
3237 fn _type_assertion(
3238 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3239 ) {
3240 match _t {
3241 alloy_sol_types::private::AssertTypeEq::<
3242 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3243 >(_) => {}
3244 }
3245 }
3246 #[automatically_derived]
3247 #[doc(hidden)]
3248 impl ::core::convert::From<CANCELLER_ROLECall> for UnderlyingRustTuple<'_> {
3249 fn from(value: CANCELLER_ROLECall) -> Self {
3250 ()
3251 }
3252 }
3253 #[automatically_derived]
3254 #[doc(hidden)]
3255 impl ::core::convert::From<UnderlyingRustTuple<'_>> for CANCELLER_ROLECall {
3256 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3257 Self
3258 }
3259 }
3260 }
3261 {
3262 #[doc(hidden)]
3263 #[allow(dead_code)]
3264 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3265 #[doc(hidden)]
3266 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3267 #[cfg(test)]
3268 #[allow(dead_code, unreachable_patterns)]
3269 fn _type_assertion(
3270 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3271 ) {
3272 match _t {
3273 alloy_sol_types::private::AssertTypeEq::<
3274 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3275 >(_) => {}
3276 }
3277 }
3278 #[automatically_derived]
3279 #[doc(hidden)]
3280 impl ::core::convert::From<CANCELLER_ROLEReturn>
3281 for UnderlyingRustTuple<'_> {
3282 fn from(value: CANCELLER_ROLEReturn) -> Self {
3283 (value._0,)
3284 }
3285 }
3286 #[automatically_derived]
3287 #[doc(hidden)]
3288 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3289 for CANCELLER_ROLEReturn {
3290 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3291 Self { _0: tuple.0 }
3292 }
3293 }
3294 }
3295 #[automatically_derived]
3296 impl alloy_sol_types::SolCall for CANCELLER_ROLECall {
3297 type Parameters<'a> = ();
3298 type Token<'a> = <Self::Parameters<
3299 'a,
3300 > as alloy_sol_types::SolType>::Token<'a>;
3301 type Return = alloy::sol_types::private::FixedBytes<32>;
3302 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3303 type ReturnToken<'a> = <Self::ReturnTuple<
3304 'a,
3305 > as alloy_sol_types::SolType>::Token<'a>;
3306 const SIGNATURE: &'static str = "CANCELLER_ROLE()";
3307 const SELECTOR: [u8; 4] = [176u8, 142u8, 81u8, 192u8];
3308 #[inline]
3309 fn new<'a>(
3310 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3311 ) -> Self {
3312 tuple.into()
3313 }
3314 #[inline]
3315 fn tokenize(&self) -> Self::Token<'_> {
3316 ()
3317 }
3318 #[inline]
3319 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3320 (
3321 <alloy::sol_types::sol_data::FixedBytes<
3322 32,
3323 > as alloy_sol_types::SolType>::tokenize(ret),
3324 )
3325 }
3326 #[inline]
3327 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3328 <Self::ReturnTuple<
3329 '_,
3330 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3331 .map(|r| {
3332 let r: CANCELLER_ROLEReturn = r.into();
3333 r._0
3334 })
3335 }
3336 #[inline]
3337 fn abi_decode_returns_validate(
3338 data: &[u8],
3339 ) -> alloy_sol_types::Result<Self::Return> {
3340 <Self::ReturnTuple<
3341 '_,
3342 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3343 .map(|r| {
3344 let r: CANCELLER_ROLEReturn = r.into();
3345 r._0
3346 })
3347 }
3348 }
3349 };
3350 #[derive(serde::Serialize, serde::Deserialize)]
3351 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3352 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3357 #[derive(Clone)]
3358 pub struct DEFAULT_ADMIN_ROLECall;
3359 #[derive(serde::Serialize, serde::Deserialize)]
3360 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3361 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3363 #[derive(Clone)]
3364 pub struct DEFAULT_ADMIN_ROLEReturn {
3365 #[allow(missing_docs)]
3366 pub _0: alloy::sol_types::private::FixedBytes<32>,
3367 }
3368 #[allow(
3369 non_camel_case_types,
3370 non_snake_case,
3371 clippy::pub_underscore_fields,
3372 clippy::style
3373 )]
3374 const _: () = {
3375 use alloy::sol_types as alloy_sol_types;
3376 {
3377 #[doc(hidden)]
3378 #[allow(dead_code)]
3379 type UnderlyingSolTuple<'a> = ();
3380 #[doc(hidden)]
3381 type UnderlyingRustTuple<'a> = ();
3382 #[cfg(test)]
3383 #[allow(dead_code, unreachable_patterns)]
3384 fn _type_assertion(
3385 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3386 ) {
3387 match _t {
3388 alloy_sol_types::private::AssertTypeEq::<
3389 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3390 >(_) => {}
3391 }
3392 }
3393 #[automatically_derived]
3394 #[doc(hidden)]
3395 impl ::core::convert::From<DEFAULT_ADMIN_ROLECall>
3396 for UnderlyingRustTuple<'_> {
3397 fn from(value: DEFAULT_ADMIN_ROLECall) -> Self {
3398 ()
3399 }
3400 }
3401 #[automatically_derived]
3402 #[doc(hidden)]
3403 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3404 for DEFAULT_ADMIN_ROLECall {
3405 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3406 Self
3407 }
3408 }
3409 }
3410 {
3411 #[doc(hidden)]
3412 #[allow(dead_code)]
3413 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3414 #[doc(hidden)]
3415 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3416 #[cfg(test)]
3417 #[allow(dead_code, unreachable_patterns)]
3418 fn _type_assertion(
3419 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3420 ) {
3421 match _t {
3422 alloy_sol_types::private::AssertTypeEq::<
3423 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3424 >(_) => {}
3425 }
3426 }
3427 #[automatically_derived]
3428 #[doc(hidden)]
3429 impl ::core::convert::From<DEFAULT_ADMIN_ROLEReturn>
3430 for UnderlyingRustTuple<'_> {
3431 fn from(value: DEFAULT_ADMIN_ROLEReturn) -> Self {
3432 (value._0,)
3433 }
3434 }
3435 #[automatically_derived]
3436 #[doc(hidden)]
3437 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3438 for DEFAULT_ADMIN_ROLEReturn {
3439 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3440 Self { _0: tuple.0 }
3441 }
3442 }
3443 }
3444 #[automatically_derived]
3445 impl alloy_sol_types::SolCall for DEFAULT_ADMIN_ROLECall {
3446 type Parameters<'a> = ();
3447 type Token<'a> = <Self::Parameters<
3448 'a,
3449 > as alloy_sol_types::SolType>::Token<'a>;
3450 type Return = alloy::sol_types::private::FixedBytes<32>;
3451 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3452 type ReturnToken<'a> = <Self::ReturnTuple<
3453 'a,
3454 > as alloy_sol_types::SolType>::Token<'a>;
3455 const SIGNATURE: &'static str = "DEFAULT_ADMIN_ROLE()";
3456 const SELECTOR: [u8; 4] = [162u8, 23u8, 253u8, 223u8];
3457 #[inline]
3458 fn new<'a>(
3459 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3460 ) -> Self {
3461 tuple.into()
3462 }
3463 #[inline]
3464 fn tokenize(&self) -> Self::Token<'_> {
3465 ()
3466 }
3467 #[inline]
3468 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3469 (
3470 <alloy::sol_types::sol_data::FixedBytes<
3471 32,
3472 > as alloy_sol_types::SolType>::tokenize(ret),
3473 )
3474 }
3475 #[inline]
3476 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3477 <Self::ReturnTuple<
3478 '_,
3479 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3480 .map(|r| {
3481 let r: DEFAULT_ADMIN_ROLEReturn = r.into();
3482 r._0
3483 })
3484 }
3485 #[inline]
3486 fn abi_decode_returns_validate(
3487 data: &[u8],
3488 ) -> alloy_sol_types::Result<Self::Return> {
3489 <Self::ReturnTuple<
3490 '_,
3491 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3492 .map(|r| {
3493 let r: DEFAULT_ADMIN_ROLEReturn = r.into();
3494 r._0
3495 })
3496 }
3497 }
3498 };
3499 #[derive(serde::Serialize, serde::Deserialize)]
3500 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3501 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3506 #[derive(Clone)]
3507 pub struct EXECUTOR_ROLECall;
3508 #[derive(serde::Serialize, serde::Deserialize)]
3509 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3510 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3512 #[derive(Clone)]
3513 pub struct EXECUTOR_ROLEReturn {
3514 #[allow(missing_docs)]
3515 pub _0: alloy::sol_types::private::FixedBytes<32>,
3516 }
3517 #[allow(
3518 non_camel_case_types,
3519 non_snake_case,
3520 clippy::pub_underscore_fields,
3521 clippy::style
3522 )]
3523 const _: () = {
3524 use alloy::sol_types as alloy_sol_types;
3525 {
3526 #[doc(hidden)]
3527 #[allow(dead_code)]
3528 type UnderlyingSolTuple<'a> = ();
3529 #[doc(hidden)]
3530 type UnderlyingRustTuple<'a> = ();
3531 #[cfg(test)]
3532 #[allow(dead_code, unreachable_patterns)]
3533 fn _type_assertion(
3534 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3535 ) {
3536 match _t {
3537 alloy_sol_types::private::AssertTypeEq::<
3538 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3539 >(_) => {}
3540 }
3541 }
3542 #[automatically_derived]
3543 #[doc(hidden)]
3544 impl ::core::convert::From<EXECUTOR_ROLECall> for UnderlyingRustTuple<'_> {
3545 fn from(value: EXECUTOR_ROLECall) -> Self {
3546 ()
3547 }
3548 }
3549 #[automatically_derived]
3550 #[doc(hidden)]
3551 impl ::core::convert::From<UnderlyingRustTuple<'_>> for EXECUTOR_ROLECall {
3552 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3553 Self
3554 }
3555 }
3556 }
3557 {
3558 #[doc(hidden)]
3559 #[allow(dead_code)]
3560 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3561 #[doc(hidden)]
3562 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3563 #[cfg(test)]
3564 #[allow(dead_code, unreachable_patterns)]
3565 fn _type_assertion(
3566 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3567 ) {
3568 match _t {
3569 alloy_sol_types::private::AssertTypeEq::<
3570 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3571 >(_) => {}
3572 }
3573 }
3574 #[automatically_derived]
3575 #[doc(hidden)]
3576 impl ::core::convert::From<EXECUTOR_ROLEReturn> for UnderlyingRustTuple<'_> {
3577 fn from(value: EXECUTOR_ROLEReturn) -> Self {
3578 (value._0,)
3579 }
3580 }
3581 #[automatically_derived]
3582 #[doc(hidden)]
3583 impl ::core::convert::From<UnderlyingRustTuple<'_>> for EXECUTOR_ROLEReturn {
3584 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3585 Self { _0: tuple.0 }
3586 }
3587 }
3588 }
3589 #[automatically_derived]
3590 impl alloy_sol_types::SolCall for EXECUTOR_ROLECall {
3591 type Parameters<'a> = ();
3592 type Token<'a> = <Self::Parameters<
3593 'a,
3594 > as alloy_sol_types::SolType>::Token<'a>;
3595 type Return = alloy::sol_types::private::FixedBytes<32>;
3596 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3597 type ReturnToken<'a> = <Self::ReturnTuple<
3598 'a,
3599 > as alloy_sol_types::SolType>::Token<'a>;
3600 const SIGNATURE: &'static str = "EXECUTOR_ROLE()";
3601 const SELECTOR: [u8; 4] = [7u8, 189u8, 2u8, 101u8];
3602 #[inline]
3603 fn new<'a>(
3604 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3605 ) -> Self {
3606 tuple.into()
3607 }
3608 #[inline]
3609 fn tokenize(&self) -> Self::Token<'_> {
3610 ()
3611 }
3612 #[inline]
3613 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3614 (
3615 <alloy::sol_types::sol_data::FixedBytes<
3616 32,
3617 > as alloy_sol_types::SolType>::tokenize(ret),
3618 )
3619 }
3620 #[inline]
3621 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3622 <Self::ReturnTuple<
3623 '_,
3624 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3625 .map(|r| {
3626 let r: EXECUTOR_ROLEReturn = r.into();
3627 r._0
3628 })
3629 }
3630 #[inline]
3631 fn abi_decode_returns_validate(
3632 data: &[u8],
3633 ) -> alloy_sol_types::Result<Self::Return> {
3634 <Self::ReturnTuple<
3635 '_,
3636 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3637 .map(|r| {
3638 let r: EXECUTOR_ROLEReturn = r.into();
3639 r._0
3640 })
3641 }
3642 }
3643 };
3644 #[derive(serde::Serialize, serde::Deserialize)]
3645 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3646 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3651 #[derive(Clone)]
3652 pub struct PROPOSER_ROLECall;
3653 #[derive(serde::Serialize, serde::Deserialize)]
3654 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3655 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3657 #[derive(Clone)]
3658 pub struct PROPOSER_ROLEReturn {
3659 #[allow(missing_docs)]
3660 pub _0: alloy::sol_types::private::FixedBytes<32>,
3661 }
3662 #[allow(
3663 non_camel_case_types,
3664 non_snake_case,
3665 clippy::pub_underscore_fields,
3666 clippy::style
3667 )]
3668 const _: () = {
3669 use alloy::sol_types as alloy_sol_types;
3670 {
3671 #[doc(hidden)]
3672 #[allow(dead_code)]
3673 type UnderlyingSolTuple<'a> = ();
3674 #[doc(hidden)]
3675 type UnderlyingRustTuple<'a> = ();
3676 #[cfg(test)]
3677 #[allow(dead_code, unreachable_patterns)]
3678 fn _type_assertion(
3679 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3680 ) {
3681 match _t {
3682 alloy_sol_types::private::AssertTypeEq::<
3683 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3684 >(_) => {}
3685 }
3686 }
3687 #[automatically_derived]
3688 #[doc(hidden)]
3689 impl ::core::convert::From<PROPOSER_ROLECall> for UnderlyingRustTuple<'_> {
3690 fn from(value: PROPOSER_ROLECall) -> Self {
3691 ()
3692 }
3693 }
3694 #[automatically_derived]
3695 #[doc(hidden)]
3696 impl ::core::convert::From<UnderlyingRustTuple<'_>> for PROPOSER_ROLECall {
3697 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3698 Self
3699 }
3700 }
3701 }
3702 {
3703 #[doc(hidden)]
3704 #[allow(dead_code)]
3705 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3706 #[doc(hidden)]
3707 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3708 #[cfg(test)]
3709 #[allow(dead_code, unreachable_patterns)]
3710 fn _type_assertion(
3711 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3712 ) {
3713 match _t {
3714 alloy_sol_types::private::AssertTypeEq::<
3715 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3716 >(_) => {}
3717 }
3718 }
3719 #[automatically_derived]
3720 #[doc(hidden)]
3721 impl ::core::convert::From<PROPOSER_ROLEReturn> for UnderlyingRustTuple<'_> {
3722 fn from(value: PROPOSER_ROLEReturn) -> Self {
3723 (value._0,)
3724 }
3725 }
3726 #[automatically_derived]
3727 #[doc(hidden)]
3728 impl ::core::convert::From<UnderlyingRustTuple<'_>> for PROPOSER_ROLEReturn {
3729 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3730 Self { _0: tuple.0 }
3731 }
3732 }
3733 }
3734 #[automatically_derived]
3735 impl alloy_sol_types::SolCall for PROPOSER_ROLECall {
3736 type Parameters<'a> = ();
3737 type Token<'a> = <Self::Parameters<
3738 'a,
3739 > as alloy_sol_types::SolType>::Token<'a>;
3740 type Return = alloy::sol_types::private::FixedBytes<32>;
3741 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3742 type ReturnToken<'a> = <Self::ReturnTuple<
3743 'a,
3744 > as alloy_sol_types::SolType>::Token<'a>;
3745 const SIGNATURE: &'static str = "PROPOSER_ROLE()";
3746 const SELECTOR: [u8; 4] = [143u8, 97u8, 244u8, 245u8];
3747 #[inline]
3748 fn new<'a>(
3749 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3750 ) -> Self {
3751 tuple.into()
3752 }
3753 #[inline]
3754 fn tokenize(&self) -> Self::Token<'_> {
3755 ()
3756 }
3757 #[inline]
3758 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3759 (
3760 <alloy::sol_types::sol_data::FixedBytes<
3761 32,
3762 > as alloy_sol_types::SolType>::tokenize(ret),
3763 )
3764 }
3765 #[inline]
3766 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3767 <Self::ReturnTuple<
3768 '_,
3769 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3770 .map(|r| {
3771 let r: PROPOSER_ROLEReturn = r.into();
3772 r._0
3773 })
3774 }
3775 #[inline]
3776 fn abi_decode_returns_validate(
3777 data: &[u8],
3778 ) -> alloy_sol_types::Result<Self::Return> {
3779 <Self::ReturnTuple<
3780 '_,
3781 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3782 .map(|r| {
3783 let r: PROPOSER_ROLEReturn = r.into();
3784 r._0
3785 })
3786 }
3787 }
3788 };
3789 #[derive(serde::Serialize, serde::Deserialize)]
3790 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3791 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3796 #[derive(Clone)]
3797 pub struct cancelCall {
3798 #[allow(missing_docs)]
3799 pub id: alloy::sol_types::private::FixedBytes<32>,
3800 }
3801 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3803 #[derive(Clone)]
3804 pub struct cancelReturn {}
3805 #[allow(
3806 non_camel_case_types,
3807 non_snake_case,
3808 clippy::pub_underscore_fields,
3809 clippy::style
3810 )]
3811 const _: () = {
3812 use alloy::sol_types as alloy_sol_types;
3813 {
3814 #[doc(hidden)]
3815 #[allow(dead_code)]
3816 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3817 #[doc(hidden)]
3818 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3819 #[cfg(test)]
3820 #[allow(dead_code, unreachable_patterns)]
3821 fn _type_assertion(
3822 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3823 ) {
3824 match _t {
3825 alloy_sol_types::private::AssertTypeEq::<
3826 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3827 >(_) => {}
3828 }
3829 }
3830 #[automatically_derived]
3831 #[doc(hidden)]
3832 impl ::core::convert::From<cancelCall> for UnderlyingRustTuple<'_> {
3833 fn from(value: cancelCall) -> Self {
3834 (value.id,)
3835 }
3836 }
3837 #[automatically_derived]
3838 #[doc(hidden)]
3839 impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelCall {
3840 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3841 Self { id: tuple.0 }
3842 }
3843 }
3844 }
3845 {
3846 #[doc(hidden)]
3847 #[allow(dead_code)]
3848 type UnderlyingSolTuple<'a> = ();
3849 #[doc(hidden)]
3850 type UnderlyingRustTuple<'a> = ();
3851 #[cfg(test)]
3852 #[allow(dead_code, unreachable_patterns)]
3853 fn _type_assertion(
3854 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3855 ) {
3856 match _t {
3857 alloy_sol_types::private::AssertTypeEq::<
3858 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3859 >(_) => {}
3860 }
3861 }
3862 #[automatically_derived]
3863 #[doc(hidden)]
3864 impl ::core::convert::From<cancelReturn> for UnderlyingRustTuple<'_> {
3865 fn from(value: cancelReturn) -> Self {
3866 ()
3867 }
3868 }
3869 #[automatically_derived]
3870 #[doc(hidden)]
3871 impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelReturn {
3872 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3873 Self {}
3874 }
3875 }
3876 }
3877 impl cancelReturn {
3878 fn _tokenize(
3879 &self,
3880 ) -> <cancelCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3881 ()
3882 }
3883 }
3884 #[automatically_derived]
3885 impl alloy_sol_types::SolCall for cancelCall {
3886 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3887 type Token<'a> = <Self::Parameters<
3888 'a,
3889 > as alloy_sol_types::SolType>::Token<'a>;
3890 type Return = cancelReturn;
3891 type ReturnTuple<'a> = ();
3892 type ReturnToken<'a> = <Self::ReturnTuple<
3893 'a,
3894 > as alloy_sol_types::SolType>::Token<'a>;
3895 const SIGNATURE: &'static str = "cancel(bytes32)";
3896 const SELECTOR: [u8; 4] = [196u8, 210u8, 82u8, 245u8];
3897 #[inline]
3898 fn new<'a>(
3899 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3900 ) -> Self {
3901 tuple.into()
3902 }
3903 #[inline]
3904 fn tokenize(&self) -> Self::Token<'_> {
3905 (
3906 <alloy::sol_types::sol_data::FixedBytes<
3907 32,
3908 > as alloy_sol_types::SolType>::tokenize(&self.id),
3909 )
3910 }
3911 #[inline]
3912 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3913 cancelReturn::_tokenize(ret)
3914 }
3915 #[inline]
3916 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3917 <Self::ReturnTuple<
3918 '_,
3919 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3920 .map(Into::into)
3921 }
3922 #[inline]
3923 fn abi_decode_returns_validate(
3924 data: &[u8],
3925 ) -> alloy_sol_types::Result<Self::Return> {
3926 <Self::ReturnTuple<
3927 '_,
3928 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3929 .map(Into::into)
3930 }
3931 }
3932 };
3933 #[derive(serde::Serialize, serde::Deserialize)]
3934 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3935 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3940 #[derive(Clone)]
3941 pub struct executeCall {
3942 #[allow(missing_docs)]
3943 pub target: alloy::sol_types::private::Address,
3944 #[allow(missing_docs)]
3945 pub value: alloy::sol_types::private::primitives::aliases::U256,
3946 #[allow(missing_docs)]
3947 pub payload: alloy::sol_types::private::Bytes,
3948 #[allow(missing_docs)]
3949 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
3950 #[allow(missing_docs)]
3951 pub salt: alloy::sol_types::private::FixedBytes<32>,
3952 }
3953 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3955 #[derive(Clone)]
3956 pub struct executeReturn {}
3957 #[allow(
3958 non_camel_case_types,
3959 non_snake_case,
3960 clippy::pub_underscore_fields,
3961 clippy::style
3962 )]
3963 const _: () = {
3964 use alloy::sol_types as alloy_sol_types;
3965 {
3966 #[doc(hidden)]
3967 #[allow(dead_code)]
3968 type UnderlyingSolTuple<'a> = (
3969 alloy::sol_types::sol_data::Address,
3970 alloy::sol_types::sol_data::Uint<256>,
3971 alloy::sol_types::sol_data::Bytes,
3972 alloy::sol_types::sol_data::FixedBytes<32>,
3973 alloy::sol_types::sol_data::FixedBytes<32>,
3974 );
3975 #[doc(hidden)]
3976 type UnderlyingRustTuple<'a> = (
3977 alloy::sol_types::private::Address,
3978 alloy::sol_types::private::primitives::aliases::U256,
3979 alloy::sol_types::private::Bytes,
3980 alloy::sol_types::private::FixedBytes<32>,
3981 alloy::sol_types::private::FixedBytes<32>,
3982 );
3983 #[cfg(test)]
3984 #[allow(dead_code, unreachable_patterns)]
3985 fn _type_assertion(
3986 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3987 ) {
3988 match _t {
3989 alloy_sol_types::private::AssertTypeEq::<
3990 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3991 >(_) => {}
3992 }
3993 }
3994 #[automatically_derived]
3995 #[doc(hidden)]
3996 impl ::core::convert::From<executeCall> for UnderlyingRustTuple<'_> {
3997 fn from(value: executeCall) -> Self {
3998 (
3999 value.target,
4000 value.value,
4001 value.payload,
4002 value.predecessor,
4003 value.salt,
4004 )
4005 }
4006 }
4007 #[automatically_derived]
4008 #[doc(hidden)]
4009 impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeCall {
4010 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4011 Self {
4012 target: tuple.0,
4013 value: tuple.1,
4014 payload: tuple.2,
4015 predecessor: tuple.3,
4016 salt: tuple.4,
4017 }
4018 }
4019 }
4020 }
4021 {
4022 #[doc(hidden)]
4023 #[allow(dead_code)]
4024 type UnderlyingSolTuple<'a> = ();
4025 #[doc(hidden)]
4026 type UnderlyingRustTuple<'a> = ();
4027 #[cfg(test)]
4028 #[allow(dead_code, unreachable_patterns)]
4029 fn _type_assertion(
4030 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4031 ) {
4032 match _t {
4033 alloy_sol_types::private::AssertTypeEq::<
4034 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4035 >(_) => {}
4036 }
4037 }
4038 #[automatically_derived]
4039 #[doc(hidden)]
4040 impl ::core::convert::From<executeReturn> for UnderlyingRustTuple<'_> {
4041 fn from(value: executeReturn) -> Self {
4042 ()
4043 }
4044 }
4045 #[automatically_derived]
4046 #[doc(hidden)]
4047 impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeReturn {
4048 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4049 Self {}
4050 }
4051 }
4052 }
4053 impl executeReturn {
4054 fn _tokenize(
4055 &self,
4056 ) -> <executeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4057 ()
4058 }
4059 }
4060 #[automatically_derived]
4061 impl alloy_sol_types::SolCall for executeCall {
4062 type Parameters<'a> = (
4063 alloy::sol_types::sol_data::Address,
4064 alloy::sol_types::sol_data::Uint<256>,
4065 alloy::sol_types::sol_data::Bytes,
4066 alloy::sol_types::sol_data::FixedBytes<32>,
4067 alloy::sol_types::sol_data::FixedBytes<32>,
4068 );
4069 type Token<'a> = <Self::Parameters<
4070 'a,
4071 > as alloy_sol_types::SolType>::Token<'a>;
4072 type Return = executeReturn;
4073 type ReturnTuple<'a> = ();
4074 type ReturnToken<'a> = <Self::ReturnTuple<
4075 'a,
4076 > as alloy_sol_types::SolType>::Token<'a>;
4077 const SIGNATURE: &'static str = "execute(address,uint256,bytes,bytes32,bytes32)";
4078 const SELECTOR: [u8; 4] = [19u8, 64u8, 8u8, 211u8];
4079 #[inline]
4080 fn new<'a>(
4081 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4082 ) -> Self {
4083 tuple.into()
4084 }
4085 #[inline]
4086 fn tokenize(&self) -> Self::Token<'_> {
4087 (
4088 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4089 &self.target,
4090 ),
4091 <alloy::sol_types::sol_data::Uint<
4092 256,
4093 > as alloy_sol_types::SolType>::tokenize(&self.value),
4094 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
4095 &self.payload,
4096 ),
4097 <alloy::sol_types::sol_data::FixedBytes<
4098 32,
4099 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
4100 <alloy::sol_types::sol_data::FixedBytes<
4101 32,
4102 > as alloy_sol_types::SolType>::tokenize(&self.salt),
4103 )
4104 }
4105 #[inline]
4106 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4107 executeReturn::_tokenize(ret)
4108 }
4109 #[inline]
4110 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4111 <Self::ReturnTuple<
4112 '_,
4113 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4114 .map(Into::into)
4115 }
4116 #[inline]
4117 fn abi_decode_returns_validate(
4118 data: &[u8],
4119 ) -> alloy_sol_types::Result<Self::Return> {
4120 <Self::ReturnTuple<
4121 '_,
4122 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4123 .map(Into::into)
4124 }
4125 }
4126 };
4127 #[derive(serde::Serialize, serde::Deserialize)]
4128 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4129 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4134 #[derive(Clone)]
4135 pub struct executeBatchCall {
4136 #[allow(missing_docs)]
4137 pub targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
4138 #[allow(missing_docs)]
4139 pub values: alloy::sol_types::private::Vec<
4140 alloy::sol_types::private::primitives::aliases::U256,
4141 >,
4142 #[allow(missing_docs)]
4143 pub payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
4144 #[allow(missing_docs)]
4145 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
4146 #[allow(missing_docs)]
4147 pub salt: alloy::sol_types::private::FixedBytes<32>,
4148 }
4149 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4151 #[derive(Clone)]
4152 pub struct executeBatchReturn {}
4153 #[allow(
4154 non_camel_case_types,
4155 non_snake_case,
4156 clippy::pub_underscore_fields,
4157 clippy::style
4158 )]
4159 const _: () = {
4160 use alloy::sol_types as alloy_sol_types;
4161 {
4162 #[doc(hidden)]
4163 #[allow(dead_code)]
4164 type UnderlyingSolTuple<'a> = (
4165 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
4166 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
4167 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
4168 alloy::sol_types::sol_data::FixedBytes<32>,
4169 alloy::sol_types::sol_data::FixedBytes<32>,
4170 );
4171 #[doc(hidden)]
4172 type UnderlyingRustTuple<'a> = (
4173 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
4174 alloy::sol_types::private::Vec<
4175 alloy::sol_types::private::primitives::aliases::U256,
4176 >,
4177 alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
4178 alloy::sol_types::private::FixedBytes<32>,
4179 alloy::sol_types::private::FixedBytes<32>,
4180 );
4181 #[cfg(test)]
4182 #[allow(dead_code, unreachable_patterns)]
4183 fn _type_assertion(
4184 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4185 ) {
4186 match _t {
4187 alloy_sol_types::private::AssertTypeEq::<
4188 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4189 >(_) => {}
4190 }
4191 }
4192 #[automatically_derived]
4193 #[doc(hidden)]
4194 impl ::core::convert::From<executeBatchCall> for UnderlyingRustTuple<'_> {
4195 fn from(value: executeBatchCall) -> Self {
4196 (
4197 value.targets,
4198 value.values,
4199 value.payloads,
4200 value.predecessor,
4201 value.salt,
4202 )
4203 }
4204 }
4205 #[automatically_derived]
4206 #[doc(hidden)]
4207 impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeBatchCall {
4208 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4209 Self {
4210 targets: tuple.0,
4211 values: tuple.1,
4212 payloads: tuple.2,
4213 predecessor: tuple.3,
4214 salt: tuple.4,
4215 }
4216 }
4217 }
4218 }
4219 {
4220 #[doc(hidden)]
4221 #[allow(dead_code)]
4222 type UnderlyingSolTuple<'a> = ();
4223 #[doc(hidden)]
4224 type UnderlyingRustTuple<'a> = ();
4225 #[cfg(test)]
4226 #[allow(dead_code, unreachable_patterns)]
4227 fn _type_assertion(
4228 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4229 ) {
4230 match _t {
4231 alloy_sol_types::private::AssertTypeEq::<
4232 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4233 >(_) => {}
4234 }
4235 }
4236 #[automatically_derived]
4237 #[doc(hidden)]
4238 impl ::core::convert::From<executeBatchReturn> for UnderlyingRustTuple<'_> {
4239 fn from(value: executeBatchReturn) -> Self {
4240 ()
4241 }
4242 }
4243 #[automatically_derived]
4244 #[doc(hidden)]
4245 impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeBatchReturn {
4246 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4247 Self {}
4248 }
4249 }
4250 }
4251 impl executeBatchReturn {
4252 fn _tokenize(
4253 &self,
4254 ) -> <executeBatchCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4255 ()
4256 }
4257 }
4258 #[automatically_derived]
4259 impl alloy_sol_types::SolCall for executeBatchCall {
4260 type Parameters<'a> = (
4261 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
4262 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
4263 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
4264 alloy::sol_types::sol_data::FixedBytes<32>,
4265 alloy::sol_types::sol_data::FixedBytes<32>,
4266 );
4267 type Token<'a> = <Self::Parameters<
4268 'a,
4269 > as alloy_sol_types::SolType>::Token<'a>;
4270 type Return = executeBatchReturn;
4271 type ReturnTuple<'a> = ();
4272 type ReturnToken<'a> = <Self::ReturnTuple<
4273 'a,
4274 > as alloy_sol_types::SolType>::Token<'a>;
4275 const SIGNATURE: &'static str = "executeBatch(address[],uint256[],bytes[],bytes32,bytes32)";
4276 const SELECTOR: [u8; 4] = [227u8, 131u8, 53u8, 229u8];
4277 #[inline]
4278 fn new<'a>(
4279 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4280 ) -> Self {
4281 tuple.into()
4282 }
4283 #[inline]
4284 fn tokenize(&self) -> Self::Token<'_> {
4285 (
4286 <alloy::sol_types::sol_data::Array<
4287 alloy::sol_types::sol_data::Address,
4288 > as alloy_sol_types::SolType>::tokenize(&self.targets),
4289 <alloy::sol_types::sol_data::Array<
4290 alloy::sol_types::sol_data::Uint<256>,
4291 > as alloy_sol_types::SolType>::tokenize(&self.values),
4292 <alloy::sol_types::sol_data::Array<
4293 alloy::sol_types::sol_data::Bytes,
4294 > as alloy_sol_types::SolType>::tokenize(&self.payloads),
4295 <alloy::sol_types::sol_data::FixedBytes<
4296 32,
4297 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
4298 <alloy::sol_types::sol_data::FixedBytes<
4299 32,
4300 > as alloy_sol_types::SolType>::tokenize(&self.salt),
4301 )
4302 }
4303 #[inline]
4304 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4305 executeBatchReturn::_tokenize(ret)
4306 }
4307 #[inline]
4308 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4309 <Self::ReturnTuple<
4310 '_,
4311 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4312 .map(Into::into)
4313 }
4314 #[inline]
4315 fn abi_decode_returns_validate(
4316 data: &[u8],
4317 ) -> alloy_sol_types::Result<Self::Return> {
4318 <Self::ReturnTuple<
4319 '_,
4320 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4321 .map(Into::into)
4322 }
4323 }
4324 };
4325 #[derive(serde::Serialize, serde::Deserialize)]
4326 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4327 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4332 #[derive(Clone)]
4333 pub struct getMinDelayCall;
4334 #[derive(serde::Serialize, serde::Deserialize)]
4335 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4336 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4338 #[derive(Clone)]
4339 pub struct getMinDelayReturn {
4340 #[allow(missing_docs)]
4341 pub _0: alloy::sol_types::private::primitives::aliases::U256,
4342 }
4343 #[allow(
4344 non_camel_case_types,
4345 non_snake_case,
4346 clippy::pub_underscore_fields,
4347 clippy::style
4348 )]
4349 const _: () = {
4350 use alloy::sol_types as alloy_sol_types;
4351 {
4352 #[doc(hidden)]
4353 #[allow(dead_code)]
4354 type UnderlyingSolTuple<'a> = ();
4355 #[doc(hidden)]
4356 type UnderlyingRustTuple<'a> = ();
4357 #[cfg(test)]
4358 #[allow(dead_code, unreachable_patterns)]
4359 fn _type_assertion(
4360 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4361 ) {
4362 match _t {
4363 alloy_sol_types::private::AssertTypeEq::<
4364 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4365 >(_) => {}
4366 }
4367 }
4368 #[automatically_derived]
4369 #[doc(hidden)]
4370 impl ::core::convert::From<getMinDelayCall> for UnderlyingRustTuple<'_> {
4371 fn from(value: getMinDelayCall) -> Self {
4372 ()
4373 }
4374 }
4375 #[automatically_derived]
4376 #[doc(hidden)]
4377 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMinDelayCall {
4378 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4379 Self
4380 }
4381 }
4382 }
4383 {
4384 #[doc(hidden)]
4385 #[allow(dead_code)]
4386 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4387 #[doc(hidden)]
4388 type UnderlyingRustTuple<'a> = (
4389 alloy::sol_types::private::primitives::aliases::U256,
4390 );
4391 #[cfg(test)]
4392 #[allow(dead_code, unreachable_patterns)]
4393 fn _type_assertion(
4394 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4395 ) {
4396 match _t {
4397 alloy_sol_types::private::AssertTypeEq::<
4398 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4399 >(_) => {}
4400 }
4401 }
4402 #[automatically_derived]
4403 #[doc(hidden)]
4404 impl ::core::convert::From<getMinDelayReturn> for UnderlyingRustTuple<'_> {
4405 fn from(value: getMinDelayReturn) -> Self {
4406 (value._0,)
4407 }
4408 }
4409 #[automatically_derived]
4410 #[doc(hidden)]
4411 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMinDelayReturn {
4412 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4413 Self { _0: tuple.0 }
4414 }
4415 }
4416 }
4417 #[automatically_derived]
4418 impl alloy_sol_types::SolCall for getMinDelayCall {
4419 type Parameters<'a> = ();
4420 type Token<'a> = <Self::Parameters<
4421 'a,
4422 > as alloy_sol_types::SolType>::Token<'a>;
4423 type Return = alloy::sol_types::private::primitives::aliases::U256;
4424 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4425 type ReturnToken<'a> = <Self::ReturnTuple<
4426 'a,
4427 > as alloy_sol_types::SolType>::Token<'a>;
4428 const SIGNATURE: &'static str = "getMinDelay()";
4429 const SELECTOR: [u8; 4] = [242u8, 122u8, 12u8, 146u8];
4430 #[inline]
4431 fn new<'a>(
4432 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4433 ) -> Self {
4434 tuple.into()
4435 }
4436 #[inline]
4437 fn tokenize(&self) -> Self::Token<'_> {
4438 ()
4439 }
4440 #[inline]
4441 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4442 (
4443 <alloy::sol_types::sol_data::Uint<
4444 256,
4445 > as alloy_sol_types::SolType>::tokenize(ret),
4446 )
4447 }
4448 #[inline]
4449 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4450 <Self::ReturnTuple<
4451 '_,
4452 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4453 .map(|r| {
4454 let r: getMinDelayReturn = r.into();
4455 r._0
4456 })
4457 }
4458 #[inline]
4459 fn abi_decode_returns_validate(
4460 data: &[u8],
4461 ) -> alloy_sol_types::Result<Self::Return> {
4462 <Self::ReturnTuple<
4463 '_,
4464 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4465 .map(|r| {
4466 let r: getMinDelayReturn = r.into();
4467 r._0
4468 })
4469 }
4470 }
4471 };
4472 #[derive(serde::Serialize, serde::Deserialize)]
4473 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4474 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4479 #[derive(Clone)]
4480 pub struct getOperationStateCall {
4481 #[allow(missing_docs)]
4482 pub id: alloy::sol_types::private::FixedBytes<32>,
4483 }
4484 #[derive(serde::Serialize, serde::Deserialize)]
4485 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4486 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4488 #[derive(Clone)]
4489 pub struct getOperationStateReturn {
4490 #[allow(missing_docs)]
4491 pub _0: <TimelockController::OperationState as alloy::sol_types::SolType>::RustType,
4492 }
4493 #[allow(
4494 non_camel_case_types,
4495 non_snake_case,
4496 clippy::pub_underscore_fields,
4497 clippy::style
4498 )]
4499 const _: () = {
4500 use alloy::sol_types as alloy_sol_types;
4501 {
4502 #[doc(hidden)]
4503 #[allow(dead_code)]
4504 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4505 #[doc(hidden)]
4506 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
4507 #[cfg(test)]
4508 #[allow(dead_code, unreachable_patterns)]
4509 fn _type_assertion(
4510 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4511 ) {
4512 match _t {
4513 alloy_sol_types::private::AssertTypeEq::<
4514 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4515 >(_) => {}
4516 }
4517 }
4518 #[automatically_derived]
4519 #[doc(hidden)]
4520 impl ::core::convert::From<getOperationStateCall>
4521 for UnderlyingRustTuple<'_> {
4522 fn from(value: getOperationStateCall) -> Self {
4523 (value.id,)
4524 }
4525 }
4526 #[automatically_derived]
4527 #[doc(hidden)]
4528 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4529 for getOperationStateCall {
4530 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4531 Self { id: tuple.0 }
4532 }
4533 }
4534 }
4535 {
4536 #[doc(hidden)]
4537 #[allow(dead_code)]
4538 type UnderlyingSolTuple<'a> = (TimelockController::OperationState,);
4539 #[doc(hidden)]
4540 type UnderlyingRustTuple<'a> = (
4541 <TimelockController::OperationState as alloy::sol_types::SolType>::RustType,
4542 );
4543 #[cfg(test)]
4544 #[allow(dead_code, unreachable_patterns)]
4545 fn _type_assertion(
4546 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4547 ) {
4548 match _t {
4549 alloy_sol_types::private::AssertTypeEq::<
4550 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4551 >(_) => {}
4552 }
4553 }
4554 #[automatically_derived]
4555 #[doc(hidden)]
4556 impl ::core::convert::From<getOperationStateReturn>
4557 for UnderlyingRustTuple<'_> {
4558 fn from(value: getOperationStateReturn) -> Self {
4559 (value._0,)
4560 }
4561 }
4562 #[automatically_derived]
4563 #[doc(hidden)]
4564 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4565 for getOperationStateReturn {
4566 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4567 Self { _0: tuple.0 }
4568 }
4569 }
4570 }
4571 #[automatically_derived]
4572 impl alloy_sol_types::SolCall for getOperationStateCall {
4573 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4574 type Token<'a> = <Self::Parameters<
4575 'a,
4576 > as alloy_sol_types::SolType>::Token<'a>;
4577 type Return = <TimelockController::OperationState as alloy::sol_types::SolType>::RustType;
4578 type ReturnTuple<'a> = (TimelockController::OperationState,);
4579 type ReturnToken<'a> = <Self::ReturnTuple<
4580 'a,
4581 > as alloy_sol_types::SolType>::Token<'a>;
4582 const SIGNATURE: &'static str = "getOperationState(bytes32)";
4583 const SELECTOR: [u8; 4] = [121u8, 88u8, 0u8, 76u8];
4584 #[inline]
4585 fn new<'a>(
4586 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4587 ) -> Self {
4588 tuple.into()
4589 }
4590 #[inline]
4591 fn tokenize(&self) -> Self::Token<'_> {
4592 (
4593 <alloy::sol_types::sol_data::FixedBytes<
4594 32,
4595 > as alloy_sol_types::SolType>::tokenize(&self.id),
4596 )
4597 }
4598 #[inline]
4599 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4600 (
4601 <TimelockController::OperationState as alloy_sol_types::SolType>::tokenize(
4602 ret,
4603 ),
4604 )
4605 }
4606 #[inline]
4607 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4608 <Self::ReturnTuple<
4609 '_,
4610 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4611 .map(|r| {
4612 let r: getOperationStateReturn = r.into();
4613 r._0
4614 })
4615 }
4616 #[inline]
4617 fn abi_decode_returns_validate(
4618 data: &[u8],
4619 ) -> alloy_sol_types::Result<Self::Return> {
4620 <Self::ReturnTuple<
4621 '_,
4622 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4623 .map(|r| {
4624 let r: getOperationStateReturn = r.into();
4625 r._0
4626 })
4627 }
4628 }
4629 };
4630 #[derive(serde::Serialize, serde::Deserialize)]
4631 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4632 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4637 #[derive(Clone)]
4638 pub struct getRoleAdminCall {
4639 #[allow(missing_docs)]
4640 pub role: alloy::sol_types::private::FixedBytes<32>,
4641 }
4642 #[derive(serde::Serialize, serde::Deserialize)]
4643 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4644 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4646 #[derive(Clone)]
4647 pub struct getRoleAdminReturn {
4648 #[allow(missing_docs)]
4649 pub _0: alloy::sol_types::private::FixedBytes<32>,
4650 }
4651 #[allow(
4652 non_camel_case_types,
4653 non_snake_case,
4654 clippy::pub_underscore_fields,
4655 clippy::style
4656 )]
4657 const _: () = {
4658 use alloy::sol_types as alloy_sol_types;
4659 {
4660 #[doc(hidden)]
4661 #[allow(dead_code)]
4662 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4663 #[doc(hidden)]
4664 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
4665 #[cfg(test)]
4666 #[allow(dead_code, unreachable_patterns)]
4667 fn _type_assertion(
4668 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4669 ) {
4670 match _t {
4671 alloy_sol_types::private::AssertTypeEq::<
4672 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4673 >(_) => {}
4674 }
4675 }
4676 #[automatically_derived]
4677 #[doc(hidden)]
4678 impl ::core::convert::From<getRoleAdminCall> for UnderlyingRustTuple<'_> {
4679 fn from(value: getRoleAdminCall) -> Self {
4680 (value.role,)
4681 }
4682 }
4683 #[automatically_derived]
4684 #[doc(hidden)]
4685 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminCall {
4686 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4687 Self { role: tuple.0 }
4688 }
4689 }
4690 }
4691 {
4692 #[doc(hidden)]
4693 #[allow(dead_code)]
4694 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4695 #[doc(hidden)]
4696 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
4697 #[cfg(test)]
4698 #[allow(dead_code, unreachable_patterns)]
4699 fn _type_assertion(
4700 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4701 ) {
4702 match _t {
4703 alloy_sol_types::private::AssertTypeEq::<
4704 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4705 >(_) => {}
4706 }
4707 }
4708 #[automatically_derived]
4709 #[doc(hidden)]
4710 impl ::core::convert::From<getRoleAdminReturn> for UnderlyingRustTuple<'_> {
4711 fn from(value: getRoleAdminReturn) -> Self {
4712 (value._0,)
4713 }
4714 }
4715 #[automatically_derived]
4716 #[doc(hidden)]
4717 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminReturn {
4718 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4719 Self { _0: tuple.0 }
4720 }
4721 }
4722 }
4723 #[automatically_derived]
4724 impl alloy_sol_types::SolCall for getRoleAdminCall {
4725 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4726 type Token<'a> = <Self::Parameters<
4727 'a,
4728 > as alloy_sol_types::SolType>::Token<'a>;
4729 type Return = alloy::sol_types::private::FixedBytes<32>;
4730 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4731 type ReturnToken<'a> = <Self::ReturnTuple<
4732 'a,
4733 > as alloy_sol_types::SolType>::Token<'a>;
4734 const SIGNATURE: &'static str = "getRoleAdmin(bytes32)";
4735 const SELECTOR: [u8; 4] = [36u8, 138u8, 156u8, 163u8];
4736 #[inline]
4737 fn new<'a>(
4738 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4739 ) -> Self {
4740 tuple.into()
4741 }
4742 #[inline]
4743 fn tokenize(&self) -> Self::Token<'_> {
4744 (
4745 <alloy::sol_types::sol_data::FixedBytes<
4746 32,
4747 > as alloy_sol_types::SolType>::tokenize(&self.role),
4748 )
4749 }
4750 #[inline]
4751 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4752 (
4753 <alloy::sol_types::sol_data::FixedBytes<
4754 32,
4755 > as alloy_sol_types::SolType>::tokenize(ret),
4756 )
4757 }
4758 #[inline]
4759 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4760 <Self::ReturnTuple<
4761 '_,
4762 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4763 .map(|r| {
4764 let r: getRoleAdminReturn = r.into();
4765 r._0
4766 })
4767 }
4768 #[inline]
4769 fn abi_decode_returns_validate(
4770 data: &[u8],
4771 ) -> alloy_sol_types::Result<Self::Return> {
4772 <Self::ReturnTuple<
4773 '_,
4774 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4775 .map(|r| {
4776 let r: getRoleAdminReturn = r.into();
4777 r._0
4778 })
4779 }
4780 }
4781 };
4782 #[derive(serde::Serialize, serde::Deserialize)]
4783 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4784 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4789 #[derive(Clone)]
4790 pub struct getTimestampCall {
4791 #[allow(missing_docs)]
4792 pub id: alloy::sol_types::private::FixedBytes<32>,
4793 }
4794 #[derive(serde::Serialize, serde::Deserialize)]
4795 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4796 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4798 #[derive(Clone)]
4799 pub struct getTimestampReturn {
4800 #[allow(missing_docs)]
4801 pub _0: alloy::sol_types::private::primitives::aliases::U256,
4802 }
4803 #[allow(
4804 non_camel_case_types,
4805 non_snake_case,
4806 clippy::pub_underscore_fields,
4807 clippy::style
4808 )]
4809 const _: () = {
4810 use alloy::sol_types as alloy_sol_types;
4811 {
4812 #[doc(hidden)]
4813 #[allow(dead_code)]
4814 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4815 #[doc(hidden)]
4816 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
4817 #[cfg(test)]
4818 #[allow(dead_code, unreachable_patterns)]
4819 fn _type_assertion(
4820 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4821 ) {
4822 match _t {
4823 alloy_sol_types::private::AssertTypeEq::<
4824 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4825 >(_) => {}
4826 }
4827 }
4828 #[automatically_derived]
4829 #[doc(hidden)]
4830 impl ::core::convert::From<getTimestampCall> for UnderlyingRustTuple<'_> {
4831 fn from(value: getTimestampCall) -> Self {
4832 (value.id,)
4833 }
4834 }
4835 #[automatically_derived]
4836 #[doc(hidden)]
4837 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTimestampCall {
4838 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4839 Self { id: tuple.0 }
4840 }
4841 }
4842 }
4843 {
4844 #[doc(hidden)]
4845 #[allow(dead_code)]
4846 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4847 #[doc(hidden)]
4848 type UnderlyingRustTuple<'a> = (
4849 alloy::sol_types::private::primitives::aliases::U256,
4850 );
4851 #[cfg(test)]
4852 #[allow(dead_code, unreachable_patterns)]
4853 fn _type_assertion(
4854 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4855 ) {
4856 match _t {
4857 alloy_sol_types::private::AssertTypeEq::<
4858 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4859 >(_) => {}
4860 }
4861 }
4862 #[automatically_derived]
4863 #[doc(hidden)]
4864 impl ::core::convert::From<getTimestampReturn> for UnderlyingRustTuple<'_> {
4865 fn from(value: getTimestampReturn) -> Self {
4866 (value._0,)
4867 }
4868 }
4869 #[automatically_derived]
4870 #[doc(hidden)]
4871 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTimestampReturn {
4872 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4873 Self { _0: tuple.0 }
4874 }
4875 }
4876 }
4877 #[automatically_derived]
4878 impl alloy_sol_types::SolCall for getTimestampCall {
4879 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4880 type Token<'a> = <Self::Parameters<
4881 'a,
4882 > as alloy_sol_types::SolType>::Token<'a>;
4883 type Return = alloy::sol_types::private::primitives::aliases::U256;
4884 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4885 type ReturnToken<'a> = <Self::ReturnTuple<
4886 'a,
4887 > as alloy_sol_types::SolType>::Token<'a>;
4888 const SIGNATURE: &'static str = "getTimestamp(bytes32)";
4889 const SELECTOR: [u8; 4] = [212u8, 92u8, 68u8, 53u8];
4890 #[inline]
4891 fn new<'a>(
4892 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4893 ) -> Self {
4894 tuple.into()
4895 }
4896 #[inline]
4897 fn tokenize(&self) -> Self::Token<'_> {
4898 (
4899 <alloy::sol_types::sol_data::FixedBytes<
4900 32,
4901 > as alloy_sol_types::SolType>::tokenize(&self.id),
4902 )
4903 }
4904 #[inline]
4905 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4906 (
4907 <alloy::sol_types::sol_data::Uint<
4908 256,
4909 > as alloy_sol_types::SolType>::tokenize(ret),
4910 )
4911 }
4912 #[inline]
4913 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4914 <Self::ReturnTuple<
4915 '_,
4916 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4917 .map(|r| {
4918 let r: getTimestampReturn = r.into();
4919 r._0
4920 })
4921 }
4922 #[inline]
4923 fn abi_decode_returns_validate(
4924 data: &[u8],
4925 ) -> alloy_sol_types::Result<Self::Return> {
4926 <Self::ReturnTuple<
4927 '_,
4928 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4929 .map(|r| {
4930 let r: getTimestampReturn = r.into();
4931 r._0
4932 })
4933 }
4934 }
4935 };
4936 #[derive(serde::Serialize, serde::Deserialize)]
4937 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4938 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4943 #[derive(Clone)]
4944 pub struct grantRoleCall {
4945 #[allow(missing_docs)]
4946 pub role: alloy::sol_types::private::FixedBytes<32>,
4947 #[allow(missing_docs)]
4948 pub account: alloy::sol_types::private::Address,
4949 }
4950 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4952 #[derive(Clone)]
4953 pub struct grantRoleReturn {}
4954 #[allow(
4955 non_camel_case_types,
4956 non_snake_case,
4957 clippy::pub_underscore_fields,
4958 clippy::style
4959 )]
4960 const _: () = {
4961 use alloy::sol_types as alloy_sol_types;
4962 {
4963 #[doc(hidden)]
4964 #[allow(dead_code)]
4965 type UnderlyingSolTuple<'a> = (
4966 alloy::sol_types::sol_data::FixedBytes<32>,
4967 alloy::sol_types::sol_data::Address,
4968 );
4969 #[doc(hidden)]
4970 type UnderlyingRustTuple<'a> = (
4971 alloy::sol_types::private::FixedBytes<32>,
4972 alloy::sol_types::private::Address,
4973 );
4974 #[cfg(test)]
4975 #[allow(dead_code, unreachable_patterns)]
4976 fn _type_assertion(
4977 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4978 ) {
4979 match _t {
4980 alloy_sol_types::private::AssertTypeEq::<
4981 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4982 >(_) => {}
4983 }
4984 }
4985 #[automatically_derived]
4986 #[doc(hidden)]
4987 impl ::core::convert::From<grantRoleCall> for UnderlyingRustTuple<'_> {
4988 fn from(value: grantRoleCall) -> Self {
4989 (value.role, value.account)
4990 }
4991 }
4992 #[automatically_derived]
4993 #[doc(hidden)]
4994 impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleCall {
4995 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4996 Self {
4997 role: tuple.0,
4998 account: tuple.1,
4999 }
5000 }
5001 }
5002 }
5003 {
5004 #[doc(hidden)]
5005 #[allow(dead_code)]
5006 type UnderlyingSolTuple<'a> = ();
5007 #[doc(hidden)]
5008 type UnderlyingRustTuple<'a> = ();
5009 #[cfg(test)]
5010 #[allow(dead_code, unreachable_patterns)]
5011 fn _type_assertion(
5012 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5013 ) {
5014 match _t {
5015 alloy_sol_types::private::AssertTypeEq::<
5016 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5017 >(_) => {}
5018 }
5019 }
5020 #[automatically_derived]
5021 #[doc(hidden)]
5022 impl ::core::convert::From<grantRoleReturn> for UnderlyingRustTuple<'_> {
5023 fn from(value: grantRoleReturn) -> Self {
5024 ()
5025 }
5026 }
5027 #[automatically_derived]
5028 #[doc(hidden)]
5029 impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleReturn {
5030 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5031 Self {}
5032 }
5033 }
5034 }
5035 impl grantRoleReturn {
5036 fn _tokenize(
5037 &self,
5038 ) -> <grantRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
5039 ()
5040 }
5041 }
5042 #[automatically_derived]
5043 impl alloy_sol_types::SolCall for grantRoleCall {
5044 type Parameters<'a> = (
5045 alloy::sol_types::sol_data::FixedBytes<32>,
5046 alloy::sol_types::sol_data::Address,
5047 );
5048 type Token<'a> = <Self::Parameters<
5049 'a,
5050 > as alloy_sol_types::SolType>::Token<'a>;
5051 type Return = grantRoleReturn;
5052 type ReturnTuple<'a> = ();
5053 type ReturnToken<'a> = <Self::ReturnTuple<
5054 'a,
5055 > as alloy_sol_types::SolType>::Token<'a>;
5056 const SIGNATURE: &'static str = "grantRole(bytes32,address)";
5057 const SELECTOR: [u8; 4] = [47u8, 47u8, 241u8, 93u8];
5058 #[inline]
5059 fn new<'a>(
5060 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5061 ) -> Self {
5062 tuple.into()
5063 }
5064 #[inline]
5065 fn tokenize(&self) -> Self::Token<'_> {
5066 (
5067 <alloy::sol_types::sol_data::FixedBytes<
5068 32,
5069 > as alloy_sol_types::SolType>::tokenize(&self.role),
5070 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5071 &self.account,
5072 ),
5073 )
5074 }
5075 #[inline]
5076 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5077 grantRoleReturn::_tokenize(ret)
5078 }
5079 #[inline]
5080 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5081 <Self::ReturnTuple<
5082 '_,
5083 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5084 .map(Into::into)
5085 }
5086 #[inline]
5087 fn abi_decode_returns_validate(
5088 data: &[u8],
5089 ) -> alloy_sol_types::Result<Self::Return> {
5090 <Self::ReturnTuple<
5091 '_,
5092 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5093 .map(Into::into)
5094 }
5095 }
5096 };
5097 #[derive(serde::Serialize, serde::Deserialize)]
5098 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5099 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5104 #[derive(Clone)]
5105 pub struct hasRoleCall {
5106 #[allow(missing_docs)]
5107 pub role: alloy::sol_types::private::FixedBytes<32>,
5108 #[allow(missing_docs)]
5109 pub account: alloy::sol_types::private::Address,
5110 }
5111 #[derive(serde::Serialize, serde::Deserialize)]
5112 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5113 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5115 #[derive(Clone)]
5116 pub struct hasRoleReturn {
5117 #[allow(missing_docs)]
5118 pub _0: bool,
5119 }
5120 #[allow(
5121 non_camel_case_types,
5122 non_snake_case,
5123 clippy::pub_underscore_fields,
5124 clippy::style
5125 )]
5126 const _: () = {
5127 use alloy::sol_types as alloy_sol_types;
5128 {
5129 #[doc(hidden)]
5130 #[allow(dead_code)]
5131 type UnderlyingSolTuple<'a> = (
5132 alloy::sol_types::sol_data::FixedBytes<32>,
5133 alloy::sol_types::sol_data::Address,
5134 );
5135 #[doc(hidden)]
5136 type UnderlyingRustTuple<'a> = (
5137 alloy::sol_types::private::FixedBytes<32>,
5138 alloy::sol_types::private::Address,
5139 );
5140 #[cfg(test)]
5141 #[allow(dead_code, unreachable_patterns)]
5142 fn _type_assertion(
5143 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5144 ) {
5145 match _t {
5146 alloy_sol_types::private::AssertTypeEq::<
5147 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5148 >(_) => {}
5149 }
5150 }
5151 #[automatically_derived]
5152 #[doc(hidden)]
5153 impl ::core::convert::From<hasRoleCall> for UnderlyingRustTuple<'_> {
5154 fn from(value: hasRoleCall) -> Self {
5155 (value.role, value.account)
5156 }
5157 }
5158 #[automatically_derived]
5159 #[doc(hidden)]
5160 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleCall {
5161 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5162 Self {
5163 role: tuple.0,
5164 account: tuple.1,
5165 }
5166 }
5167 }
5168 }
5169 {
5170 #[doc(hidden)]
5171 #[allow(dead_code)]
5172 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5173 #[doc(hidden)]
5174 type UnderlyingRustTuple<'a> = (bool,);
5175 #[cfg(test)]
5176 #[allow(dead_code, unreachable_patterns)]
5177 fn _type_assertion(
5178 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5179 ) {
5180 match _t {
5181 alloy_sol_types::private::AssertTypeEq::<
5182 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5183 >(_) => {}
5184 }
5185 }
5186 #[automatically_derived]
5187 #[doc(hidden)]
5188 impl ::core::convert::From<hasRoleReturn> for UnderlyingRustTuple<'_> {
5189 fn from(value: hasRoleReturn) -> Self {
5190 (value._0,)
5191 }
5192 }
5193 #[automatically_derived]
5194 #[doc(hidden)]
5195 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleReturn {
5196 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5197 Self { _0: tuple.0 }
5198 }
5199 }
5200 }
5201 #[automatically_derived]
5202 impl alloy_sol_types::SolCall for hasRoleCall {
5203 type Parameters<'a> = (
5204 alloy::sol_types::sol_data::FixedBytes<32>,
5205 alloy::sol_types::sol_data::Address,
5206 );
5207 type Token<'a> = <Self::Parameters<
5208 'a,
5209 > as alloy_sol_types::SolType>::Token<'a>;
5210 type Return = bool;
5211 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5212 type ReturnToken<'a> = <Self::ReturnTuple<
5213 'a,
5214 > as alloy_sol_types::SolType>::Token<'a>;
5215 const SIGNATURE: &'static str = "hasRole(bytes32,address)";
5216 const SELECTOR: [u8; 4] = [145u8, 209u8, 72u8, 84u8];
5217 #[inline]
5218 fn new<'a>(
5219 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5220 ) -> Self {
5221 tuple.into()
5222 }
5223 #[inline]
5224 fn tokenize(&self) -> Self::Token<'_> {
5225 (
5226 <alloy::sol_types::sol_data::FixedBytes<
5227 32,
5228 > as alloy_sol_types::SolType>::tokenize(&self.role),
5229 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5230 &self.account,
5231 ),
5232 )
5233 }
5234 #[inline]
5235 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5236 (
5237 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
5238 ret,
5239 ),
5240 )
5241 }
5242 #[inline]
5243 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5244 <Self::ReturnTuple<
5245 '_,
5246 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5247 .map(|r| {
5248 let r: hasRoleReturn = r.into();
5249 r._0
5250 })
5251 }
5252 #[inline]
5253 fn abi_decode_returns_validate(
5254 data: &[u8],
5255 ) -> alloy_sol_types::Result<Self::Return> {
5256 <Self::ReturnTuple<
5257 '_,
5258 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5259 .map(|r| {
5260 let r: hasRoleReturn = r.into();
5261 r._0
5262 })
5263 }
5264 }
5265 };
5266 #[derive(serde::Serialize, serde::Deserialize)]
5267 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5268 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5273 #[derive(Clone)]
5274 pub struct hashOperationCall {
5275 #[allow(missing_docs)]
5276 pub target: alloy::sol_types::private::Address,
5277 #[allow(missing_docs)]
5278 pub value: alloy::sol_types::private::primitives::aliases::U256,
5279 #[allow(missing_docs)]
5280 pub data: alloy::sol_types::private::Bytes,
5281 #[allow(missing_docs)]
5282 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
5283 #[allow(missing_docs)]
5284 pub salt: alloy::sol_types::private::FixedBytes<32>,
5285 }
5286 #[derive(serde::Serialize, serde::Deserialize)]
5287 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5288 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5290 #[derive(Clone)]
5291 pub struct hashOperationReturn {
5292 #[allow(missing_docs)]
5293 pub _0: alloy::sol_types::private::FixedBytes<32>,
5294 }
5295 #[allow(
5296 non_camel_case_types,
5297 non_snake_case,
5298 clippy::pub_underscore_fields,
5299 clippy::style
5300 )]
5301 const _: () = {
5302 use alloy::sol_types as alloy_sol_types;
5303 {
5304 #[doc(hidden)]
5305 #[allow(dead_code)]
5306 type UnderlyingSolTuple<'a> = (
5307 alloy::sol_types::sol_data::Address,
5308 alloy::sol_types::sol_data::Uint<256>,
5309 alloy::sol_types::sol_data::Bytes,
5310 alloy::sol_types::sol_data::FixedBytes<32>,
5311 alloy::sol_types::sol_data::FixedBytes<32>,
5312 );
5313 #[doc(hidden)]
5314 type UnderlyingRustTuple<'a> = (
5315 alloy::sol_types::private::Address,
5316 alloy::sol_types::private::primitives::aliases::U256,
5317 alloy::sol_types::private::Bytes,
5318 alloy::sol_types::private::FixedBytes<32>,
5319 alloy::sol_types::private::FixedBytes<32>,
5320 );
5321 #[cfg(test)]
5322 #[allow(dead_code, unreachable_patterns)]
5323 fn _type_assertion(
5324 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5325 ) {
5326 match _t {
5327 alloy_sol_types::private::AssertTypeEq::<
5328 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5329 >(_) => {}
5330 }
5331 }
5332 #[automatically_derived]
5333 #[doc(hidden)]
5334 impl ::core::convert::From<hashOperationCall> for UnderlyingRustTuple<'_> {
5335 fn from(value: hashOperationCall) -> Self {
5336 (
5337 value.target,
5338 value.value,
5339 value.data,
5340 value.predecessor,
5341 value.salt,
5342 )
5343 }
5344 }
5345 #[automatically_derived]
5346 #[doc(hidden)]
5347 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashOperationCall {
5348 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5349 Self {
5350 target: tuple.0,
5351 value: tuple.1,
5352 data: tuple.2,
5353 predecessor: tuple.3,
5354 salt: tuple.4,
5355 }
5356 }
5357 }
5358 }
5359 {
5360 #[doc(hidden)]
5361 #[allow(dead_code)]
5362 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5363 #[doc(hidden)]
5364 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
5365 #[cfg(test)]
5366 #[allow(dead_code, unreachable_patterns)]
5367 fn _type_assertion(
5368 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5369 ) {
5370 match _t {
5371 alloy_sol_types::private::AssertTypeEq::<
5372 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5373 >(_) => {}
5374 }
5375 }
5376 #[automatically_derived]
5377 #[doc(hidden)]
5378 impl ::core::convert::From<hashOperationReturn> for UnderlyingRustTuple<'_> {
5379 fn from(value: hashOperationReturn) -> Self {
5380 (value._0,)
5381 }
5382 }
5383 #[automatically_derived]
5384 #[doc(hidden)]
5385 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashOperationReturn {
5386 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5387 Self { _0: tuple.0 }
5388 }
5389 }
5390 }
5391 #[automatically_derived]
5392 impl alloy_sol_types::SolCall for hashOperationCall {
5393 type Parameters<'a> = (
5394 alloy::sol_types::sol_data::Address,
5395 alloy::sol_types::sol_data::Uint<256>,
5396 alloy::sol_types::sol_data::Bytes,
5397 alloy::sol_types::sol_data::FixedBytes<32>,
5398 alloy::sol_types::sol_data::FixedBytes<32>,
5399 );
5400 type Token<'a> = <Self::Parameters<
5401 'a,
5402 > as alloy_sol_types::SolType>::Token<'a>;
5403 type Return = alloy::sol_types::private::FixedBytes<32>;
5404 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5405 type ReturnToken<'a> = <Self::ReturnTuple<
5406 'a,
5407 > as alloy_sol_types::SolType>::Token<'a>;
5408 const SIGNATURE: &'static str = "hashOperation(address,uint256,bytes,bytes32,bytes32)";
5409 const SELECTOR: [u8; 4] = [128u8, 101u8, 101u8, 127u8];
5410 #[inline]
5411 fn new<'a>(
5412 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5413 ) -> Self {
5414 tuple.into()
5415 }
5416 #[inline]
5417 fn tokenize(&self) -> Self::Token<'_> {
5418 (
5419 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5420 &self.target,
5421 ),
5422 <alloy::sol_types::sol_data::Uint<
5423 256,
5424 > as alloy_sol_types::SolType>::tokenize(&self.value),
5425 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
5426 &self.data,
5427 ),
5428 <alloy::sol_types::sol_data::FixedBytes<
5429 32,
5430 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
5431 <alloy::sol_types::sol_data::FixedBytes<
5432 32,
5433 > as alloy_sol_types::SolType>::tokenize(&self.salt),
5434 )
5435 }
5436 #[inline]
5437 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5438 (
5439 <alloy::sol_types::sol_data::FixedBytes<
5440 32,
5441 > as alloy_sol_types::SolType>::tokenize(ret),
5442 )
5443 }
5444 #[inline]
5445 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5446 <Self::ReturnTuple<
5447 '_,
5448 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5449 .map(|r| {
5450 let r: hashOperationReturn = r.into();
5451 r._0
5452 })
5453 }
5454 #[inline]
5455 fn abi_decode_returns_validate(
5456 data: &[u8],
5457 ) -> alloy_sol_types::Result<Self::Return> {
5458 <Self::ReturnTuple<
5459 '_,
5460 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5461 .map(|r| {
5462 let r: hashOperationReturn = r.into();
5463 r._0
5464 })
5465 }
5466 }
5467 };
5468 #[derive(serde::Serialize, serde::Deserialize)]
5469 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5470 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5475 #[derive(Clone)]
5476 pub struct hashOperationBatchCall {
5477 #[allow(missing_docs)]
5478 pub targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
5479 #[allow(missing_docs)]
5480 pub values: alloy::sol_types::private::Vec<
5481 alloy::sol_types::private::primitives::aliases::U256,
5482 >,
5483 #[allow(missing_docs)]
5484 pub payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
5485 #[allow(missing_docs)]
5486 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
5487 #[allow(missing_docs)]
5488 pub salt: alloy::sol_types::private::FixedBytes<32>,
5489 }
5490 #[derive(serde::Serialize, serde::Deserialize)]
5491 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5492 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5494 #[derive(Clone)]
5495 pub struct hashOperationBatchReturn {
5496 #[allow(missing_docs)]
5497 pub _0: alloy::sol_types::private::FixedBytes<32>,
5498 }
5499 #[allow(
5500 non_camel_case_types,
5501 non_snake_case,
5502 clippy::pub_underscore_fields,
5503 clippy::style
5504 )]
5505 const _: () = {
5506 use alloy::sol_types as alloy_sol_types;
5507 {
5508 #[doc(hidden)]
5509 #[allow(dead_code)]
5510 type UnderlyingSolTuple<'a> = (
5511 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5512 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
5513 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
5514 alloy::sol_types::sol_data::FixedBytes<32>,
5515 alloy::sol_types::sol_data::FixedBytes<32>,
5516 );
5517 #[doc(hidden)]
5518 type UnderlyingRustTuple<'a> = (
5519 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
5520 alloy::sol_types::private::Vec<
5521 alloy::sol_types::private::primitives::aliases::U256,
5522 >,
5523 alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
5524 alloy::sol_types::private::FixedBytes<32>,
5525 alloy::sol_types::private::FixedBytes<32>,
5526 );
5527 #[cfg(test)]
5528 #[allow(dead_code, unreachable_patterns)]
5529 fn _type_assertion(
5530 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5531 ) {
5532 match _t {
5533 alloy_sol_types::private::AssertTypeEq::<
5534 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5535 >(_) => {}
5536 }
5537 }
5538 #[automatically_derived]
5539 #[doc(hidden)]
5540 impl ::core::convert::From<hashOperationBatchCall>
5541 for UnderlyingRustTuple<'_> {
5542 fn from(value: hashOperationBatchCall) -> Self {
5543 (
5544 value.targets,
5545 value.values,
5546 value.payloads,
5547 value.predecessor,
5548 value.salt,
5549 )
5550 }
5551 }
5552 #[automatically_derived]
5553 #[doc(hidden)]
5554 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5555 for hashOperationBatchCall {
5556 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5557 Self {
5558 targets: tuple.0,
5559 values: tuple.1,
5560 payloads: tuple.2,
5561 predecessor: tuple.3,
5562 salt: tuple.4,
5563 }
5564 }
5565 }
5566 }
5567 {
5568 #[doc(hidden)]
5569 #[allow(dead_code)]
5570 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5571 #[doc(hidden)]
5572 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
5573 #[cfg(test)]
5574 #[allow(dead_code, unreachable_patterns)]
5575 fn _type_assertion(
5576 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5577 ) {
5578 match _t {
5579 alloy_sol_types::private::AssertTypeEq::<
5580 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5581 >(_) => {}
5582 }
5583 }
5584 #[automatically_derived]
5585 #[doc(hidden)]
5586 impl ::core::convert::From<hashOperationBatchReturn>
5587 for UnderlyingRustTuple<'_> {
5588 fn from(value: hashOperationBatchReturn) -> Self {
5589 (value._0,)
5590 }
5591 }
5592 #[automatically_derived]
5593 #[doc(hidden)]
5594 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5595 for hashOperationBatchReturn {
5596 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5597 Self { _0: tuple.0 }
5598 }
5599 }
5600 }
5601 #[automatically_derived]
5602 impl alloy_sol_types::SolCall for hashOperationBatchCall {
5603 type Parameters<'a> = (
5604 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5605 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
5606 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
5607 alloy::sol_types::sol_data::FixedBytes<32>,
5608 alloy::sol_types::sol_data::FixedBytes<32>,
5609 );
5610 type Token<'a> = <Self::Parameters<
5611 'a,
5612 > as alloy_sol_types::SolType>::Token<'a>;
5613 type Return = alloy::sol_types::private::FixedBytes<32>;
5614 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5615 type ReturnToken<'a> = <Self::ReturnTuple<
5616 'a,
5617 > as alloy_sol_types::SolType>::Token<'a>;
5618 const SIGNATURE: &'static str = "hashOperationBatch(address[],uint256[],bytes[],bytes32,bytes32)";
5619 const SELECTOR: [u8; 4] = [177u8, 197u8, 244u8, 39u8];
5620 #[inline]
5621 fn new<'a>(
5622 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5623 ) -> Self {
5624 tuple.into()
5625 }
5626 #[inline]
5627 fn tokenize(&self) -> Self::Token<'_> {
5628 (
5629 <alloy::sol_types::sol_data::Array<
5630 alloy::sol_types::sol_data::Address,
5631 > as alloy_sol_types::SolType>::tokenize(&self.targets),
5632 <alloy::sol_types::sol_data::Array<
5633 alloy::sol_types::sol_data::Uint<256>,
5634 > as alloy_sol_types::SolType>::tokenize(&self.values),
5635 <alloy::sol_types::sol_data::Array<
5636 alloy::sol_types::sol_data::Bytes,
5637 > as alloy_sol_types::SolType>::tokenize(&self.payloads),
5638 <alloy::sol_types::sol_data::FixedBytes<
5639 32,
5640 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
5641 <alloy::sol_types::sol_data::FixedBytes<
5642 32,
5643 > as alloy_sol_types::SolType>::tokenize(&self.salt),
5644 )
5645 }
5646 #[inline]
5647 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5648 (
5649 <alloy::sol_types::sol_data::FixedBytes<
5650 32,
5651 > as alloy_sol_types::SolType>::tokenize(ret),
5652 )
5653 }
5654 #[inline]
5655 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5656 <Self::ReturnTuple<
5657 '_,
5658 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5659 .map(|r| {
5660 let r: hashOperationBatchReturn = r.into();
5661 r._0
5662 })
5663 }
5664 #[inline]
5665 fn abi_decode_returns_validate(
5666 data: &[u8],
5667 ) -> alloy_sol_types::Result<Self::Return> {
5668 <Self::ReturnTuple<
5669 '_,
5670 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5671 .map(|r| {
5672 let r: hashOperationBatchReturn = r.into();
5673 r._0
5674 })
5675 }
5676 }
5677 };
5678 #[derive(serde::Serialize, serde::Deserialize)]
5679 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5680 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5685 #[derive(Clone)]
5686 pub struct isOperationCall {
5687 #[allow(missing_docs)]
5688 pub id: alloy::sol_types::private::FixedBytes<32>,
5689 }
5690 #[derive(serde::Serialize, serde::Deserialize)]
5691 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5692 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5694 #[derive(Clone)]
5695 pub struct isOperationReturn {
5696 #[allow(missing_docs)]
5697 pub _0: bool,
5698 }
5699 #[allow(
5700 non_camel_case_types,
5701 non_snake_case,
5702 clippy::pub_underscore_fields,
5703 clippy::style
5704 )]
5705 const _: () = {
5706 use alloy::sol_types as alloy_sol_types;
5707 {
5708 #[doc(hidden)]
5709 #[allow(dead_code)]
5710 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5711 #[doc(hidden)]
5712 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
5713 #[cfg(test)]
5714 #[allow(dead_code, unreachable_patterns)]
5715 fn _type_assertion(
5716 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5717 ) {
5718 match _t {
5719 alloy_sol_types::private::AssertTypeEq::<
5720 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5721 >(_) => {}
5722 }
5723 }
5724 #[automatically_derived]
5725 #[doc(hidden)]
5726 impl ::core::convert::From<isOperationCall> for UnderlyingRustTuple<'_> {
5727 fn from(value: isOperationCall) -> Self {
5728 (value.id,)
5729 }
5730 }
5731 #[automatically_derived]
5732 #[doc(hidden)]
5733 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOperationCall {
5734 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5735 Self { id: tuple.0 }
5736 }
5737 }
5738 }
5739 {
5740 #[doc(hidden)]
5741 #[allow(dead_code)]
5742 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5743 #[doc(hidden)]
5744 type UnderlyingRustTuple<'a> = (bool,);
5745 #[cfg(test)]
5746 #[allow(dead_code, unreachable_patterns)]
5747 fn _type_assertion(
5748 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5749 ) {
5750 match _t {
5751 alloy_sol_types::private::AssertTypeEq::<
5752 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5753 >(_) => {}
5754 }
5755 }
5756 #[automatically_derived]
5757 #[doc(hidden)]
5758 impl ::core::convert::From<isOperationReturn> for UnderlyingRustTuple<'_> {
5759 fn from(value: isOperationReturn) -> Self {
5760 (value._0,)
5761 }
5762 }
5763 #[automatically_derived]
5764 #[doc(hidden)]
5765 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOperationReturn {
5766 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5767 Self { _0: tuple.0 }
5768 }
5769 }
5770 }
5771 #[automatically_derived]
5772 impl alloy_sol_types::SolCall for isOperationCall {
5773 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5774 type Token<'a> = <Self::Parameters<
5775 'a,
5776 > as alloy_sol_types::SolType>::Token<'a>;
5777 type Return = bool;
5778 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5779 type ReturnToken<'a> = <Self::ReturnTuple<
5780 'a,
5781 > as alloy_sol_types::SolType>::Token<'a>;
5782 const SIGNATURE: &'static str = "isOperation(bytes32)";
5783 const SELECTOR: [u8; 4] = [49u8, 213u8, 7u8, 80u8];
5784 #[inline]
5785 fn new<'a>(
5786 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5787 ) -> Self {
5788 tuple.into()
5789 }
5790 #[inline]
5791 fn tokenize(&self) -> Self::Token<'_> {
5792 (
5793 <alloy::sol_types::sol_data::FixedBytes<
5794 32,
5795 > as alloy_sol_types::SolType>::tokenize(&self.id),
5796 )
5797 }
5798 #[inline]
5799 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5800 (
5801 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
5802 ret,
5803 ),
5804 )
5805 }
5806 #[inline]
5807 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5808 <Self::ReturnTuple<
5809 '_,
5810 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5811 .map(|r| {
5812 let r: isOperationReturn = r.into();
5813 r._0
5814 })
5815 }
5816 #[inline]
5817 fn abi_decode_returns_validate(
5818 data: &[u8],
5819 ) -> alloy_sol_types::Result<Self::Return> {
5820 <Self::ReturnTuple<
5821 '_,
5822 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5823 .map(|r| {
5824 let r: isOperationReturn = r.into();
5825 r._0
5826 })
5827 }
5828 }
5829 };
5830 #[derive(serde::Serialize, serde::Deserialize)]
5831 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5832 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5837 #[derive(Clone)]
5838 pub struct isOperationDoneCall {
5839 #[allow(missing_docs)]
5840 pub id: alloy::sol_types::private::FixedBytes<32>,
5841 }
5842 #[derive(serde::Serialize, serde::Deserialize)]
5843 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5844 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5846 #[derive(Clone)]
5847 pub struct isOperationDoneReturn {
5848 #[allow(missing_docs)]
5849 pub _0: bool,
5850 }
5851 #[allow(
5852 non_camel_case_types,
5853 non_snake_case,
5854 clippy::pub_underscore_fields,
5855 clippy::style
5856 )]
5857 const _: () = {
5858 use alloy::sol_types as alloy_sol_types;
5859 {
5860 #[doc(hidden)]
5861 #[allow(dead_code)]
5862 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5863 #[doc(hidden)]
5864 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
5865 #[cfg(test)]
5866 #[allow(dead_code, unreachable_patterns)]
5867 fn _type_assertion(
5868 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5869 ) {
5870 match _t {
5871 alloy_sol_types::private::AssertTypeEq::<
5872 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5873 >(_) => {}
5874 }
5875 }
5876 #[automatically_derived]
5877 #[doc(hidden)]
5878 impl ::core::convert::From<isOperationDoneCall> for UnderlyingRustTuple<'_> {
5879 fn from(value: isOperationDoneCall) -> Self {
5880 (value.id,)
5881 }
5882 }
5883 #[automatically_derived]
5884 #[doc(hidden)]
5885 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOperationDoneCall {
5886 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5887 Self { id: tuple.0 }
5888 }
5889 }
5890 }
5891 {
5892 #[doc(hidden)]
5893 #[allow(dead_code)]
5894 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5895 #[doc(hidden)]
5896 type UnderlyingRustTuple<'a> = (bool,);
5897 #[cfg(test)]
5898 #[allow(dead_code, unreachable_patterns)]
5899 fn _type_assertion(
5900 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5901 ) {
5902 match _t {
5903 alloy_sol_types::private::AssertTypeEq::<
5904 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5905 >(_) => {}
5906 }
5907 }
5908 #[automatically_derived]
5909 #[doc(hidden)]
5910 impl ::core::convert::From<isOperationDoneReturn>
5911 for UnderlyingRustTuple<'_> {
5912 fn from(value: isOperationDoneReturn) -> Self {
5913 (value._0,)
5914 }
5915 }
5916 #[automatically_derived]
5917 #[doc(hidden)]
5918 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5919 for isOperationDoneReturn {
5920 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5921 Self { _0: tuple.0 }
5922 }
5923 }
5924 }
5925 #[automatically_derived]
5926 impl alloy_sol_types::SolCall for isOperationDoneCall {
5927 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5928 type Token<'a> = <Self::Parameters<
5929 'a,
5930 > as alloy_sol_types::SolType>::Token<'a>;
5931 type Return = bool;
5932 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5933 type ReturnToken<'a> = <Self::ReturnTuple<
5934 'a,
5935 > as alloy_sol_types::SolType>::Token<'a>;
5936 const SIGNATURE: &'static str = "isOperationDone(bytes32)";
5937 const SELECTOR: [u8; 4] = [42u8, 176u8, 245u8, 41u8];
5938 #[inline]
5939 fn new<'a>(
5940 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5941 ) -> Self {
5942 tuple.into()
5943 }
5944 #[inline]
5945 fn tokenize(&self) -> Self::Token<'_> {
5946 (
5947 <alloy::sol_types::sol_data::FixedBytes<
5948 32,
5949 > as alloy_sol_types::SolType>::tokenize(&self.id),
5950 )
5951 }
5952 #[inline]
5953 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5954 (
5955 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
5956 ret,
5957 ),
5958 )
5959 }
5960 #[inline]
5961 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5962 <Self::ReturnTuple<
5963 '_,
5964 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
5965 .map(|r| {
5966 let r: isOperationDoneReturn = r.into();
5967 r._0
5968 })
5969 }
5970 #[inline]
5971 fn abi_decode_returns_validate(
5972 data: &[u8],
5973 ) -> alloy_sol_types::Result<Self::Return> {
5974 <Self::ReturnTuple<
5975 '_,
5976 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
5977 .map(|r| {
5978 let r: isOperationDoneReturn = r.into();
5979 r._0
5980 })
5981 }
5982 }
5983 };
5984 #[derive(serde::Serialize, serde::Deserialize)]
5985 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5986 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5991 #[derive(Clone)]
5992 pub struct isOperationPendingCall {
5993 #[allow(missing_docs)]
5994 pub id: alloy::sol_types::private::FixedBytes<32>,
5995 }
5996 #[derive(serde::Serialize, serde::Deserialize)]
5997 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5998 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6000 #[derive(Clone)]
6001 pub struct isOperationPendingReturn {
6002 #[allow(missing_docs)]
6003 pub _0: bool,
6004 }
6005 #[allow(
6006 non_camel_case_types,
6007 non_snake_case,
6008 clippy::pub_underscore_fields,
6009 clippy::style
6010 )]
6011 const _: () = {
6012 use alloy::sol_types as alloy_sol_types;
6013 {
6014 #[doc(hidden)]
6015 #[allow(dead_code)]
6016 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6017 #[doc(hidden)]
6018 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
6019 #[cfg(test)]
6020 #[allow(dead_code, unreachable_patterns)]
6021 fn _type_assertion(
6022 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6023 ) {
6024 match _t {
6025 alloy_sol_types::private::AssertTypeEq::<
6026 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6027 >(_) => {}
6028 }
6029 }
6030 #[automatically_derived]
6031 #[doc(hidden)]
6032 impl ::core::convert::From<isOperationPendingCall>
6033 for UnderlyingRustTuple<'_> {
6034 fn from(value: isOperationPendingCall) -> Self {
6035 (value.id,)
6036 }
6037 }
6038 #[automatically_derived]
6039 #[doc(hidden)]
6040 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6041 for isOperationPendingCall {
6042 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6043 Self { id: tuple.0 }
6044 }
6045 }
6046 }
6047 {
6048 #[doc(hidden)]
6049 #[allow(dead_code)]
6050 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
6051 #[doc(hidden)]
6052 type UnderlyingRustTuple<'a> = (bool,);
6053 #[cfg(test)]
6054 #[allow(dead_code, unreachable_patterns)]
6055 fn _type_assertion(
6056 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6057 ) {
6058 match _t {
6059 alloy_sol_types::private::AssertTypeEq::<
6060 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6061 >(_) => {}
6062 }
6063 }
6064 #[automatically_derived]
6065 #[doc(hidden)]
6066 impl ::core::convert::From<isOperationPendingReturn>
6067 for UnderlyingRustTuple<'_> {
6068 fn from(value: isOperationPendingReturn) -> Self {
6069 (value._0,)
6070 }
6071 }
6072 #[automatically_derived]
6073 #[doc(hidden)]
6074 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6075 for isOperationPendingReturn {
6076 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6077 Self { _0: tuple.0 }
6078 }
6079 }
6080 }
6081 #[automatically_derived]
6082 impl alloy_sol_types::SolCall for isOperationPendingCall {
6083 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6084 type Token<'a> = <Self::Parameters<
6085 'a,
6086 > as alloy_sol_types::SolType>::Token<'a>;
6087 type Return = bool;
6088 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
6089 type ReturnToken<'a> = <Self::ReturnTuple<
6090 'a,
6091 > as alloy_sol_types::SolType>::Token<'a>;
6092 const SIGNATURE: &'static str = "isOperationPending(bytes32)";
6093 const SELECTOR: [u8; 4] = [88u8, 75u8, 21u8, 62u8];
6094 #[inline]
6095 fn new<'a>(
6096 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6097 ) -> Self {
6098 tuple.into()
6099 }
6100 #[inline]
6101 fn tokenize(&self) -> Self::Token<'_> {
6102 (
6103 <alloy::sol_types::sol_data::FixedBytes<
6104 32,
6105 > as alloy_sol_types::SolType>::tokenize(&self.id),
6106 )
6107 }
6108 #[inline]
6109 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6110 (
6111 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
6112 ret,
6113 ),
6114 )
6115 }
6116 #[inline]
6117 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6118 <Self::ReturnTuple<
6119 '_,
6120 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6121 .map(|r| {
6122 let r: isOperationPendingReturn = r.into();
6123 r._0
6124 })
6125 }
6126 #[inline]
6127 fn abi_decode_returns_validate(
6128 data: &[u8],
6129 ) -> alloy_sol_types::Result<Self::Return> {
6130 <Self::ReturnTuple<
6131 '_,
6132 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6133 .map(|r| {
6134 let r: isOperationPendingReturn = r.into();
6135 r._0
6136 })
6137 }
6138 }
6139 };
6140 #[derive(serde::Serialize, serde::Deserialize)]
6141 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6142 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6147 #[derive(Clone)]
6148 pub struct isOperationReadyCall {
6149 #[allow(missing_docs)]
6150 pub id: alloy::sol_types::private::FixedBytes<32>,
6151 }
6152 #[derive(serde::Serialize, serde::Deserialize)]
6153 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6154 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6156 #[derive(Clone)]
6157 pub struct isOperationReadyReturn {
6158 #[allow(missing_docs)]
6159 pub _0: bool,
6160 }
6161 #[allow(
6162 non_camel_case_types,
6163 non_snake_case,
6164 clippy::pub_underscore_fields,
6165 clippy::style
6166 )]
6167 const _: () = {
6168 use alloy::sol_types as alloy_sol_types;
6169 {
6170 #[doc(hidden)]
6171 #[allow(dead_code)]
6172 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6173 #[doc(hidden)]
6174 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
6175 #[cfg(test)]
6176 #[allow(dead_code, unreachable_patterns)]
6177 fn _type_assertion(
6178 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6179 ) {
6180 match _t {
6181 alloy_sol_types::private::AssertTypeEq::<
6182 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6183 >(_) => {}
6184 }
6185 }
6186 #[automatically_derived]
6187 #[doc(hidden)]
6188 impl ::core::convert::From<isOperationReadyCall>
6189 for UnderlyingRustTuple<'_> {
6190 fn from(value: isOperationReadyCall) -> Self {
6191 (value.id,)
6192 }
6193 }
6194 #[automatically_derived]
6195 #[doc(hidden)]
6196 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6197 for isOperationReadyCall {
6198 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6199 Self { id: tuple.0 }
6200 }
6201 }
6202 }
6203 {
6204 #[doc(hidden)]
6205 #[allow(dead_code)]
6206 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
6207 #[doc(hidden)]
6208 type UnderlyingRustTuple<'a> = (bool,);
6209 #[cfg(test)]
6210 #[allow(dead_code, unreachable_patterns)]
6211 fn _type_assertion(
6212 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6213 ) {
6214 match _t {
6215 alloy_sol_types::private::AssertTypeEq::<
6216 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6217 >(_) => {}
6218 }
6219 }
6220 #[automatically_derived]
6221 #[doc(hidden)]
6222 impl ::core::convert::From<isOperationReadyReturn>
6223 for UnderlyingRustTuple<'_> {
6224 fn from(value: isOperationReadyReturn) -> Self {
6225 (value._0,)
6226 }
6227 }
6228 #[automatically_derived]
6229 #[doc(hidden)]
6230 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6231 for isOperationReadyReturn {
6232 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6233 Self { _0: tuple.0 }
6234 }
6235 }
6236 }
6237 #[automatically_derived]
6238 impl alloy_sol_types::SolCall for isOperationReadyCall {
6239 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
6240 type Token<'a> = <Self::Parameters<
6241 'a,
6242 > as alloy_sol_types::SolType>::Token<'a>;
6243 type Return = bool;
6244 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
6245 type ReturnToken<'a> = <Self::ReturnTuple<
6246 'a,
6247 > as alloy_sol_types::SolType>::Token<'a>;
6248 const SIGNATURE: &'static str = "isOperationReady(bytes32)";
6249 const SELECTOR: [u8; 4] = [19u8, 188u8, 159u8, 32u8];
6250 #[inline]
6251 fn new<'a>(
6252 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6253 ) -> Self {
6254 tuple.into()
6255 }
6256 #[inline]
6257 fn tokenize(&self) -> Self::Token<'_> {
6258 (
6259 <alloy::sol_types::sol_data::FixedBytes<
6260 32,
6261 > as alloy_sol_types::SolType>::tokenize(&self.id),
6262 )
6263 }
6264 #[inline]
6265 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6266 (
6267 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
6268 ret,
6269 ),
6270 )
6271 }
6272 #[inline]
6273 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6274 <Self::ReturnTuple<
6275 '_,
6276 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6277 .map(|r| {
6278 let r: isOperationReadyReturn = r.into();
6279 r._0
6280 })
6281 }
6282 #[inline]
6283 fn abi_decode_returns_validate(
6284 data: &[u8],
6285 ) -> alloy_sol_types::Result<Self::Return> {
6286 <Self::ReturnTuple<
6287 '_,
6288 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6289 .map(|r| {
6290 let r: isOperationReadyReturn = r.into();
6291 r._0
6292 })
6293 }
6294 }
6295 };
6296 #[derive(serde::Serialize, serde::Deserialize)]
6297 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6298 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6303 #[derive(Clone)]
6304 pub struct onERC1155BatchReceivedCall {
6305 #[allow(missing_docs)]
6306 pub _0: alloy::sol_types::private::Address,
6307 #[allow(missing_docs)]
6308 pub _1: alloy::sol_types::private::Address,
6309 #[allow(missing_docs)]
6310 pub _2: alloy::sol_types::private::Vec<
6311 alloy::sol_types::private::primitives::aliases::U256,
6312 >,
6313 #[allow(missing_docs)]
6314 pub _3: alloy::sol_types::private::Vec<
6315 alloy::sol_types::private::primitives::aliases::U256,
6316 >,
6317 #[allow(missing_docs)]
6318 pub _4: alloy::sol_types::private::Bytes,
6319 }
6320 #[derive(serde::Serialize, serde::Deserialize)]
6321 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6322 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6324 #[derive(Clone)]
6325 pub struct onERC1155BatchReceivedReturn {
6326 #[allow(missing_docs)]
6327 pub _0: alloy::sol_types::private::FixedBytes<4>,
6328 }
6329 #[allow(
6330 non_camel_case_types,
6331 non_snake_case,
6332 clippy::pub_underscore_fields,
6333 clippy::style
6334 )]
6335 const _: () = {
6336 use alloy::sol_types as alloy_sol_types;
6337 {
6338 #[doc(hidden)]
6339 #[allow(dead_code)]
6340 type UnderlyingSolTuple<'a> = (
6341 alloy::sol_types::sol_data::Address,
6342 alloy::sol_types::sol_data::Address,
6343 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
6344 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
6345 alloy::sol_types::sol_data::Bytes,
6346 );
6347 #[doc(hidden)]
6348 type UnderlyingRustTuple<'a> = (
6349 alloy::sol_types::private::Address,
6350 alloy::sol_types::private::Address,
6351 alloy::sol_types::private::Vec<
6352 alloy::sol_types::private::primitives::aliases::U256,
6353 >,
6354 alloy::sol_types::private::Vec<
6355 alloy::sol_types::private::primitives::aliases::U256,
6356 >,
6357 alloy::sol_types::private::Bytes,
6358 );
6359 #[cfg(test)]
6360 #[allow(dead_code, unreachable_patterns)]
6361 fn _type_assertion(
6362 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6363 ) {
6364 match _t {
6365 alloy_sol_types::private::AssertTypeEq::<
6366 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6367 >(_) => {}
6368 }
6369 }
6370 #[automatically_derived]
6371 #[doc(hidden)]
6372 impl ::core::convert::From<onERC1155BatchReceivedCall>
6373 for UnderlyingRustTuple<'_> {
6374 fn from(value: onERC1155BatchReceivedCall) -> Self {
6375 (value._0, value._1, value._2, value._3, value._4)
6376 }
6377 }
6378 #[automatically_derived]
6379 #[doc(hidden)]
6380 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6381 for onERC1155BatchReceivedCall {
6382 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6383 Self {
6384 _0: tuple.0,
6385 _1: tuple.1,
6386 _2: tuple.2,
6387 _3: tuple.3,
6388 _4: tuple.4,
6389 }
6390 }
6391 }
6392 }
6393 {
6394 #[doc(hidden)]
6395 #[allow(dead_code)]
6396 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6397 #[doc(hidden)]
6398 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
6399 #[cfg(test)]
6400 #[allow(dead_code, unreachable_patterns)]
6401 fn _type_assertion(
6402 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6403 ) {
6404 match _t {
6405 alloy_sol_types::private::AssertTypeEq::<
6406 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6407 >(_) => {}
6408 }
6409 }
6410 #[automatically_derived]
6411 #[doc(hidden)]
6412 impl ::core::convert::From<onERC1155BatchReceivedReturn>
6413 for UnderlyingRustTuple<'_> {
6414 fn from(value: onERC1155BatchReceivedReturn) -> Self {
6415 (value._0,)
6416 }
6417 }
6418 #[automatically_derived]
6419 #[doc(hidden)]
6420 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6421 for onERC1155BatchReceivedReturn {
6422 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6423 Self { _0: tuple.0 }
6424 }
6425 }
6426 }
6427 #[automatically_derived]
6428 impl alloy_sol_types::SolCall for onERC1155BatchReceivedCall {
6429 type Parameters<'a> = (
6430 alloy::sol_types::sol_data::Address,
6431 alloy::sol_types::sol_data::Address,
6432 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
6433 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
6434 alloy::sol_types::sol_data::Bytes,
6435 );
6436 type Token<'a> = <Self::Parameters<
6437 'a,
6438 > as alloy_sol_types::SolType>::Token<'a>;
6439 type Return = alloy::sol_types::private::FixedBytes<4>;
6440 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6441 type ReturnToken<'a> = <Self::ReturnTuple<
6442 'a,
6443 > as alloy_sol_types::SolType>::Token<'a>;
6444 const SIGNATURE: &'static str = "onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)";
6445 const SELECTOR: [u8; 4] = [188u8, 25u8, 124u8, 129u8];
6446 #[inline]
6447 fn new<'a>(
6448 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6449 ) -> Self {
6450 tuple.into()
6451 }
6452 #[inline]
6453 fn tokenize(&self) -> Self::Token<'_> {
6454 (
6455 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6456 &self._0,
6457 ),
6458 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6459 &self._1,
6460 ),
6461 <alloy::sol_types::sol_data::Array<
6462 alloy::sol_types::sol_data::Uint<256>,
6463 > as alloy_sol_types::SolType>::tokenize(&self._2),
6464 <alloy::sol_types::sol_data::Array<
6465 alloy::sol_types::sol_data::Uint<256>,
6466 > as alloy_sol_types::SolType>::tokenize(&self._3),
6467 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
6468 &self._4,
6469 ),
6470 )
6471 }
6472 #[inline]
6473 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6474 (
6475 <alloy::sol_types::sol_data::FixedBytes<
6476 4,
6477 > as alloy_sol_types::SolType>::tokenize(ret),
6478 )
6479 }
6480 #[inline]
6481 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6482 <Self::ReturnTuple<
6483 '_,
6484 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6485 .map(|r| {
6486 let r: onERC1155BatchReceivedReturn = r.into();
6487 r._0
6488 })
6489 }
6490 #[inline]
6491 fn abi_decode_returns_validate(
6492 data: &[u8],
6493 ) -> alloy_sol_types::Result<Self::Return> {
6494 <Self::ReturnTuple<
6495 '_,
6496 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6497 .map(|r| {
6498 let r: onERC1155BatchReceivedReturn = r.into();
6499 r._0
6500 })
6501 }
6502 }
6503 };
6504 #[derive(serde::Serialize, serde::Deserialize)]
6505 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6506 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6511 #[derive(Clone)]
6512 pub struct onERC1155ReceivedCall {
6513 #[allow(missing_docs)]
6514 pub _0: alloy::sol_types::private::Address,
6515 #[allow(missing_docs)]
6516 pub _1: alloy::sol_types::private::Address,
6517 #[allow(missing_docs)]
6518 pub _2: alloy::sol_types::private::primitives::aliases::U256,
6519 #[allow(missing_docs)]
6520 pub _3: alloy::sol_types::private::primitives::aliases::U256,
6521 #[allow(missing_docs)]
6522 pub _4: alloy::sol_types::private::Bytes,
6523 }
6524 #[derive(serde::Serialize, serde::Deserialize)]
6525 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6526 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6528 #[derive(Clone)]
6529 pub struct onERC1155ReceivedReturn {
6530 #[allow(missing_docs)]
6531 pub _0: alloy::sol_types::private::FixedBytes<4>,
6532 }
6533 #[allow(
6534 non_camel_case_types,
6535 non_snake_case,
6536 clippy::pub_underscore_fields,
6537 clippy::style
6538 )]
6539 const _: () = {
6540 use alloy::sol_types as alloy_sol_types;
6541 {
6542 #[doc(hidden)]
6543 #[allow(dead_code)]
6544 type UnderlyingSolTuple<'a> = (
6545 alloy::sol_types::sol_data::Address,
6546 alloy::sol_types::sol_data::Address,
6547 alloy::sol_types::sol_data::Uint<256>,
6548 alloy::sol_types::sol_data::Uint<256>,
6549 alloy::sol_types::sol_data::Bytes,
6550 );
6551 #[doc(hidden)]
6552 type UnderlyingRustTuple<'a> = (
6553 alloy::sol_types::private::Address,
6554 alloy::sol_types::private::Address,
6555 alloy::sol_types::private::primitives::aliases::U256,
6556 alloy::sol_types::private::primitives::aliases::U256,
6557 alloy::sol_types::private::Bytes,
6558 );
6559 #[cfg(test)]
6560 #[allow(dead_code, unreachable_patterns)]
6561 fn _type_assertion(
6562 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6563 ) {
6564 match _t {
6565 alloy_sol_types::private::AssertTypeEq::<
6566 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6567 >(_) => {}
6568 }
6569 }
6570 #[automatically_derived]
6571 #[doc(hidden)]
6572 impl ::core::convert::From<onERC1155ReceivedCall>
6573 for UnderlyingRustTuple<'_> {
6574 fn from(value: onERC1155ReceivedCall) -> Self {
6575 (value._0, value._1, value._2, value._3, value._4)
6576 }
6577 }
6578 #[automatically_derived]
6579 #[doc(hidden)]
6580 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6581 for onERC1155ReceivedCall {
6582 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6583 Self {
6584 _0: tuple.0,
6585 _1: tuple.1,
6586 _2: tuple.2,
6587 _3: tuple.3,
6588 _4: tuple.4,
6589 }
6590 }
6591 }
6592 }
6593 {
6594 #[doc(hidden)]
6595 #[allow(dead_code)]
6596 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6597 #[doc(hidden)]
6598 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
6599 #[cfg(test)]
6600 #[allow(dead_code, unreachable_patterns)]
6601 fn _type_assertion(
6602 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6603 ) {
6604 match _t {
6605 alloy_sol_types::private::AssertTypeEq::<
6606 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6607 >(_) => {}
6608 }
6609 }
6610 #[automatically_derived]
6611 #[doc(hidden)]
6612 impl ::core::convert::From<onERC1155ReceivedReturn>
6613 for UnderlyingRustTuple<'_> {
6614 fn from(value: onERC1155ReceivedReturn) -> Self {
6615 (value._0,)
6616 }
6617 }
6618 #[automatically_derived]
6619 #[doc(hidden)]
6620 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6621 for onERC1155ReceivedReturn {
6622 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6623 Self { _0: tuple.0 }
6624 }
6625 }
6626 }
6627 #[automatically_derived]
6628 impl alloy_sol_types::SolCall for onERC1155ReceivedCall {
6629 type Parameters<'a> = (
6630 alloy::sol_types::sol_data::Address,
6631 alloy::sol_types::sol_data::Address,
6632 alloy::sol_types::sol_data::Uint<256>,
6633 alloy::sol_types::sol_data::Uint<256>,
6634 alloy::sol_types::sol_data::Bytes,
6635 );
6636 type Token<'a> = <Self::Parameters<
6637 'a,
6638 > as alloy_sol_types::SolType>::Token<'a>;
6639 type Return = alloy::sol_types::private::FixedBytes<4>;
6640 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6641 type ReturnToken<'a> = <Self::ReturnTuple<
6642 'a,
6643 > as alloy_sol_types::SolType>::Token<'a>;
6644 const SIGNATURE: &'static str = "onERC1155Received(address,address,uint256,uint256,bytes)";
6645 const SELECTOR: [u8; 4] = [242u8, 58u8, 110u8, 97u8];
6646 #[inline]
6647 fn new<'a>(
6648 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6649 ) -> Self {
6650 tuple.into()
6651 }
6652 #[inline]
6653 fn tokenize(&self) -> Self::Token<'_> {
6654 (
6655 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6656 &self._0,
6657 ),
6658 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6659 &self._1,
6660 ),
6661 <alloy::sol_types::sol_data::Uint<
6662 256,
6663 > as alloy_sol_types::SolType>::tokenize(&self._2),
6664 <alloy::sol_types::sol_data::Uint<
6665 256,
6666 > as alloy_sol_types::SolType>::tokenize(&self._3),
6667 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
6668 &self._4,
6669 ),
6670 )
6671 }
6672 #[inline]
6673 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6674 (
6675 <alloy::sol_types::sol_data::FixedBytes<
6676 4,
6677 > as alloy_sol_types::SolType>::tokenize(ret),
6678 )
6679 }
6680 #[inline]
6681 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6682 <Self::ReturnTuple<
6683 '_,
6684 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6685 .map(|r| {
6686 let r: onERC1155ReceivedReturn = r.into();
6687 r._0
6688 })
6689 }
6690 #[inline]
6691 fn abi_decode_returns_validate(
6692 data: &[u8],
6693 ) -> alloy_sol_types::Result<Self::Return> {
6694 <Self::ReturnTuple<
6695 '_,
6696 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6697 .map(|r| {
6698 let r: onERC1155ReceivedReturn = r.into();
6699 r._0
6700 })
6701 }
6702 }
6703 };
6704 #[derive(serde::Serialize, serde::Deserialize)]
6705 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6706 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6711 #[derive(Clone)]
6712 pub struct onERC721ReceivedCall {
6713 #[allow(missing_docs)]
6714 pub _0: alloy::sol_types::private::Address,
6715 #[allow(missing_docs)]
6716 pub _1: alloy::sol_types::private::Address,
6717 #[allow(missing_docs)]
6718 pub _2: alloy::sol_types::private::primitives::aliases::U256,
6719 #[allow(missing_docs)]
6720 pub _3: alloy::sol_types::private::Bytes,
6721 }
6722 #[derive(serde::Serialize, serde::Deserialize)]
6723 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6724 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6726 #[derive(Clone)]
6727 pub struct onERC721ReceivedReturn {
6728 #[allow(missing_docs)]
6729 pub _0: alloy::sol_types::private::FixedBytes<4>,
6730 }
6731 #[allow(
6732 non_camel_case_types,
6733 non_snake_case,
6734 clippy::pub_underscore_fields,
6735 clippy::style
6736 )]
6737 const _: () = {
6738 use alloy::sol_types as alloy_sol_types;
6739 {
6740 #[doc(hidden)]
6741 #[allow(dead_code)]
6742 type UnderlyingSolTuple<'a> = (
6743 alloy::sol_types::sol_data::Address,
6744 alloy::sol_types::sol_data::Address,
6745 alloy::sol_types::sol_data::Uint<256>,
6746 alloy::sol_types::sol_data::Bytes,
6747 );
6748 #[doc(hidden)]
6749 type UnderlyingRustTuple<'a> = (
6750 alloy::sol_types::private::Address,
6751 alloy::sol_types::private::Address,
6752 alloy::sol_types::private::primitives::aliases::U256,
6753 alloy::sol_types::private::Bytes,
6754 );
6755 #[cfg(test)]
6756 #[allow(dead_code, unreachable_patterns)]
6757 fn _type_assertion(
6758 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6759 ) {
6760 match _t {
6761 alloy_sol_types::private::AssertTypeEq::<
6762 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6763 >(_) => {}
6764 }
6765 }
6766 #[automatically_derived]
6767 #[doc(hidden)]
6768 impl ::core::convert::From<onERC721ReceivedCall>
6769 for UnderlyingRustTuple<'_> {
6770 fn from(value: onERC721ReceivedCall) -> Self {
6771 (value._0, value._1, value._2, value._3)
6772 }
6773 }
6774 #[automatically_derived]
6775 #[doc(hidden)]
6776 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6777 for onERC721ReceivedCall {
6778 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6779 Self {
6780 _0: tuple.0,
6781 _1: tuple.1,
6782 _2: tuple.2,
6783 _3: tuple.3,
6784 }
6785 }
6786 }
6787 }
6788 {
6789 #[doc(hidden)]
6790 #[allow(dead_code)]
6791 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6792 #[doc(hidden)]
6793 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
6794 #[cfg(test)]
6795 #[allow(dead_code, unreachable_patterns)]
6796 fn _type_assertion(
6797 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6798 ) {
6799 match _t {
6800 alloy_sol_types::private::AssertTypeEq::<
6801 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6802 >(_) => {}
6803 }
6804 }
6805 #[automatically_derived]
6806 #[doc(hidden)]
6807 impl ::core::convert::From<onERC721ReceivedReturn>
6808 for UnderlyingRustTuple<'_> {
6809 fn from(value: onERC721ReceivedReturn) -> Self {
6810 (value._0,)
6811 }
6812 }
6813 #[automatically_derived]
6814 #[doc(hidden)]
6815 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6816 for onERC721ReceivedReturn {
6817 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6818 Self { _0: tuple.0 }
6819 }
6820 }
6821 }
6822 #[automatically_derived]
6823 impl alloy_sol_types::SolCall for onERC721ReceivedCall {
6824 type Parameters<'a> = (
6825 alloy::sol_types::sol_data::Address,
6826 alloy::sol_types::sol_data::Address,
6827 alloy::sol_types::sol_data::Uint<256>,
6828 alloy::sol_types::sol_data::Bytes,
6829 );
6830 type Token<'a> = <Self::Parameters<
6831 'a,
6832 > as alloy_sol_types::SolType>::Token<'a>;
6833 type Return = alloy::sol_types::private::FixedBytes<4>;
6834 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6835 type ReturnToken<'a> = <Self::ReturnTuple<
6836 'a,
6837 > as alloy_sol_types::SolType>::Token<'a>;
6838 const SIGNATURE: &'static str = "onERC721Received(address,address,uint256,bytes)";
6839 const SELECTOR: [u8; 4] = [21u8, 11u8, 122u8, 2u8];
6840 #[inline]
6841 fn new<'a>(
6842 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6843 ) -> Self {
6844 tuple.into()
6845 }
6846 #[inline]
6847 fn tokenize(&self) -> Self::Token<'_> {
6848 (
6849 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6850 &self._0,
6851 ),
6852 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6853 &self._1,
6854 ),
6855 <alloy::sol_types::sol_data::Uint<
6856 256,
6857 > as alloy_sol_types::SolType>::tokenize(&self._2),
6858 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
6859 &self._3,
6860 ),
6861 )
6862 }
6863 #[inline]
6864 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6865 (
6866 <alloy::sol_types::sol_data::FixedBytes<
6867 4,
6868 > as alloy_sol_types::SolType>::tokenize(ret),
6869 )
6870 }
6871 #[inline]
6872 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6873 <Self::ReturnTuple<
6874 '_,
6875 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6876 .map(|r| {
6877 let r: onERC721ReceivedReturn = r.into();
6878 r._0
6879 })
6880 }
6881 #[inline]
6882 fn abi_decode_returns_validate(
6883 data: &[u8],
6884 ) -> alloy_sol_types::Result<Self::Return> {
6885 <Self::ReturnTuple<
6886 '_,
6887 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6888 .map(|r| {
6889 let r: onERC721ReceivedReturn = r.into();
6890 r._0
6891 })
6892 }
6893 }
6894 };
6895 #[derive(serde::Serialize, serde::Deserialize)]
6896 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6897 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6902 #[derive(Clone)]
6903 pub struct renounceRoleCall {
6904 #[allow(missing_docs)]
6905 pub role: alloy::sol_types::private::FixedBytes<32>,
6906 #[allow(missing_docs)]
6907 pub callerConfirmation: alloy::sol_types::private::Address,
6908 }
6909 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6911 #[derive(Clone)]
6912 pub struct renounceRoleReturn {}
6913 #[allow(
6914 non_camel_case_types,
6915 non_snake_case,
6916 clippy::pub_underscore_fields,
6917 clippy::style
6918 )]
6919 const _: () = {
6920 use alloy::sol_types as alloy_sol_types;
6921 {
6922 #[doc(hidden)]
6923 #[allow(dead_code)]
6924 type UnderlyingSolTuple<'a> = (
6925 alloy::sol_types::sol_data::FixedBytes<32>,
6926 alloy::sol_types::sol_data::Address,
6927 );
6928 #[doc(hidden)]
6929 type UnderlyingRustTuple<'a> = (
6930 alloy::sol_types::private::FixedBytes<32>,
6931 alloy::sol_types::private::Address,
6932 );
6933 #[cfg(test)]
6934 #[allow(dead_code, unreachable_patterns)]
6935 fn _type_assertion(
6936 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6937 ) {
6938 match _t {
6939 alloy_sol_types::private::AssertTypeEq::<
6940 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6941 >(_) => {}
6942 }
6943 }
6944 #[automatically_derived]
6945 #[doc(hidden)]
6946 impl ::core::convert::From<renounceRoleCall> for UnderlyingRustTuple<'_> {
6947 fn from(value: renounceRoleCall) -> Self {
6948 (value.role, value.callerConfirmation)
6949 }
6950 }
6951 #[automatically_derived]
6952 #[doc(hidden)]
6953 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleCall {
6954 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6955 Self {
6956 role: tuple.0,
6957 callerConfirmation: tuple.1,
6958 }
6959 }
6960 }
6961 }
6962 {
6963 #[doc(hidden)]
6964 #[allow(dead_code)]
6965 type UnderlyingSolTuple<'a> = ();
6966 #[doc(hidden)]
6967 type UnderlyingRustTuple<'a> = ();
6968 #[cfg(test)]
6969 #[allow(dead_code, unreachable_patterns)]
6970 fn _type_assertion(
6971 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6972 ) {
6973 match _t {
6974 alloy_sol_types::private::AssertTypeEq::<
6975 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6976 >(_) => {}
6977 }
6978 }
6979 #[automatically_derived]
6980 #[doc(hidden)]
6981 impl ::core::convert::From<renounceRoleReturn> for UnderlyingRustTuple<'_> {
6982 fn from(value: renounceRoleReturn) -> Self {
6983 ()
6984 }
6985 }
6986 #[automatically_derived]
6987 #[doc(hidden)]
6988 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleReturn {
6989 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6990 Self {}
6991 }
6992 }
6993 }
6994 impl renounceRoleReturn {
6995 fn _tokenize(
6996 &self,
6997 ) -> <renounceRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
6998 ()
6999 }
7000 }
7001 #[automatically_derived]
7002 impl alloy_sol_types::SolCall for renounceRoleCall {
7003 type Parameters<'a> = (
7004 alloy::sol_types::sol_data::FixedBytes<32>,
7005 alloy::sol_types::sol_data::Address,
7006 );
7007 type Token<'a> = <Self::Parameters<
7008 'a,
7009 > as alloy_sol_types::SolType>::Token<'a>;
7010 type Return = renounceRoleReturn;
7011 type ReturnTuple<'a> = ();
7012 type ReturnToken<'a> = <Self::ReturnTuple<
7013 'a,
7014 > as alloy_sol_types::SolType>::Token<'a>;
7015 const SIGNATURE: &'static str = "renounceRole(bytes32,address)";
7016 const SELECTOR: [u8; 4] = [54u8, 86u8, 138u8, 190u8];
7017 #[inline]
7018 fn new<'a>(
7019 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7020 ) -> Self {
7021 tuple.into()
7022 }
7023 #[inline]
7024 fn tokenize(&self) -> Self::Token<'_> {
7025 (
7026 <alloy::sol_types::sol_data::FixedBytes<
7027 32,
7028 > as alloy_sol_types::SolType>::tokenize(&self.role),
7029 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7030 &self.callerConfirmation,
7031 ),
7032 )
7033 }
7034 #[inline]
7035 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7036 renounceRoleReturn::_tokenize(ret)
7037 }
7038 #[inline]
7039 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7040 <Self::ReturnTuple<
7041 '_,
7042 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7043 .map(Into::into)
7044 }
7045 #[inline]
7046 fn abi_decode_returns_validate(
7047 data: &[u8],
7048 ) -> alloy_sol_types::Result<Self::Return> {
7049 <Self::ReturnTuple<
7050 '_,
7051 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7052 .map(Into::into)
7053 }
7054 }
7055 };
7056 #[derive(serde::Serialize, serde::Deserialize)]
7057 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7058 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7063 #[derive(Clone)]
7064 pub struct revokeRoleCall {
7065 #[allow(missing_docs)]
7066 pub role: alloy::sol_types::private::FixedBytes<32>,
7067 #[allow(missing_docs)]
7068 pub account: alloy::sol_types::private::Address,
7069 }
7070 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7072 #[derive(Clone)]
7073 pub struct revokeRoleReturn {}
7074 #[allow(
7075 non_camel_case_types,
7076 non_snake_case,
7077 clippy::pub_underscore_fields,
7078 clippy::style
7079 )]
7080 const _: () = {
7081 use alloy::sol_types as alloy_sol_types;
7082 {
7083 #[doc(hidden)]
7084 #[allow(dead_code)]
7085 type UnderlyingSolTuple<'a> = (
7086 alloy::sol_types::sol_data::FixedBytes<32>,
7087 alloy::sol_types::sol_data::Address,
7088 );
7089 #[doc(hidden)]
7090 type UnderlyingRustTuple<'a> = (
7091 alloy::sol_types::private::FixedBytes<32>,
7092 alloy::sol_types::private::Address,
7093 );
7094 #[cfg(test)]
7095 #[allow(dead_code, unreachable_patterns)]
7096 fn _type_assertion(
7097 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7098 ) {
7099 match _t {
7100 alloy_sol_types::private::AssertTypeEq::<
7101 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7102 >(_) => {}
7103 }
7104 }
7105 #[automatically_derived]
7106 #[doc(hidden)]
7107 impl ::core::convert::From<revokeRoleCall> for UnderlyingRustTuple<'_> {
7108 fn from(value: revokeRoleCall) -> Self {
7109 (value.role, value.account)
7110 }
7111 }
7112 #[automatically_derived]
7113 #[doc(hidden)]
7114 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleCall {
7115 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7116 Self {
7117 role: tuple.0,
7118 account: tuple.1,
7119 }
7120 }
7121 }
7122 }
7123 {
7124 #[doc(hidden)]
7125 #[allow(dead_code)]
7126 type UnderlyingSolTuple<'a> = ();
7127 #[doc(hidden)]
7128 type UnderlyingRustTuple<'a> = ();
7129 #[cfg(test)]
7130 #[allow(dead_code, unreachable_patterns)]
7131 fn _type_assertion(
7132 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7133 ) {
7134 match _t {
7135 alloy_sol_types::private::AssertTypeEq::<
7136 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7137 >(_) => {}
7138 }
7139 }
7140 #[automatically_derived]
7141 #[doc(hidden)]
7142 impl ::core::convert::From<revokeRoleReturn> for UnderlyingRustTuple<'_> {
7143 fn from(value: revokeRoleReturn) -> Self {
7144 ()
7145 }
7146 }
7147 #[automatically_derived]
7148 #[doc(hidden)]
7149 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleReturn {
7150 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7151 Self {}
7152 }
7153 }
7154 }
7155 impl revokeRoleReturn {
7156 fn _tokenize(
7157 &self,
7158 ) -> <revokeRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
7159 ()
7160 }
7161 }
7162 #[automatically_derived]
7163 impl alloy_sol_types::SolCall for revokeRoleCall {
7164 type Parameters<'a> = (
7165 alloy::sol_types::sol_data::FixedBytes<32>,
7166 alloy::sol_types::sol_data::Address,
7167 );
7168 type Token<'a> = <Self::Parameters<
7169 'a,
7170 > as alloy_sol_types::SolType>::Token<'a>;
7171 type Return = revokeRoleReturn;
7172 type ReturnTuple<'a> = ();
7173 type ReturnToken<'a> = <Self::ReturnTuple<
7174 'a,
7175 > as alloy_sol_types::SolType>::Token<'a>;
7176 const SIGNATURE: &'static str = "revokeRole(bytes32,address)";
7177 const SELECTOR: [u8; 4] = [213u8, 71u8, 116u8, 31u8];
7178 #[inline]
7179 fn new<'a>(
7180 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7181 ) -> Self {
7182 tuple.into()
7183 }
7184 #[inline]
7185 fn tokenize(&self) -> Self::Token<'_> {
7186 (
7187 <alloy::sol_types::sol_data::FixedBytes<
7188 32,
7189 > as alloy_sol_types::SolType>::tokenize(&self.role),
7190 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7191 &self.account,
7192 ),
7193 )
7194 }
7195 #[inline]
7196 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7197 revokeRoleReturn::_tokenize(ret)
7198 }
7199 #[inline]
7200 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7201 <Self::ReturnTuple<
7202 '_,
7203 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7204 .map(Into::into)
7205 }
7206 #[inline]
7207 fn abi_decode_returns_validate(
7208 data: &[u8],
7209 ) -> alloy_sol_types::Result<Self::Return> {
7210 <Self::ReturnTuple<
7211 '_,
7212 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7213 .map(Into::into)
7214 }
7215 }
7216 };
7217 #[derive(serde::Serialize, serde::Deserialize)]
7218 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7219 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7224 #[derive(Clone)]
7225 pub struct scheduleCall {
7226 #[allow(missing_docs)]
7227 pub target: alloy::sol_types::private::Address,
7228 #[allow(missing_docs)]
7229 pub value: alloy::sol_types::private::primitives::aliases::U256,
7230 #[allow(missing_docs)]
7231 pub data: alloy::sol_types::private::Bytes,
7232 #[allow(missing_docs)]
7233 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
7234 #[allow(missing_docs)]
7235 pub salt: alloy::sol_types::private::FixedBytes<32>,
7236 #[allow(missing_docs)]
7237 pub delay: alloy::sol_types::private::primitives::aliases::U256,
7238 }
7239 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7241 #[derive(Clone)]
7242 pub struct scheduleReturn {}
7243 #[allow(
7244 non_camel_case_types,
7245 non_snake_case,
7246 clippy::pub_underscore_fields,
7247 clippy::style
7248 )]
7249 const _: () = {
7250 use alloy::sol_types as alloy_sol_types;
7251 {
7252 #[doc(hidden)]
7253 #[allow(dead_code)]
7254 type UnderlyingSolTuple<'a> = (
7255 alloy::sol_types::sol_data::Address,
7256 alloy::sol_types::sol_data::Uint<256>,
7257 alloy::sol_types::sol_data::Bytes,
7258 alloy::sol_types::sol_data::FixedBytes<32>,
7259 alloy::sol_types::sol_data::FixedBytes<32>,
7260 alloy::sol_types::sol_data::Uint<256>,
7261 );
7262 #[doc(hidden)]
7263 type UnderlyingRustTuple<'a> = (
7264 alloy::sol_types::private::Address,
7265 alloy::sol_types::private::primitives::aliases::U256,
7266 alloy::sol_types::private::Bytes,
7267 alloy::sol_types::private::FixedBytes<32>,
7268 alloy::sol_types::private::FixedBytes<32>,
7269 alloy::sol_types::private::primitives::aliases::U256,
7270 );
7271 #[cfg(test)]
7272 #[allow(dead_code, unreachable_patterns)]
7273 fn _type_assertion(
7274 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7275 ) {
7276 match _t {
7277 alloy_sol_types::private::AssertTypeEq::<
7278 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7279 >(_) => {}
7280 }
7281 }
7282 #[automatically_derived]
7283 #[doc(hidden)]
7284 impl ::core::convert::From<scheduleCall> for UnderlyingRustTuple<'_> {
7285 fn from(value: scheduleCall) -> Self {
7286 (
7287 value.target,
7288 value.value,
7289 value.data,
7290 value.predecessor,
7291 value.salt,
7292 value.delay,
7293 )
7294 }
7295 }
7296 #[automatically_derived]
7297 #[doc(hidden)]
7298 impl ::core::convert::From<UnderlyingRustTuple<'_>> for scheduleCall {
7299 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7300 Self {
7301 target: tuple.0,
7302 value: tuple.1,
7303 data: tuple.2,
7304 predecessor: tuple.3,
7305 salt: tuple.4,
7306 delay: tuple.5,
7307 }
7308 }
7309 }
7310 }
7311 {
7312 #[doc(hidden)]
7313 #[allow(dead_code)]
7314 type UnderlyingSolTuple<'a> = ();
7315 #[doc(hidden)]
7316 type UnderlyingRustTuple<'a> = ();
7317 #[cfg(test)]
7318 #[allow(dead_code, unreachable_patterns)]
7319 fn _type_assertion(
7320 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7321 ) {
7322 match _t {
7323 alloy_sol_types::private::AssertTypeEq::<
7324 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7325 >(_) => {}
7326 }
7327 }
7328 #[automatically_derived]
7329 #[doc(hidden)]
7330 impl ::core::convert::From<scheduleReturn> for UnderlyingRustTuple<'_> {
7331 fn from(value: scheduleReturn) -> Self {
7332 ()
7333 }
7334 }
7335 #[automatically_derived]
7336 #[doc(hidden)]
7337 impl ::core::convert::From<UnderlyingRustTuple<'_>> for scheduleReturn {
7338 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7339 Self {}
7340 }
7341 }
7342 }
7343 impl scheduleReturn {
7344 fn _tokenize(
7345 &self,
7346 ) -> <scheduleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
7347 ()
7348 }
7349 }
7350 #[automatically_derived]
7351 impl alloy_sol_types::SolCall for scheduleCall {
7352 type Parameters<'a> = (
7353 alloy::sol_types::sol_data::Address,
7354 alloy::sol_types::sol_data::Uint<256>,
7355 alloy::sol_types::sol_data::Bytes,
7356 alloy::sol_types::sol_data::FixedBytes<32>,
7357 alloy::sol_types::sol_data::FixedBytes<32>,
7358 alloy::sol_types::sol_data::Uint<256>,
7359 );
7360 type Token<'a> = <Self::Parameters<
7361 'a,
7362 > as alloy_sol_types::SolType>::Token<'a>;
7363 type Return = scheduleReturn;
7364 type ReturnTuple<'a> = ();
7365 type ReturnToken<'a> = <Self::ReturnTuple<
7366 'a,
7367 > as alloy_sol_types::SolType>::Token<'a>;
7368 const SIGNATURE: &'static str = "schedule(address,uint256,bytes,bytes32,bytes32,uint256)";
7369 const SELECTOR: [u8; 4] = [1u8, 213u8, 6u8, 42u8];
7370 #[inline]
7371 fn new<'a>(
7372 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7373 ) -> Self {
7374 tuple.into()
7375 }
7376 #[inline]
7377 fn tokenize(&self) -> Self::Token<'_> {
7378 (
7379 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7380 &self.target,
7381 ),
7382 <alloy::sol_types::sol_data::Uint<
7383 256,
7384 > as alloy_sol_types::SolType>::tokenize(&self.value),
7385 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
7386 &self.data,
7387 ),
7388 <alloy::sol_types::sol_data::FixedBytes<
7389 32,
7390 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
7391 <alloy::sol_types::sol_data::FixedBytes<
7392 32,
7393 > as alloy_sol_types::SolType>::tokenize(&self.salt),
7394 <alloy::sol_types::sol_data::Uint<
7395 256,
7396 > as alloy_sol_types::SolType>::tokenize(&self.delay),
7397 )
7398 }
7399 #[inline]
7400 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7401 scheduleReturn::_tokenize(ret)
7402 }
7403 #[inline]
7404 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7405 <Self::ReturnTuple<
7406 '_,
7407 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7408 .map(Into::into)
7409 }
7410 #[inline]
7411 fn abi_decode_returns_validate(
7412 data: &[u8],
7413 ) -> alloy_sol_types::Result<Self::Return> {
7414 <Self::ReturnTuple<
7415 '_,
7416 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7417 .map(Into::into)
7418 }
7419 }
7420 };
7421 #[derive(serde::Serialize, serde::Deserialize)]
7422 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7423 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7428 #[derive(Clone)]
7429 pub struct scheduleBatchCall {
7430 #[allow(missing_docs)]
7431 pub targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
7432 #[allow(missing_docs)]
7433 pub values: alloy::sol_types::private::Vec<
7434 alloy::sol_types::private::primitives::aliases::U256,
7435 >,
7436 #[allow(missing_docs)]
7437 pub payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
7438 #[allow(missing_docs)]
7439 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
7440 #[allow(missing_docs)]
7441 pub salt: alloy::sol_types::private::FixedBytes<32>,
7442 #[allow(missing_docs)]
7443 pub delay: alloy::sol_types::private::primitives::aliases::U256,
7444 }
7445 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7447 #[derive(Clone)]
7448 pub struct scheduleBatchReturn {}
7449 #[allow(
7450 non_camel_case_types,
7451 non_snake_case,
7452 clippy::pub_underscore_fields,
7453 clippy::style
7454 )]
7455 const _: () = {
7456 use alloy::sol_types as alloy_sol_types;
7457 {
7458 #[doc(hidden)]
7459 #[allow(dead_code)]
7460 type UnderlyingSolTuple<'a> = (
7461 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
7462 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
7463 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
7464 alloy::sol_types::sol_data::FixedBytes<32>,
7465 alloy::sol_types::sol_data::FixedBytes<32>,
7466 alloy::sol_types::sol_data::Uint<256>,
7467 );
7468 #[doc(hidden)]
7469 type UnderlyingRustTuple<'a> = (
7470 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
7471 alloy::sol_types::private::Vec<
7472 alloy::sol_types::private::primitives::aliases::U256,
7473 >,
7474 alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
7475 alloy::sol_types::private::FixedBytes<32>,
7476 alloy::sol_types::private::FixedBytes<32>,
7477 alloy::sol_types::private::primitives::aliases::U256,
7478 );
7479 #[cfg(test)]
7480 #[allow(dead_code, unreachable_patterns)]
7481 fn _type_assertion(
7482 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7483 ) {
7484 match _t {
7485 alloy_sol_types::private::AssertTypeEq::<
7486 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7487 >(_) => {}
7488 }
7489 }
7490 #[automatically_derived]
7491 #[doc(hidden)]
7492 impl ::core::convert::From<scheduleBatchCall> for UnderlyingRustTuple<'_> {
7493 fn from(value: scheduleBatchCall) -> Self {
7494 (
7495 value.targets,
7496 value.values,
7497 value.payloads,
7498 value.predecessor,
7499 value.salt,
7500 value.delay,
7501 )
7502 }
7503 }
7504 #[automatically_derived]
7505 #[doc(hidden)]
7506 impl ::core::convert::From<UnderlyingRustTuple<'_>> for scheduleBatchCall {
7507 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7508 Self {
7509 targets: tuple.0,
7510 values: tuple.1,
7511 payloads: tuple.2,
7512 predecessor: tuple.3,
7513 salt: tuple.4,
7514 delay: tuple.5,
7515 }
7516 }
7517 }
7518 }
7519 {
7520 #[doc(hidden)]
7521 #[allow(dead_code)]
7522 type UnderlyingSolTuple<'a> = ();
7523 #[doc(hidden)]
7524 type UnderlyingRustTuple<'a> = ();
7525 #[cfg(test)]
7526 #[allow(dead_code, unreachable_patterns)]
7527 fn _type_assertion(
7528 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7529 ) {
7530 match _t {
7531 alloy_sol_types::private::AssertTypeEq::<
7532 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7533 >(_) => {}
7534 }
7535 }
7536 #[automatically_derived]
7537 #[doc(hidden)]
7538 impl ::core::convert::From<scheduleBatchReturn> for UnderlyingRustTuple<'_> {
7539 fn from(value: scheduleBatchReturn) -> Self {
7540 ()
7541 }
7542 }
7543 #[automatically_derived]
7544 #[doc(hidden)]
7545 impl ::core::convert::From<UnderlyingRustTuple<'_>> for scheduleBatchReturn {
7546 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7547 Self {}
7548 }
7549 }
7550 }
7551 impl scheduleBatchReturn {
7552 fn _tokenize(
7553 &self,
7554 ) -> <scheduleBatchCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
7555 ()
7556 }
7557 }
7558 #[automatically_derived]
7559 impl alloy_sol_types::SolCall for scheduleBatchCall {
7560 type Parameters<'a> = (
7561 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
7562 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
7563 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
7564 alloy::sol_types::sol_data::FixedBytes<32>,
7565 alloy::sol_types::sol_data::FixedBytes<32>,
7566 alloy::sol_types::sol_data::Uint<256>,
7567 );
7568 type Token<'a> = <Self::Parameters<
7569 'a,
7570 > as alloy_sol_types::SolType>::Token<'a>;
7571 type Return = scheduleBatchReturn;
7572 type ReturnTuple<'a> = ();
7573 type ReturnToken<'a> = <Self::ReturnTuple<
7574 'a,
7575 > as alloy_sol_types::SolType>::Token<'a>;
7576 const SIGNATURE: &'static str = "scheduleBatch(address[],uint256[],bytes[],bytes32,bytes32,uint256)";
7577 const SELECTOR: [u8; 4] = [143u8, 42u8, 11u8, 176u8];
7578 #[inline]
7579 fn new<'a>(
7580 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7581 ) -> Self {
7582 tuple.into()
7583 }
7584 #[inline]
7585 fn tokenize(&self) -> Self::Token<'_> {
7586 (
7587 <alloy::sol_types::sol_data::Array<
7588 alloy::sol_types::sol_data::Address,
7589 > as alloy_sol_types::SolType>::tokenize(&self.targets),
7590 <alloy::sol_types::sol_data::Array<
7591 alloy::sol_types::sol_data::Uint<256>,
7592 > as alloy_sol_types::SolType>::tokenize(&self.values),
7593 <alloy::sol_types::sol_data::Array<
7594 alloy::sol_types::sol_data::Bytes,
7595 > as alloy_sol_types::SolType>::tokenize(&self.payloads),
7596 <alloy::sol_types::sol_data::FixedBytes<
7597 32,
7598 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
7599 <alloy::sol_types::sol_data::FixedBytes<
7600 32,
7601 > as alloy_sol_types::SolType>::tokenize(&self.salt),
7602 <alloy::sol_types::sol_data::Uint<
7603 256,
7604 > as alloy_sol_types::SolType>::tokenize(&self.delay),
7605 )
7606 }
7607 #[inline]
7608 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7609 scheduleBatchReturn::_tokenize(ret)
7610 }
7611 #[inline]
7612 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7613 <Self::ReturnTuple<
7614 '_,
7615 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7616 .map(Into::into)
7617 }
7618 #[inline]
7619 fn abi_decode_returns_validate(
7620 data: &[u8],
7621 ) -> alloy_sol_types::Result<Self::Return> {
7622 <Self::ReturnTuple<
7623 '_,
7624 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7625 .map(Into::into)
7626 }
7627 }
7628 };
7629 #[derive(serde::Serialize, serde::Deserialize)]
7630 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7631 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7636 #[derive(Clone)]
7637 pub struct supportsInterfaceCall {
7638 #[allow(missing_docs)]
7639 pub interfaceId: alloy::sol_types::private::FixedBytes<4>,
7640 }
7641 #[derive(serde::Serialize, serde::Deserialize)]
7642 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7643 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7645 #[derive(Clone)]
7646 pub struct supportsInterfaceReturn {
7647 #[allow(missing_docs)]
7648 pub _0: bool,
7649 }
7650 #[allow(
7651 non_camel_case_types,
7652 non_snake_case,
7653 clippy::pub_underscore_fields,
7654 clippy::style
7655 )]
7656 const _: () = {
7657 use alloy::sol_types as alloy_sol_types;
7658 {
7659 #[doc(hidden)]
7660 #[allow(dead_code)]
7661 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
7662 #[doc(hidden)]
7663 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
7664 #[cfg(test)]
7665 #[allow(dead_code, unreachable_patterns)]
7666 fn _type_assertion(
7667 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7668 ) {
7669 match _t {
7670 alloy_sol_types::private::AssertTypeEq::<
7671 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7672 >(_) => {}
7673 }
7674 }
7675 #[automatically_derived]
7676 #[doc(hidden)]
7677 impl ::core::convert::From<supportsInterfaceCall>
7678 for UnderlyingRustTuple<'_> {
7679 fn from(value: supportsInterfaceCall) -> Self {
7680 (value.interfaceId,)
7681 }
7682 }
7683 #[automatically_derived]
7684 #[doc(hidden)]
7685 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7686 for supportsInterfaceCall {
7687 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7688 Self { interfaceId: tuple.0 }
7689 }
7690 }
7691 }
7692 {
7693 #[doc(hidden)]
7694 #[allow(dead_code)]
7695 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
7696 #[doc(hidden)]
7697 type UnderlyingRustTuple<'a> = (bool,);
7698 #[cfg(test)]
7699 #[allow(dead_code, unreachable_patterns)]
7700 fn _type_assertion(
7701 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7702 ) {
7703 match _t {
7704 alloy_sol_types::private::AssertTypeEq::<
7705 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7706 >(_) => {}
7707 }
7708 }
7709 #[automatically_derived]
7710 #[doc(hidden)]
7711 impl ::core::convert::From<supportsInterfaceReturn>
7712 for UnderlyingRustTuple<'_> {
7713 fn from(value: supportsInterfaceReturn) -> Self {
7714 (value._0,)
7715 }
7716 }
7717 #[automatically_derived]
7718 #[doc(hidden)]
7719 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7720 for supportsInterfaceReturn {
7721 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7722 Self { _0: tuple.0 }
7723 }
7724 }
7725 }
7726 #[automatically_derived]
7727 impl alloy_sol_types::SolCall for supportsInterfaceCall {
7728 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
7729 type Token<'a> = <Self::Parameters<
7730 'a,
7731 > as alloy_sol_types::SolType>::Token<'a>;
7732 type Return = bool;
7733 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
7734 type ReturnToken<'a> = <Self::ReturnTuple<
7735 'a,
7736 > as alloy_sol_types::SolType>::Token<'a>;
7737 const SIGNATURE: &'static str = "supportsInterface(bytes4)";
7738 const SELECTOR: [u8; 4] = [1u8, 255u8, 201u8, 167u8];
7739 #[inline]
7740 fn new<'a>(
7741 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7742 ) -> Self {
7743 tuple.into()
7744 }
7745 #[inline]
7746 fn tokenize(&self) -> Self::Token<'_> {
7747 (
7748 <alloy::sol_types::sol_data::FixedBytes<
7749 4,
7750 > as alloy_sol_types::SolType>::tokenize(&self.interfaceId),
7751 )
7752 }
7753 #[inline]
7754 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7755 (
7756 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
7757 ret,
7758 ),
7759 )
7760 }
7761 #[inline]
7762 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7763 <Self::ReturnTuple<
7764 '_,
7765 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7766 .map(|r| {
7767 let r: supportsInterfaceReturn = r.into();
7768 r._0
7769 })
7770 }
7771 #[inline]
7772 fn abi_decode_returns_validate(
7773 data: &[u8],
7774 ) -> alloy_sol_types::Result<Self::Return> {
7775 <Self::ReturnTuple<
7776 '_,
7777 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7778 .map(|r| {
7779 let r: supportsInterfaceReturn = r.into();
7780 r._0
7781 })
7782 }
7783 }
7784 };
7785 #[derive(serde::Serialize, serde::Deserialize)]
7786 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7787 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7792 #[derive(Clone)]
7793 pub struct updateDelayCall {
7794 #[allow(missing_docs)]
7795 pub newDelay: alloy::sol_types::private::primitives::aliases::U256,
7796 }
7797 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7799 #[derive(Clone)]
7800 pub struct updateDelayReturn {}
7801 #[allow(
7802 non_camel_case_types,
7803 non_snake_case,
7804 clippy::pub_underscore_fields,
7805 clippy::style
7806 )]
7807 const _: () = {
7808 use alloy::sol_types as alloy_sol_types;
7809 {
7810 #[doc(hidden)]
7811 #[allow(dead_code)]
7812 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7813 #[doc(hidden)]
7814 type UnderlyingRustTuple<'a> = (
7815 alloy::sol_types::private::primitives::aliases::U256,
7816 );
7817 #[cfg(test)]
7818 #[allow(dead_code, unreachable_patterns)]
7819 fn _type_assertion(
7820 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7821 ) {
7822 match _t {
7823 alloy_sol_types::private::AssertTypeEq::<
7824 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7825 >(_) => {}
7826 }
7827 }
7828 #[automatically_derived]
7829 #[doc(hidden)]
7830 impl ::core::convert::From<updateDelayCall> for UnderlyingRustTuple<'_> {
7831 fn from(value: updateDelayCall) -> Self {
7832 (value.newDelay,)
7833 }
7834 }
7835 #[automatically_derived]
7836 #[doc(hidden)]
7837 impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateDelayCall {
7838 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7839 Self { newDelay: tuple.0 }
7840 }
7841 }
7842 }
7843 {
7844 #[doc(hidden)]
7845 #[allow(dead_code)]
7846 type UnderlyingSolTuple<'a> = ();
7847 #[doc(hidden)]
7848 type UnderlyingRustTuple<'a> = ();
7849 #[cfg(test)]
7850 #[allow(dead_code, unreachable_patterns)]
7851 fn _type_assertion(
7852 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7853 ) {
7854 match _t {
7855 alloy_sol_types::private::AssertTypeEq::<
7856 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7857 >(_) => {}
7858 }
7859 }
7860 #[automatically_derived]
7861 #[doc(hidden)]
7862 impl ::core::convert::From<updateDelayReturn> for UnderlyingRustTuple<'_> {
7863 fn from(value: updateDelayReturn) -> Self {
7864 ()
7865 }
7866 }
7867 #[automatically_derived]
7868 #[doc(hidden)]
7869 impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateDelayReturn {
7870 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7871 Self {}
7872 }
7873 }
7874 }
7875 impl updateDelayReturn {
7876 fn _tokenize(
7877 &self,
7878 ) -> <updateDelayCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
7879 ()
7880 }
7881 }
7882 #[automatically_derived]
7883 impl alloy_sol_types::SolCall for updateDelayCall {
7884 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7885 type Token<'a> = <Self::Parameters<
7886 'a,
7887 > as alloy_sol_types::SolType>::Token<'a>;
7888 type Return = updateDelayReturn;
7889 type ReturnTuple<'a> = ();
7890 type ReturnToken<'a> = <Self::ReturnTuple<
7891 'a,
7892 > as alloy_sol_types::SolType>::Token<'a>;
7893 const SIGNATURE: &'static str = "updateDelay(uint256)";
7894 const SELECTOR: [u8; 4] = [100u8, 214u8, 35u8, 83u8];
7895 #[inline]
7896 fn new<'a>(
7897 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7898 ) -> Self {
7899 tuple.into()
7900 }
7901 #[inline]
7902 fn tokenize(&self) -> Self::Token<'_> {
7903 (
7904 <alloy::sol_types::sol_data::Uint<
7905 256,
7906 > as alloy_sol_types::SolType>::tokenize(&self.newDelay),
7907 )
7908 }
7909 #[inline]
7910 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7911 updateDelayReturn::_tokenize(ret)
7912 }
7913 #[inline]
7914 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7915 <Self::ReturnTuple<
7916 '_,
7917 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7918 .map(Into::into)
7919 }
7920 #[inline]
7921 fn abi_decode_returns_validate(
7922 data: &[u8],
7923 ) -> alloy_sol_types::Result<Self::Return> {
7924 <Self::ReturnTuple<
7925 '_,
7926 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7927 .map(Into::into)
7928 }
7929 }
7930 };
7931 #[derive(serde::Serialize, serde::Deserialize)]
7933 #[derive()]
7934 pub enum OpsTimelockCalls {
7935 #[allow(missing_docs)]
7936 CANCELLER_ROLE(CANCELLER_ROLECall),
7937 #[allow(missing_docs)]
7938 DEFAULT_ADMIN_ROLE(DEFAULT_ADMIN_ROLECall),
7939 #[allow(missing_docs)]
7940 EXECUTOR_ROLE(EXECUTOR_ROLECall),
7941 #[allow(missing_docs)]
7942 PROPOSER_ROLE(PROPOSER_ROLECall),
7943 #[allow(missing_docs)]
7944 cancel(cancelCall),
7945 #[allow(missing_docs)]
7946 execute(executeCall),
7947 #[allow(missing_docs)]
7948 executeBatch(executeBatchCall),
7949 #[allow(missing_docs)]
7950 getMinDelay(getMinDelayCall),
7951 #[allow(missing_docs)]
7952 getOperationState(getOperationStateCall),
7953 #[allow(missing_docs)]
7954 getRoleAdmin(getRoleAdminCall),
7955 #[allow(missing_docs)]
7956 getTimestamp(getTimestampCall),
7957 #[allow(missing_docs)]
7958 grantRole(grantRoleCall),
7959 #[allow(missing_docs)]
7960 hasRole(hasRoleCall),
7961 #[allow(missing_docs)]
7962 hashOperation(hashOperationCall),
7963 #[allow(missing_docs)]
7964 hashOperationBatch(hashOperationBatchCall),
7965 #[allow(missing_docs)]
7966 isOperation(isOperationCall),
7967 #[allow(missing_docs)]
7968 isOperationDone(isOperationDoneCall),
7969 #[allow(missing_docs)]
7970 isOperationPending(isOperationPendingCall),
7971 #[allow(missing_docs)]
7972 isOperationReady(isOperationReadyCall),
7973 #[allow(missing_docs)]
7974 onERC1155BatchReceived(onERC1155BatchReceivedCall),
7975 #[allow(missing_docs)]
7976 onERC1155Received(onERC1155ReceivedCall),
7977 #[allow(missing_docs)]
7978 onERC721Received(onERC721ReceivedCall),
7979 #[allow(missing_docs)]
7980 renounceRole(renounceRoleCall),
7981 #[allow(missing_docs)]
7982 revokeRole(revokeRoleCall),
7983 #[allow(missing_docs)]
7984 schedule(scheduleCall),
7985 #[allow(missing_docs)]
7986 scheduleBatch(scheduleBatchCall),
7987 #[allow(missing_docs)]
7988 supportsInterface(supportsInterfaceCall),
7989 #[allow(missing_docs)]
7990 updateDelay(updateDelayCall),
7991 }
7992 #[automatically_derived]
7993 impl OpsTimelockCalls {
7994 pub const SELECTORS: &'static [[u8; 4usize]] = &[
8001 [1u8, 213u8, 6u8, 42u8],
8002 [1u8, 255u8, 201u8, 167u8],
8003 [7u8, 189u8, 2u8, 101u8],
8004 [19u8, 64u8, 8u8, 211u8],
8005 [19u8, 188u8, 159u8, 32u8],
8006 [21u8, 11u8, 122u8, 2u8],
8007 [36u8, 138u8, 156u8, 163u8],
8008 [42u8, 176u8, 245u8, 41u8],
8009 [47u8, 47u8, 241u8, 93u8],
8010 [49u8, 213u8, 7u8, 80u8],
8011 [54u8, 86u8, 138u8, 190u8],
8012 [88u8, 75u8, 21u8, 62u8],
8013 [100u8, 214u8, 35u8, 83u8],
8014 [121u8, 88u8, 0u8, 76u8],
8015 [128u8, 101u8, 101u8, 127u8],
8016 [143u8, 42u8, 11u8, 176u8],
8017 [143u8, 97u8, 244u8, 245u8],
8018 [145u8, 209u8, 72u8, 84u8],
8019 [162u8, 23u8, 253u8, 223u8],
8020 [176u8, 142u8, 81u8, 192u8],
8021 [177u8, 197u8, 244u8, 39u8],
8022 [188u8, 25u8, 124u8, 129u8],
8023 [196u8, 210u8, 82u8, 245u8],
8024 [212u8, 92u8, 68u8, 53u8],
8025 [213u8, 71u8, 116u8, 31u8],
8026 [227u8, 131u8, 53u8, 229u8],
8027 [242u8, 58u8, 110u8, 97u8],
8028 [242u8, 122u8, 12u8, 146u8],
8029 ];
8030 }
8031 #[automatically_derived]
8032 impl alloy_sol_types::SolInterface for OpsTimelockCalls {
8033 const NAME: &'static str = "OpsTimelockCalls";
8034 const MIN_DATA_LENGTH: usize = 0usize;
8035 const COUNT: usize = 28usize;
8036 #[inline]
8037 fn selector(&self) -> [u8; 4] {
8038 match self {
8039 Self::CANCELLER_ROLE(_) => {
8040 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::SELECTOR
8041 }
8042 Self::DEFAULT_ADMIN_ROLE(_) => {
8043 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::SELECTOR
8044 }
8045 Self::EXECUTOR_ROLE(_) => {
8046 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::SELECTOR
8047 }
8048 Self::PROPOSER_ROLE(_) => {
8049 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::SELECTOR
8050 }
8051 Self::cancel(_) => <cancelCall as alloy_sol_types::SolCall>::SELECTOR,
8052 Self::execute(_) => <executeCall as alloy_sol_types::SolCall>::SELECTOR,
8053 Self::executeBatch(_) => {
8054 <executeBatchCall as alloy_sol_types::SolCall>::SELECTOR
8055 }
8056 Self::getMinDelay(_) => {
8057 <getMinDelayCall as alloy_sol_types::SolCall>::SELECTOR
8058 }
8059 Self::getOperationState(_) => {
8060 <getOperationStateCall as alloy_sol_types::SolCall>::SELECTOR
8061 }
8062 Self::getRoleAdmin(_) => {
8063 <getRoleAdminCall as alloy_sol_types::SolCall>::SELECTOR
8064 }
8065 Self::getTimestamp(_) => {
8066 <getTimestampCall as alloy_sol_types::SolCall>::SELECTOR
8067 }
8068 Self::grantRole(_) => {
8069 <grantRoleCall as alloy_sol_types::SolCall>::SELECTOR
8070 }
8071 Self::hasRole(_) => <hasRoleCall as alloy_sol_types::SolCall>::SELECTOR,
8072 Self::hashOperation(_) => {
8073 <hashOperationCall as alloy_sol_types::SolCall>::SELECTOR
8074 }
8075 Self::hashOperationBatch(_) => {
8076 <hashOperationBatchCall as alloy_sol_types::SolCall>::SELECTOR
8077 }
8078 Self::isOperation(_) => {
8079 <isOperationCall as alloy_sol_types::SolCall>::SELECTOR
8080 }
8081 Self::isOperationDone(_) => {
8082 <isOperationDoneCall as alloy_sol_types::SolCall>::SELECTOR
8083 }
8084 Self::isOperationPending(_) => {
8085 <isOperationPendingCall as alloy_sol_types::SolCall>::SELECTOR
8086 }
8087 Self::isOperationReady(_) => {
8088 <isOperationReadyCall as alloy_sol_types::SolCall>::SELECTOR
8089 }
8090 Self::onERC1155BatchReceived(_) => {
8091 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::SELECTOR
8092 }
8093 Self::onERC1155Received(_) => {
8094 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
8095 }
8096 Self::onERC721Received(_) => {
8097 <onERC721ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
8098 }
8099 Self::renounceRole(_) => {
8100 <renounceRoleCall as alloy_sol_types::SolCall>::SELECTOR
8101 }
8102 Self::revokeRole(_) => {
8103 <revokeRoleCall as alloy_sol_types::SolCall>::SELECTOR
8104 }
8105 Self::schedule(_) => <scheduleCall as alloy_sol_types::SolCall>::SELECTOR,
8106 Self::scheduleBatch(_) => {
8107 <scheduleBatchCall as alloy_sol_types::SolCall>::SELECTOR
8108 }
8109 Self::supportsInterface(_) => {
8110 <supportsInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
8111 }
8112 Self::updateDelay(_) => {
8113 <updateDelayCall as alloy_sol_types::SolCall>::SELECTOR
8114 }
8115 }
8116 }
8117 #[inline]
8118 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
8119 Self::SELECTORS.get(i).copied()
8120 }
8121 #[inline]
8122 fn valid_selector(selector: [u8; 4]) -> bool {
8123 Self::SELECTORS.binary_search(&selector).is_ok()
8124 }
8125 #[inline]
8126 #[allow(non_snake_case)]
8127 fn abi_decode_raw(
8128 selector: [u8; 4],
8129 data: &[u8],
8130 ) -> alloy_sol_types::Result<Self> {
8131 static DECODE_SHIMS: &[fn(
8132 &[u8],
8133 ) -> alloy_sol_types::Result<OpsTimelockCalls>] = &[
8134 {
8135 fn schedule(
8136 data: &[u8],
8137 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8138 <scheduleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
8139 .map(OpsTimelockCalls::schedule)
8140 }
8141 schedule
8142 },
8143 {
8144 fn supportsInterface(
8145 data: &[u8],
8146 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8147 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(
8148 data,
8149 )
8150 .map(OpsTimelockCalls::supportsInterface)
8151 }
8152 supportsInterface
8153 },
8154 {
8155 fn EXECUTOR_ROLE(
8156 data: &[u8],
8157 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8158 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
8159 data,
8160 )
8161 .map(OpsTimelockCalls::EXECUTOR_ROLE)
8162 }
8163 EXECUTOR_ROLE
8164 },
8165 {
8166 fn execute(
8167 data: &[u8],
8168 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8169 <executeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
8170 .map(OpsTimelockCalls::execute)
8171 }
8172 execute
8173 },
8174 {
8175 fn isOperationReady(
8176 data: &[u8],
8177 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8178 <isOperationReadyCall as alloy_sol_types::SolCall>::abi_decode_raw(
8179 data,
8180 )
8181 .map(OpsTimelockCalls::isOperationReady)
8182 }
8183 isOperationReady
8184 },
8185 {
8186 fn onERC721Received(
8187 data: &[u8],
8188 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8189 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
8190 data,
8191 )
8192 .map(OpsTimelockCalls::onERC721Received)
8193 }
8194 onERC721Received
8195 },
8196 {
8197 fn getRoleAdmin(
8198 data: &[u8],
8199 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8200 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
8201 data,
8202 )
8203 .map(OpsTimelockCalls::getRoleAdmin)
8204 }
8205 getRoleAdmin
8206 },
8207 {
8208 fn isOperationDone(
8209 data: &[u8],
8210 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8211 <isOperationDoneCall as alloy_sol_types::SolCall>::abi_decode_raw(
8212 data,
8213 )
8214 .map(OpsTimelockCalls::isOperationDone)
8215 }
8216 isOperationDone
8217 },
8218 {
8219 fn grantRole(
8220 data: &[u8],
8221 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8222 <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
8223 .map(OpsTimelockCalls::grantRole)
8224 }
8225 grantRole
8226 },
8227 {
8228 fn isOperation(
8229 data: &[u8],
8230 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8231 <isOperationCall as alloy_sol_types::SolCall>::abi_decode_raw(
8232 data,
8233 )
8234 .map(OpsTimelockCalls::isOperation)
8235 }
8236 isOperation
8237 },
8238 {
8239 fn renounceRole(
8240 data: &[u8],
8241 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8242 <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
8243 data,
8244 )
8245 .map(OpsTimelockCalls::renounceRole)
8246 }
8247 renounceRole
8248 },
8249 {
8250 fn isOperationPending(
8251 data: &[u8],
8252 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8253 <isOperationPendingCall as alloy_sol_types::SolCall>::abi_decode_raw(
8254 data,
8255 )
8256 .map(OpsTimelockCalls::isOperationPending)
8257 }
8258 isOperationPending
8259 },
8260 {
8261 fn updateDelay(
8262 data: &[u8],
8263 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8264 <updateDelayCall as alloy_sol_types::SolCall>::abi_decode_raw(
8265 data,
8266 )
8267 .map(OpsTimelockCalls::updateDelay)
8268 }
8269 updateDelay
8270 },
8271 {
8272 fn getOperationState(
8273 data: &[u8],
8274 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8275 <getOperationStateCall as alloy_sol_types::SolCall>::abi_decode_raw(
8276 data,
8277 )
8278 .map(OpsTimelockCalls::getOperationState)
8279 }
8280 getOperationState
8281 },
8282 {
8283 fn hashOperation(
8284 data: &[u8],
8285 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8286 <hashOperationCall as alloy_sol_types::SolCall>::abi_decode_raw(
8287 data,
8288 )
8289 .map(OpsTimelockCalls::hashOperation)
8290 }
8291 hashOperation
8292 },
8293 {
8294 fn scheduleBatch(
8295 data: &[u8],
8296 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8297 <scheduleBatchCall as alloy_sol_types::SolCall>::abi_decode_raw(
8298 data,
8299 )
8300 .map(OpsTimelockCalls::scheduleBatch)
8301 }
8302 scheduleBatch
8303 },
8304 {
8305 fn PROPOSER_ROLE(
8306 data: &[u8],
8307 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8308 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
8309 data,
8310 )
8311 .map(OpsTimelockCalls::PROPOSER_ROLE)
8312 }
8313 PROPOSER_ROLE
8314 },
8315 {
8316 fn hasRole(
8317 data: &[u8],
8318 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8319 <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
8320 .map(OpsTimelockCalls::hasRole)
8321 }
8322 hasRole
8323 },
8324 {
8325 fn DEFAULT_ADMIN_ROLE(
8326 data: &[u8],
8327 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8328 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
8329 data,
8330 )
8331 .map(OpsTimelockCalls::DEFAULT_ADMIN_ROLE)
8332 }
8333 DEFAULT_ADMIN_ROLE
8334 },
8335 {
8336 fn CANCELLER_ROLE(
8337 data: &[u8],
8338 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8339 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
8340 data,
8341 )
8342 .map(OpsTimelockCalls::CANCELLER_ROLE)
8343 }
8344 CANCELLER_ROLE
8345 },
8346 {
8347 fn hashOperationBatch(
8348 data: &[u8],
8349 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8350 <hashOperationBatchCall as alloy_sol_types::SolCall>::abi_decode_raw(
8351 data,
8352 )
8353 .map(OpsTimelockCalls::hashOperationBatch)
8354 }
8355 hashOperationBatch
8356 },
8357 {
8358 fn onERC1155BatchReceived(
8359 data: &[u8],
8360 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8361 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
8362 data,
8363 )
8364 .map(OpsTimelockCalls::onERC1155BatchReceived)
8365 }
8366 onERC1155BatchReceived
8367 },
8368 {
8369 fn cancel(data: &[u8]) -> alloy_sol_types::Result<OpsTimelockCalls> {
8370 <cancelCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
8371 .map(OpsTimelockCalls::cancel)
8372 }
8373 cancel
8374 },
8375 {
8376 fn getTimestamp(
8377 data: &[u8],
8378 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8379 <getTimestampCall as alloy_sol_types::SolCall>::abi_decode_raw(
8380 data,
8381 )
8382 .map(OpsTimelockCalls::getTimestamp)
8383 }
8384 getTimestamp
8385 },
8386 {
8387 fn revokeRole(
8388 data: &[u8],
8389 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8390 <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
8391 data,
8392 )
8393 .map(OpsTimelockCalls::revokeRole)
8394 }
8395 revokeRole
8396 },
8397 {
8398 fn executeBatch(
8399 data: &[u8],
8400 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8401 <executeBatchCall as alloy_sol_types::SolCall>::abi_decode_raw(
8402 data,
8403 )
8404 .map(OpsTimelockCalls::executeBatch)
8405 }
8406 executeBatch
8407 },
8408 {
8409 fn onERC1155Received(
8410 data: &[u8],
8411 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8412 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
8413 data,
8414 )
8415 .map(OpsTimelockCalls::onERC1155Received)
8416 }
8417 onERC1155Received
8418 },
8419 {
8420 fn getMinDelay(
8421 data: &[u8],
8422 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8423 <getMinDelayCall as alloy_sol_types::SolCall>::abi_decode_raw(
8424 data,
8425 )
8426 .map(OpsTimelockCalls::getMinDelay)
8427 }
8428 getMinDelay
8429 },
8430 ];
8431 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
8432 return Err(
8433 alloy_sol_types::Error::unknown_selector(
8434 <Self as alloy_sol_types::SolInterface>::NAME,
8435 selector,
8436 ),
8437 );
8438 };
8439 DECODE_SHIMS[idx](data)
8440 }
8441 #[inline]
8442 #[allow(non_snake_case)]
8443 fn abi_decode_raw_validate(
8444 selector: [u8; 4],
8445 data: &[u8],
8446 ) -> alloy_sol_types::Result<Self> {
8447 static DECODE_VALIDATE_SHIMS: &[fn(
8448 &[u8],
8449 ) -> alloy_sol_types::Result<OpsTimelockCalls>] = &[
8450 {
8451 fn schedule(
8452 data: &[u8],
8453 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8454 <scheduleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8455 data,
8456 )
8457 .map(OpsTimelockCalls::schedule)
8458 }
8459 schedule
8460 },
8461 {
8462 fn supportsInterface(
8463 data: &[u8],
8464 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8465 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8466 data,
8467 )
8468 .map(OpsTimelockCalls::supportsInterface)
8469 }
8470 supportsInterface
8471 },
8472 {
8473 fn EXECUTOR_ROLE(
8474 data: &[u8],
8475 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8476 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8477 data,
8478 )
8479 .map(OpsTimelockCalls::EXECUTOR_ROLE)
8480 }
8481 EXECUTOR_ROLE
8482 },
8483 {
8484 fn execute(
8485 data: &[u8],
8486 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8487 <executeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8488 data,
8489 )
8490 .map(OpsTimelockCalls::execute)
8491 }
8492 execute
8493 },
8494 {
8495 fn isOperationReady(
8496 data: &[u8],
8497 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8498 <isOperationReadyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8499 data,
8500 )
8501 .map(OpsTimelockCalls::isOperationReady)
8502 }
8503 isOperationReady
8504 },
8505 {
8506 fn onERC721Received(
8507 data: &[u8],
8508 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8509 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8510 data,
8511 )
8512 .map(OpsTimelockCalls::onERC721Received)
8513 }
8514 onERC721Received
8515 },
8516 {
8517 fn getRoleAdmin(
8518 data: &[u8],
8519 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8520 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8521 data,
8522 )
8523 .map(OpsTimelockCalls::getRoleAdmin)
8524 }
8525 getRoleAdmin
8526 },
8527 {
8528 fn isOperationDone(
8529 data: &[u8],
8530 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8531 <isOperationDoneCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8532 data,
8533 )
8534 .map(OpsTimelockCalls::isOperationDone)
8535 }
8536 isOperationDone
8537 },
8538 {
8539 fn grantRole(
8540 data: &[u8],
8541 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8542 <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8543 data,
8544 )
8545 .map(OpsTimelockCalls::grantRole)
8546 }
8547 grantRole
8548 },
8549 {
8550 fn isOperation(
8551 data: &[u8],
8552 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8553 <isOperationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8554 data,
8555 )
8556 .map(OpsTimelockCalls::isOperation)
8557 }
8558 isOperation
8559 },
8560 {
8561 fn renounceRole(
8562 data: &[u8],
8563 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8564 <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8565 data,
8566 )
8567 .map(OpsTimelockCalls::renounceRole)
8568 }
8569 renounceRole
8570 },
8571 {
8572 fn isOperationPending(
8573 data: &[u8],
8574 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8575 <isOperationPendingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8576 data,
8577 )
8578 .map(OpsTimelockCalls::isOperationPending)
8579 }
8580 isOperationPending
8581 },
8582 {
8583 fn updateDelay(
8584 data: &[u8],
8585 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8586 <updateDelayCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8587 data,
8588 )
8589 .map(OpsTimelockCalls::updateDelay)
8590 }
8591 updateDelay
8592 },
8593 {
8594 fn getOperationState(
8595 data: &[u8],
8596 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8597 <getOperationStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8598 data,
8599 )
8600 .map(OpsTimelockCalls::getOperationState)
8601 }
8602 getOperationState
8603 },
8604 {
8605 fn hashOperation(
8606 data: &[u8],
8607 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8608 <hashOperationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8609 data,
8610 )
8611 .map(OpsTimelockCalls::hashOperation)
8612 }
8613 hashOperation
8614 },
8615 {
8616 fn scheduleBatch(
8617 data: &[u8],
8618 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8619 <scheduleBatchCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8620 data,
8621 )
8622 .map(OpsTimelockCalls::scheduleBatch)
8623 }
8624 scheduleBatch
8625 },
8626 {
8627 fn PROPOSER_ROLE(
8628 data: &[u8],
8629 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8630 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8631 data,
8632 )
8633 .map(OpsTimelockCalls::PROPOSER_ROLE)
8634 }
8635 PROPOSER_ROLE
8636 },
8637 {
8638 fn hasRole(
8639 data: &[u8],
8640 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8641 <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8642 data,
8643 )
8644 .map(OpsTimelockCalls::hasRole)
8645 }
8646 hasRole
8647 },
8648 {
8649 fn DEFAULT_ADMIN_ROLE(
8650 data: &[u8],
8651 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8652 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8653 data,
8654 )
8655 .map(OpsTimelockCalls::DEFAULT_ADMIN_ROLE)
8656 }
8657 DEFAULT_ADMIN_ROLE
8658 },
8659 {
8660 fn CANCELLER_ROLE(
8661 data: &[u8],
8662 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8663 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8664 data,
8665 )
8666 .map(OpsTimelockCalls::CANCELLER_ROLE)
8667 }
8668 CANCELLER_ROLE
8669 },
8670 {
8671 fn hashOperationBatch(
8672 data: &[u8],
8673 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8674 <hashOperationBatchCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8675 data,
8676 )
8677 .map(OpsTimelockCalls::hashOperationBatch)
8678 }
8679 hashOperationBatch
8680 },
8681 {
8682 fn onERC1155BatchReceived(
8683 data: &[u8],
8684 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8685 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8686 data,
8687 )
8688 .map(OpsTimelockCalls::onERC1155BatchReceived)
8689 }
8690 onERC1155BatchReceived
8691 },
8692 {
8693 fn cancel(data: &[u8]) -> alloy_sol_types::Result<OpsTimelockCalls> {
8694 <cancelCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8695 data,
8696 )
8697 .map(OpsTimelockCalls::cancel)
8698 }
8699 cancel
8700 },
8701 {
8702 fn getTimestamp(
8703 data: &[u8],
8704 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8705 <getTimestampCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8706 data,
8707 )
8708 .map(OpsTimelockCalls::getTimestamp)
8709 }
8710 getTimestamp
8711 },
8712 {
8713 fn revokeRole(
8714 data: &[u8],
8715 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8716 <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8717 data,
8718 )
8719 .map(OpsTimelockCalls::revokeRole)
8720 }
8721 revokeRole
8722 },
8723 {
8724 fn executeBatch(
8725 data: &[u8],
8726 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8727 <executeBatchCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8728 data,
8729 )
8730 .map(OpsTimelockCalls::executeBatch)
8731 }
8732 executeBatch
8733 },
8734 {
8735 fn onERC1155Received(
8736 data: &[u8],
8737 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8738 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8739 data,
8740 )
8741 .map(OpsTimelockCalls::onERC1155Received)
8742 }
8743 onERC1155Received
8744 },
8745 {
8746 fn getMinDelay(
8747 data: &[u8],
8748 ) -> alloy_sol_types::Result<OpsTimelockCalls> {
8749 <getMinDelayCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8750 data,
8751 )
8752 .map(OpsTimelockCalls::getMinDelay)
8753 }
8754 getMinDelay
8755 },
8756 ];
8757 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
8758 return Err(
8759 alloy_sol_types::Error::unknown_selector(
8760 <Self as alloy_sol_types::SolInterface>::NAME,
8761 selector,
8762 ),
8763 );
8764 };
8765 DECODE_VALIDATE_SHIMS[idx](data)
8766 }
8767 #[inline]
8768 fn abi_encoded_size(&self) -> usize {
8769 match self {
8770 Self::CANCELLER_ROLE(inner) => {
8771 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
8772 inner,
8773 )
8774 }
8775 Self::DEFAULT_ADMIN_ROLE(inner) => {
8776 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
8777 inner,
8778 )
8779 }
8780 Self::EXECUTOR_ROLE(inner) => {
8781 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
8782 inner,
8783 )
8784 }
8785 Self::PROPOSER_ROLE(inner) => {
8786 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
8787 inner,
8788 )
8789 }
8790 Self::cancel(inner) => {
8791 <cancelCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8792 }
8793 Self::execute(inner) => {
8794 <executeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8795 }
8796 Self::executeBatch(inner) => {
8797 <executeBatchCall as alloy_sol_types::SolCall>::abi_encoded_size(
8798 inner,
8799 )
8800 }
8801 Self::getMinDelay(inner) => {
8802 <getMinDelayCall as alloy_sol_types::SolCall>::abi_encoded_size(
8803 inner,
8804 )
8805 }
8806 Self::getOperationState(inner) => {
8807 <getOperationStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
8808 inner,
8809 )
8810 }
8811 Self::getRoleAdmin(inner) => {
8812 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
8813 inner,
8814 )
8815 }
8816 Self::getTimestamp(inner) => {
8817 <getTimestampCall as alloy_sol_types::SolCall>::abi_encoded_size(
8818 inner,
8819 )
8820 }
8821 Self::grantRole(inner) => {
8822 <grantRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8823 }
8824 Self::hasRole(inner) => {
8825 <hasRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8826 }
8827 Self::hashOperation(inner) => {
8828 <hashOperationCall as alloy_sol_types::SolCall>::abi_encoded_size(
8829 inner,
8830 )
8831 }
8832 Self::hashOperationBatch(inner) => {
8833 <hashOperationBatchCall as alloy_sol_types::SolCall>::abi_encoded_size(
8834 inner,
8835 )
8836 }
8837 Self::isOperation(inner) => {
8838 <isOperationCall as alloy_sol_types::SolCall>::abi_encoded_size(
8839 inner,
8840 )
8841 }
8842 Self::isOperationDone(inner) => {
8843 <isOperationDoneCall as alloy_sol_types::SolCall>::abi_encoded_size(
8844 inner,
8845 )
8846 }
8847 Self::isOperationPending(inner) => {
8848 <isOperationPendingCall as alloy_sol_types::SolCall>::abi_encoded_size(
8849 inner,
8850 )
8851 }
8852 Self::isOperationReady(inner) => {
8853 <isOperationReadyCall as alloy_sol_types::SolCall>::abi_encoded_size(
8854 inner,
8855 )
8856 }
8857 Self::onERC1155BatchReceived(inner) => {
8858 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
8859 inner,
8860 )
8861 }
8862 Self::onERC1155Received(inner) => {
8863 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
8864 inner,
8865 )
8866 }
8867 Self::onERC721Received(inner) => {
8868 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
8869 inner,
8870 )
8871 }
8872 Self::renounceRole(inner) => {
8873 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(
8874 inner,
8875 )
8876 }
8877 Self::revokeRole(inner) => {
8878 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8879 }
8880 Self::schedule(inner) => {
8881 <scheduleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8882 }
8883 Self::scheduleBatch(inner) => {
8884 <scheduleBatchCall as alloy_sol_types::SolCall>::abi_encoded_size(
8885 inner,
8886 )
8887 }
8888 Self::supportsInterface(inner) => {
8889 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(
8890 inner,
8891 )
8892 }
8893 Self::updateDelay(inner) => {
8894 <updateDelayCall as alloy_sol_types::SolCall>::abi_encoded_size(
8895 inner,
8896 )
8897 }
8898 }
8899 }
8900 #[inline]
8901 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
8902 match self {
8903 Self::CANCELLER_ROLE(inner) => {
8904 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
8905 inner,
8906 out,
8907 )
8908 }
8909 Self::DEFAULT_ADMIN_ROLE(inner) => {
8910 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
8911 inner,
8912 out,
8913 )
8914 }
8915 Self::EXECUTOR_ROLE(inner) => {
8916 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
8917 inner,
8918 out,
8919 )
8920 }
8921 Self::PROPOSER_ROLE(inner) => {
8922 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
8923 inner,
8924 out,
8925 )
8926 }
8927 Self::cancel(inner) => {
8928 <cancelCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8929 }
8930 Self::execute(inner) => {
8931 <executeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8932 }
8933 Self::executeBatch(inner) => {
8934 <executeBatchCall as alloy_sol_types::SolCall>::abi_encode_raw(
8935 inner,
8936 out,
8937 )
8938 }
8939 Self::getMinDelay(inner) => {
8940 <getMinDelayCall as alloy_sol_types::SolCall>::abi_encode_raw(
8941 inner,
8942 out,
8943 )
8944 }
8945 Self::getOperationState(inner) => {
8946 <getOperationStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
8947 inner,
8948 out,
8949 )
8950 }
8951 Self::getRoleAdmin(inner) => {
8952 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
8953 inner,
8954 out,
8955 )
8956 }
8957 Self::getTimestamp(inner) => {
8958 <getTimestampCall as alloy_sol_types::SolCall>::abi_encode_raw(
8959 inner,
8960 out,
8961 )
8962 }
8963 Self::grantRole(inner) => {
8964 <grantRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
8965 inner,
8966 out,
8967 )
8968 }
8969 Self::hasRole(inner) => {
8970 <hasRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8971 }
8972 Self::hashOperation(inner) => {
8973 <hashOperationCall as alloy_sol_types::SolCall>::abi_encode_raw(
8974 inner,
8975 out,
8976 )
8977 }
8978 Self::hashOperationBatch(inner) => {
8979 <hashOperationBatchCall as alloy_sol_types::SolCall>::abi_encode_raw(
8980 inner,
8981 out,
8982 )
8983 }
8984 Self::isOperation(inner) => {
8985 <isOperationCall as alloy_sol_types::SolCall>::abi_encode_raw(
8986 inner,
8987 out,
8988 )
8989 }
8990 Self::isOperationDone(inner) => {
8991 <isOperationDoneCall as alloy_sol_types::SolCall>::abi_encode_raw(
8992 inner,
8993 out,
8994 )
8995 }
8996 Self::isOperationPending(inner) => {
8997 <isOperationPendingCall as alloy_sol_types::SolCall>::abi_encode_raw(
8998 inner,
8999 out,
9000 )
9001 }
9002 Self::isOperationReady(inner) => {
9003 <isOperationReadyCall as alloy_sol_types::SolCall>::abi_encode_raw(
9004 inner,
9005 out,
9006 )
9007 }
9008 Self::onERC1155BatchReceived(inner) => {
9009 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
9010 inner,
9011 out,
9012 )
9013 }
9014 Self::onERC1155Received(inner) => {
9015 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
9016 inner,
9017 out,
9018 )
9019 }
9020 Self::onERC721Received(inner) => {
9021 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
9022 inner,
9023 out,
9024 )
9025 }
9026 Self::renounceRole(inner) => {
9027 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
9028 inner,
9029 out,
9030 )
9031 }
9032 Self::revokeRole(inner) => {
9033 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
9034 inner,
9035 out,
9036 )
9037 }
9038 Self::schedule(inner) => {
9039 <scheduleCall as alloy_sol_types::SolCall>::abi_encode_raw(
9040 inner,
9041 out,
9042 )
9043 }
9044 Self::scheduleBatch(inner) => {
9045 <scheduleBatchCall as alloy_sol_types::SolCall>::abi_encode_raw(
9046 inner,
9047 out,
9048 )
9049 }
9050 Self::supportsInterface(inner) => {
9051 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(
9052 inner,
9053 out,
9054 )
9055 }
9056 Self::updateDelay(inner) => {
9057 <updateDelayCall as alloy_sol_types::SolCall>::abi_encode_raw(
9058 inner,
9059 out,
9060 )
9061 }
9062 }
9063 }
9064 }
9065 #[derive(serde::Serialize, serde::Deserialize)]
9067 #[derive(Debug, PartialEq, Eq, Hash)]
9068 pub enum OpsTimelockErrors {
9069 #[allow(missing_docs)]
9070 AccessControlBadConfirmation(AccessControlBadConfirmation),
9071 #[allow(missing_docs)]
9072 AccessControlUnauthorizedAccount(AccessControlUnauthorizedAccount),
9073 #[allow(missing_docs)]
9074 FailedInnerCall(FailedInnerCall),
9075 #[allow(missing_docs)]
9076 TimelockInsufficientDelay(TimelockInsufficientDelay),
9077 #[allow(missing_docs)]
9078 TimelockInvalidOperationLength(TimelockInvalidOperationLength),
9079 #[allow(missing_docs)]
9080 TimelockUnauthorizedCaller(TimelockUnauthorizedCaller),
9081 #[allow(missing_docs)]
9082 TimelockUnexecutedPredecessor(TimelockUnexecutedPredecessor),
9083 #[allow(missing_docs)]
9084 TimelockUnexpectedOperationState(TimelockUnexpectedOperationState),
9085 }
9086 #[automatically_derived]
9087 impl OpsTimelockErrors {
9088 pub const SELECTORS: &'static [[u8; 4usize]] = &[
9095 [20u8, 37u8, 234u8, 66u8],
9096 [84u8, 51u8, 102u8, 9u8],
9097 [94u8, 173u8, 142u8, 181u8],
9098 [102u8, 151u8, 178u8, 50u8],
9099 [144u8, 169u8, 166u8, 24u8],
9100 [226u8, 81u8, 125u8, 63u8],
9101 [226u8, 133u8, 12u8, 89u8],
9102 [255u8, 176u8, 50u8, 17u8],
9103 ];
9104 }
9105 #[automatically_derived]
9106 impl alloy_sol_types::SolInterface for OpsTimelockErrors {
9107 const NAME: &'static str = "OpsTimelockErrors";
9108 const MIN_DATA_LENGTH: usize = 0usize;
9109 const COUNT: usize = 8usize;
9110 #[inline]
9111 fn selector(&self) -> [u8; 4] {
9112 match self {
9113 Self::AccessControlBadConfirmation(_) => {
9114 <AccessControlBadConfirmation as alloy_sol_types::SolError>::SELECTOR
9115 }
9116 Self::AccessControlUnauthorizedAccount(_) => {
9117 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
9118 }
9119 Self::FailedInnerCall(_) => {
9120 <FailedInnerCall as alloy_sol_types::SolError>::SELECTOR
9121 }
9122 Self::TimelockInsufficientDelay(_) => {
9123 <TimelockInsufficientDelay as alloy_sol_types::SolError>::SELECTOR
9124 }
9125 Self::TimelockInvalidOperationLength(_) => {
9126 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::SELECTOR
9127 }
9128 Self::TimelockUnauthorizedCaller(_) => {
9129 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::SELECTOR
9130 }
9131 Self::TimelockUnexecutedPredecessor(_) => {
9132 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::SELECTOR
9133 }
9134 Self::TimelockUnexpectedOperationState(_) => {
9135 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::SELECTOR
9136 }
9137 }
9138 }
9139 #[inline]
9140 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
9141 Self::SELECTORS.get(i).copied()
9142 }
9143 #[inline]
9144 fn valid_selector(selector: [u8; 4]) -> bool {
9145 Self::SELECTORS.binary_search(&selector).is_ok()
9146 }
9147 #[inline]
9148 #[allow(non_snake_case)]
9149 fn abi_decode_raw(
9150 selector: [u8; 4],
9151 data: &[u8],
9152 ) -> alloy_sol_types::Result<Self> {
9153 static DECODE_SHIMS: &[fn(
9154 &[u8],
9155 ) -> alloy_sol_types::Result<OpsTimelockErrors>] = &[
9156 {
9157 fn FailedInnerCall(
9158 data: &[u8],
9159 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9160 <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw(
9161 data,
9162 )
9163 .map(OpsTimelockErrors::FailedInnerCall)
9164 }
9165 FailedInnerCall
9166 },
9167 {
9168 fn TimelockInsufficientDelay(
9169 data: &[u8],
9170 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9171 <TimelockInsufficientDelay as alloy_sol_types::SolError>::abi_decode_raw(
9172 data,
9173 )
9174 .map(OpsTimelockErrors::TimelockInsufficientDelay)
9175 }
9176 TimelockInsufficientDelay
9177 },
9178 {
9179 fn TimelockUnexpectedOperationState(
9180 data: &[u8],
9181 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9182 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::abi_decode_raw(
9183 data,
9184 )
9185 .map(OpsTimelockErrors::TimelockUnexpectedOperationState)
9186 }
9187 TimelockUnexpectedOperationState
9188 },
9189 {
9190 fn AccessControlBadConfirmation(
9191 data: &[u8],
9192 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9193 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_decode_raw(
9194 data,
9195 )
9196 .map(OpsTimelockErrors::AccessControlBadConfirmation)
9197 }
9198 AccessControlBadConfirmation
9199 },
9200 {
9201 fn TimelockUnexecutedPredecessor(
9202 data: &[u8],
9203 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9204 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::abi_decode_raw(
9205 data,
9206 )
9207 .map(OpsTimelockErrors::TimelockUnexecutedPredecessor)
9208 }
9209 TimelockUnexecutedPredecessor
9210 },
9211 {
9212 fn AccessControlUnauthorizedAccount(
9213 data: &[u8],
9214 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9215 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw(
9216 data,
9217 )
9218 .map(OpsTimelockErrors::AccessControlUnauthorizedAccount)
9219 }
9220 AccessControlUnauthorizedAccount
9221 },
9222 {
9223 fn TimelockUnauthorizedCaller(
9224 data: &[u8],
9225 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9226 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::abi_decode_raw(
9227 data,
9228 )
9229 .map(OpsTimelockErrors::TimelockUnauthorizedCaller)
9230 }
9231 TimelockUnauthorizedCaller
9232 },
9233 {
9234 fn TimelockInvalidOperationLength(
9235 data: &[u8],
9236 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9237 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::abi_decode_raw(
9238 data,
9239 )
9240 .map(OpsTimelockErrors::TimelockInvalidOperationLength)
9241 }
9242 TimelockInvalidOperationLength
9243 },
9244 ];
9245 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
9246 return Err(
9247 alloy_sol_types::Error::unknown_selector(
9248 <Self as alloy_sol_types::SolInterface>::NAME,
9249 selector,
9250 ),
9251 );
9252 };
9253 DECODE_SHIMS[idx](data)
9254 }
9255 #[inline]
9256 #[allow(non_snake_case)]
9257 fn abi_decode_raw_validate(
9258 selector: [u8; 4],
9259 data: &[u8],
9260 ) -> alloy_sol_types::Result<Self> {
9261 static DECODE_VALIDATE_SHIMS: &[fn(
9262 &[u8],
9263 ) -> alloy_sol_types::Result<OpsTimelockErrors>] = &[
9264 {
9265 fn FailedInnerCall(
9266 data: &[u8],
9267 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9268 <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw_validate(
9269 data,
9270 )
9271 .map(OpsTimelockErrors::FailedInnerCall)
9272 }
9273 FailedInnerCall
9274 },
9275 {
9276 fn TimelockInsufficientDelay(
9277 data: &[u8],
9278 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9279 <TimelockInsufficientDelay as alloy_sol_types::SolError>::abi_decode_raw_validate(
9280 data,
9281 )
9282 .map(OpsTimelockErrors::TimelockInsufficientDelay)
9283 }
9284 TimelockInsufficientDelay
9285 },
9286 {
9287 fn TimelockUnexpectedOperationState(
9288 data: &[u8],
9289 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9290 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::abi_decode_raw_validate(
9291 data,
9292 )
9293 .map(OpsTimelockErrors::TimelockUnexpectedOperationState)
9294 }
9295 TimelockUnexpectedOperationState
9296 },
9297 {
9298 fn AccessControlBadConfirmation(
9299 data: &[u8],
9300 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9301 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_decode_raw_validate(
9302 data,
9303 )
9304 .map(OpsTimelockErrors::AccessControlBadConfirmation)
9305 }
9306 AccessControlBadConfirmation
9307 },
9308 {
9309 fn TimelockUnexecutedPredecessor(
9310 data: &[u8],
9311 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9312 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::abi_decode_raw_validate(
9313 data,
9314 )
9315 .map(OpsTimelockErrors::TimelockUnexecutedPredecessor)
9316 }
9317 TimelockUnexecutedPredecessor
9318 },
9319 {
9320 fn AccessControlUnauthorizedAccount(
9321 data: &[u8],
9322 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9323 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw_validate(
9324 data,
9325 )
9326 .map(OpsTimelockErrors::AccessControlUnauthorizedAccount)
9327 }
9328 AccessControlUnauthorizedAccount
9329 },
9330 {
9331 fn TimelockUnauthorizedCaller(
9332 data: &[u8],
9333 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9334 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::abi_decode_raw_validate(
9335 data,
9336 )
9337 .map(OpsTimelockErrors::TimelockUnauthorizedCaller)
9338 }
9339 TimelockUnauthorizedCaller
9340 },
9341 {
9342 fn TimelockInvalidOperationLength(
9343 data: &[u8],
9344 ) -> alloy_sol_types::Result<OpsTimelockErrors> {
9345 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::abi_decode_raw_validate(
9346 data,
9347 )
9348 .map(OpsTimelockErrors::TimelockInvalidOperationLength)
9349 }
9350 TimelockInvalidOperationLength
9351 },
9352 ];
9353 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
9354 return Err(
9355 alloy_sol_types::Error::unknown_selector(
9356 <Self as alloy_sol_types::SolInterface>::NAME,
9357 selector,
9358 ),
9359 );
9360 };
9361 DECODE_VALIDATE_SHIMS[idx](data)
9362 }
9363 #[inline]
9364 fn abi_encoded_size(&self) -> usize {
9365 match self {
9366 Self::AccessControlBadConfirmation(inner) => {
9367 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_encoded_size(
9368 inner,
9369 )
9370 }
9371 Self::AccessControlUnauthorizedAccount(inner) => {
9372 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
9373 inner,
9374 )
9375 }
9376 Self::FailedInnerCall(inner) => {
9377 <FailedInnerCall as alloy_sol_types::SolError>::abi_encoded_size(
9378 inner,
9379 )
9380 }
9381 Self::TimelockInsufficientDelay(inner) => {
9382 <TimelockInsufficientDelay as alloy_sol_types::SolError>::abi_encoded_size(
9383 inner,
9384 )
9385 }
9386 Self::TimelockInvalidOperationLength(inner) => {
9387 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::abi_encoded_size(
9388 inner,
9389 )
9390 }
9391 Self::TimelockUnauthorizedCaller(inner) => {
9392 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::abi_encoded_size(
9393 inner,
9394 )
9395 }
9396 Self::TimelockUnexecutedPredecessor(inner) => {
9397 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::abi_encoded_size(
9398 inner,
9399 )
9400 }
9401 Self::TimelockUnexpectedOperationState(inner) => {
9402 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::abi_encoded_size(
9403 inner,
9404 )
9405 }
9406 }
9407 }
9408 #[inline]
9409 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
9410 match self {
9411 Self::AccessControlBadConfirmation(inner) => {
9412 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_encode_raw(
9413 inner,
9414 out,
9415 )
9416 }
9417 Self::AccessControlUnauthorizedAccount(inner) => {
9418 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
9419 inner,
9420 out,
9421 )
9422 }
9423 Self::FailedInnerCall(inner) => {
9424 <FailedInnerCall as alloy_sol_types::SolError>::abi_encode_raw(
9425 inner,
9426 out,
9427 )
9428 }
9429 Self::TimelockInsufficientDelay(inner) => {
9430 <TimelockInsufficientDelay as alloy_sol_types::SolError>::abi_encode_raw(
9431 inner,
9432 out,
9433 )
9434 }
9435 Self::TimelockInvalidOperationLength(inner) => {
9436 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::abi_encode_raw(
9437 inner,
9438 out,
9439 )
9440 }
9441 Self::TimelockUnauthorizedCaller(inner) => {
9442 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::abi_encode_raw(
9443 inner,
9444 out,
9445 )
9446 }
9447 Self::TimelockUnexecutedPredecessor(inner) => {
9448 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::abi_encode_raw(
9449 inner,
9450 out,
9451 )
9452 }
9453 Self::TimelockUnexpectedOperationState(inner) => {
9454 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::abi_encode_raw(
9455 inner,
9456 out,
9457 )
9458 }
9459 }
9460 }
9461 }
9462 #[derive(serde::Serialize, serde::Deserialize)]
9464 #[derive(Debug, PartialEq, Eq, Hash)]
9465 pub enum OpsTimelockEvents {
9466 #[allow(missing_docs)]
9467 CallExecuted(CallExecuted),
9468 #[allow(missing_docs)]
9469 CallSalt(CallSalt),
9470 #[allow(missing_docs)]
9471 CallScheduled(CallScheduled),
9472 #[allow(missing_docs)]
9473 Cancelled(Cancelled),
9474 #[allow(missing_docs)]
9475 MinDelayChange(MinDelayChange),
9476 #[allow(missing_docs)]
9477 RoleAdminChanged(RoleAdminChanged),
9478 #[allow(missing_docs)]
9479 RoleGranted(RoleGranted),
9480 #[allow(missing_docs)]
9481 RoleRevoked(RoleRevoked),
9482 }
9483 #[automatically_derived]
9484 impl OpsTimelockEvents {
9485 pub const SELECTORS: &'static [[u8; 32usize]] = &[
9492 [
9493 17u8, 194u8, 79u8, 78u8, 173u8, 22u8, 80u8, 124u8, 105u8, 172u8, 70u8,
9494 127u8, 189u8, 94u8, 78u8, 237u8, 95u8, 181u8, 198u8, 153u8, 98u8, 109u8,
9495 44u8, 198u8, 214u8, 100u8, 33u8, 223u8, 37u8, 56u8, 134u8, 213u8,
9496 ],
9497 [
9498 32u8, 253u8, 165u8, 253u8, 39u8, 161u8, 234u8, 123u8, 245u8, 185u8, 86u8,
9499 127u8, 20u8, 58u8, 197u8, 71u8, 11u8, 176u8, 89u8, 55u8, 74u8, 39u8,
9500 232u8, 246u8, 124u8, 180u8, 79u8, 148u8, 111u8, 109u8, 3u8, 135u8,
9501 ],
9502 [
9503 47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8,
9504 236u8, 121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8,
9505 64u8, 48u8, 69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
9506 ],
9507 [
9508 76u8, 244u8, 65u8, 12u8, 197u8, 112u8, 64u8, 228u8, 72u8, 98u8, 239u8,
9509 15u8, 69u8, 243u8, 221u8, 90u8, 94u8, 2u8, 219u8, 142u8, 184u8, 173u8,
9510 214u8, 72u8, 212u8, 176u8, 226u8, 54u8, 241u8, 208u8, 125u8, 202u8,
9511 ],
9512 [
9513 186u8, 161u8, 235u8, 34u8, 242u8, 164u8, 146u8, 186u8, 26u8, 95u8, 234u8,
9514 97u8, 184u8, 223u8, 77u8, 39u8, 198u8, 200u8, 181u8, 243u8, 151u8, 30u8,
9515 99u8, 187u8, 88u8, 250u8, 20u8, 255u8, 114u8, 238u8, 219u8, 112u8,
9516 ],
9517 [
9518 189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8,
9519 81u8, 66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8,
9520 71u8, 92u8, 58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
9521 ],
9522 [
9523 194u8, 97u8, 126u8, 250u8, 105u8, 186u8, 182u8, 103u8, 130u8, 250u8,
9524 33u8, 149u8, 67u8, 113u8, 67u8, 56u8, 72u8, 156u8, 78u8, 158u8, 23u8,
9525 130u8, 113u8, 86u8, 10u8, 145u8, 184u8, 44u8, 63u8, 97u8, 43u8, 88u8,
9526 ],
9527 [
9528 246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8,
9529 103u8, 11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8,
9530 253u8, 100u8, 235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
9531 ],
9532 ];
9533 }
9534 #[automatically_derived]
9535 impl alloy_sol_types::SolEventInterface for OpsTimelockEvents {
9536 const NAME: &'static str = "OpsTimelockEvents";
9537 const COUNT: usize = 8usize;
9538 fn decode_raw_log(
9539 topics: &[alloy_sol_types::Word],
9540 data: &[u8],
9541 ) -> alloy_sol_types::Result<Self> {
9542 match topics.first().copied() {
9543 Some(<CallExecuted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9544 <CallExecuted as alloy_sol_types::SolEvent>::decode_raw_log(
9545 topics,
9546 data,
9547 )
9548 .map(Self::CallExecuted)
9549 }
9550 Some(<CallSalt as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9551 <CallSalt as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
9552 .map(Self::CallSalt)
9553 }
9554 Some(<CallScheduled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9555 <CallScheduled as alloy_sol_types::SolEvent>::decode_raw_log(
9556 topics,
9557 data,
9558 )
9559 .map(Self::CallScheduled)
9560 }
9561 Some(<Cancelled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9562 <Cancelled as alloy_sol_types::SolEvent>::decode_raw_log(
9563 topics,
9564 data,
9565 )
9566 .map(Self::Cancelled)
9567 }
9568 Some(<MinDelayChange as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9569 <MinDelayChange as alloy_sol_types::SolEvent>::decode_raw_log(
9570 topics,
9571 data,
9572 )
9573 .map(Self::MinDelayChange)
9574 }
9575 Some(<RoleAdminChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9576 <RoleAdminChanged as alloy_sol_types::SolEvent>::decode_raw_log(
9577 topics,
9578 data,
9579 )
9580 .map(Self::RoleAdminChanged)
9581 }
9582 Some(<RoleGranted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9583 <RoleGranted as alloy_sol_types::SolEvent>::decode_raw_log(
9584 topics,
9585 data,
9586 )
9587 .map(Self::RoleGranted)
9588 }
9589 Some(<RoleRevoked as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9590 <RoleRevoked as alloy_sol_types::SolEvent>::decode_raw_log(
9591 topics,
9592 data,
9593 )
9594 .map(Self::RoleRevoked)
9595 }
9596 _ => {
9597 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
9598 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
9599 log: alloy_sol_types::private::Box::new(
9600 alloy_sol_types::private::LogData::new_unchecked(
9601 topics.to_vec(),
9602 data.to_vec().into(),
9603 ),
9604 ),
9605 })
9606 }
9607 }
9608 }
9609 }
9610 #[automatically_derived]
9611 impl alloy_sol_types::private::IntoLogData for OpsTimelockEvents {
9612 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
9613 match self {
9614 Self::CallExecuted(inner) => {
9615 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9616 }
9617 Self::CallSalt(inner) => {
9618 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9619 }
9620 Self::CallScheduled(inner) => {
9621 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9622 }
9623 Self::Cancelled(inner) => {
9624 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9625 }
9626 Self::MinDelayChange(inner) => {
9627 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9628 }
9629 Self::RoleAdminChanged(inner) => {
9630 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9631 }
9632 Self::RoleGranted(inner) => {
9633 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9634 }
9635 Self::RoleRevoked(inner) => {
9636 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9637 }
9638 }
9639 }
9640 fn into_log_data(self) -> alloy_sol_types::private::LogData {
9641 match self {
9642 Self::CallExecuted(inner) => {
9643 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9644 }
9645 Self::CallSalt(inner) => {
9646 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9647 }
9648 Self::CallScheduled(inner) => {
9649 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9650 }
9651 Self::Cancelled(inner) => {
9652 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9653 }
9654 Self::MinDelayChange(inner) => {
9655 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9656 }
9657 Self::RoleAdminChanged(inner) => {
9658 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9659 }
9660 Self::RoleGranted(inner) => {
9661 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9662 }
9663 Self::RoleRevoked(inner) => {
9664 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9665 }
9666 }
9667 }
9668 }
9669 use alloy::contract as alloy_contract;
9670 #[inline]
9674 pub const fn new<
9675 P: alloy_contract::private::Provider<N>,
9676 N: alloy_contract::private::Network,
9677 >(
9678 address: alloy_sol_types::private::Address,
9679 __provider: P,
9680 ) -> OpsTimelockInstance<P, N> {
9681 OpsTimelockInstance::<P, N>::new(address, __provider)
9682 }
9683 #[inline]
9689 pub fn deploy<
9690 P: alloy_contract::private::Provider<N>,
9691 N: alloy_contract::private::Network,
9692 >(
9693 __provider: P,
9694 minDelay: alloy::sol_types::private::primitives::aliases::U256,
9695 proposers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9696 executors: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9697 admin: alloy::sol_types::private::Address,
9698 ) -> impl ::core::future::Future<
9699 Output = alloy_contract::Result<OpsTimelockInstance<P, N>>,
9700 > {
9701 OpsTimelockInstance::<
9702 P,
9703 N,
9704 >::deploy(__provider, minDelay, proposers, executors, admin)
9705 }
9706 #[inline]
9712 pub fn deploy_builder<
9713 P: alloy_contract::private::Provider<N>,
9714 N: alloy_contract::private::Network,
9715 >(
9716 __provider: P,
9717 minDelay: alloy::sol_types::private::primitives::aliases::U256,
9718 proposers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9719 executors: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9720 admin: alloy::sol_types::private::Address,
9721 ) -> alloy_contract::RawCallBuilder<P, N> {
9722 OpsTimelockInstance::<
9723 P,
9724 N,
9725 >::deploy_builder(__provider, minDelay, proposers, executors, admin)
9726 }
9727 #[derive(Clone)]
9739 pub struct OpsTimelockInstance<P, N = alloy_contract::private::Ethereum> {
9740 address: alloy_sol_types::private::Address,
9741 provider: P,
9742 _network: ::core::marker::PhantomData<N>,
9743 }
9744 #[automatically_derived]
9745 impl<P, N> ::core::fmt::Debug for OpsTimelockInstance<P, N> {
9746 #[inline]
9747 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
9748 f.debug_tuple("OpsTimelockInstance").field(&self.address).finish()
9749 }
9750 }
9751 #[automatically_derived]
9753 impl<
9754 P: alloy_contract::private::Provider<N>,
9755 N: alloy_contract::private::Network,
9756 > OpsTimelockInstance<P, N> {
9757 #[inline]
9761 pub const fn new(
9762 address: alloy_sol_types::private::Address,
9763 __provider: P,
9764 ) -> Self {
9765 Self {
9766 address,
9767 provider: __provider,
9768 _network: ::core::marker::PhantomData,
9769 }
9770 }
9771 #[inline]
9777 pub async fn deploy(
9778 __provider: P,
9779 minDelay: alloy::sol_types::private::primitives::aliases::U256,
9780 proposers: alloy::sol_types::private::Vec<
9781 alloy::sol_types::private::Address,
9782 >,
9783 executors: alloy::sol_types::private::Vec<
9784 alloy::sol_types::private::Address,
9785 >,
9786 admin: alloy::sol_types::private::Address,
9787 ) -> alloy_contract::Result<OpsTimelockInstance<P, N>> {
9788 let call_builder = Self::deploy_builder(
9789 __provider,
9790 minDelay,
9791 proposers,
9792 executors,
9793 admin,
9794 );
9795 let contract_address = call_builder.deploy().await?;
9796 Ok(Self::new(contract_address, call_builder.provider))
9797 }
9798 #[inline]
9804 pub fn deploy_builder(
9805 __provider: P,
9806 minDelay: alloy::sol_types::private::primitives::aliases::U256,
9807 proposers: alloy::sol_types::private::Vec<
9808 alloy::sol_types::private::Address,
9809 >,
9810 executors: alloy::sol_types::private::Vec<
9811 alloy::sol_types::private::Address,
9812 >,
9813 admin: alloy::sol_types::private::Address,
9814 ) -> alloy_contract::RawCallBuilder<P, N> {
9815 alloy_contract::RawCallBuilder::new_raw_deploy(
9816 __provider,
9817 [
9818 &BYTECODE[..],
9819 &alloy_sol_types::SolConstructor::abi_encode(
9820 &constructorCall {
9821 minDelay,
9822 proposers,
9823 executors,
9824 admin,
9825 },
9826 )[..],
9827 ]
9828 .concat()
9829 .into(),
9830 )
9831 }
9832 #[inline]
9834 pub const fn address(&self) -> &alloy_sol_types::private::Address {
9835 &self.address
9836 }
9837 #[inline]
9839 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
9840 self.address = address;
9841 }
9842 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
9844 self.set_address(address);
9845 self
9846 }
9847 #[inline]
9849 pub const fn provider(&self) -> &P {
9850 &self.provider
9851 }
9852 }
9853 impl<P: ::core::clone::Clone, N> OpsTimelockInstance<&P, N> {
9854 #[inline]
9856 pub fn with_cloned_provider(self) -> OpsTimelockInstance<P, N> {
9857 OpsTimelockInstance {
9858 address: self.address,
9859 provider: ::core::clone::Clone::clone(&self.provider),
9860 _network: ::core::marker::PhantomData,
9861 }
9862 }
9863 }
9864 #[automatically_derived]
9866 impl<
9867 P: alloy_contract::private::Provider<N>,
9868 N: alloy_contract::private::Network,
9869 > OpsTimelockInstance<P, N> {
9870 pub fn call_builder<C: alloy_sol_types::SolCall>(
9875 &self,
9876 call: &C,
9877 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
9878 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
9879 }
9880 pub fn CANCELLER_ROLE(
9882 &self,
9883 ) -> alloy_contract::SolCallBuilder<&P, CANCELLER_ROLECall, N> {
9884 self.call_builder(&CANCELLER_ROLECall)
9885 }
9886 pub fn DEFAULT_ADMIN_ROLE(
9888 &self,
9889 ) -> alloy_contract::SolCallBuilder<&P, DEFAULT_ADMIN_ROLECall, N> {
9890 self.call_builder(&DEFAULT_ADMIN_ROLECall)
9891 }
9892 pub fn EXECUTOR_ROLE(
9894 &self,
9895 ) -> alloy_contract::SolCallBuilder<&P, EXECUTOR_ROLECall, N> {
9896 self.call_builder(&EXECUTOR_ROLECall)
9897 }
9898 pub fn PROPOSER_ROLE(
9900 &self,
9901 ) -> alloy_contract::SolCallBuilder<&P, PROPOSER_ROLECall, N> {
9902 self.call_builder(&PROPOSER_ROLECall)
9903 }
9904 pub fn cancel(
9906 &self,
9907 id: alloy::sol_types::private::FixedBytes<32>,
9908 ) -> alloy_contract::SolCallBuilder<&P, cancelCall, N> {
9909 self.call_builder(&cancelCall { id })
9910 }
9911 pub fn execute(
9913 &self,
9914 target: alloy::sol_types::private::Address,
9915 value: alloy::sol_types::private::primitives::aliases::U256,
9916 payload: alloy::sol_types::private::Bytes,
9917 predecessor: alloy::sol_types::private::FixedBytes<32>,
9918 salt: alloy::sol_types::private::FixedBytes<32>,
9919 ) -> alloy_contract::SolCallBuilder<&P, executeCall, N> {
9920 self.call_builder(
9921 &executeCall {
9922 target,
9923 value,
9924 payload,
9925 predecessor,
9926 salt,
9927 },
9928 )
9929 }
9930 pub fn executeBatch(
9932 &self,
9933 targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9934 values: alloy::sol_types::private::Vec<
9935 alloy::sol_types::private::primitives::aliases::U256,
9936 >,
9937 payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
9938 predecessor: alloy::sol_types::private::FixedBytes<32>,
9939 salt: alloy::sol_types::private::FixedBytes<32>,
9940 ) -> alloy_contract::SolCallBuilder<&P, executeBatchCall, N> {
9941 self.call_builder(
9942 &executeBatchCall {
9943 targets,
9944 values,
9945 payloads,
9946 predecessor,
9947 salt,
9948 },
9949 )
9950 }
9951 pub fn getMinDelay(
9953 &self,
9954 ) -> alloy_contract::SolCallBuilder<&P, getMinDelayCall, N> {
9955 self.call_builder(&getMinDelayCall)
9956 }
9957 pub fn getOperationState(
9959 &self,
9960 id: alloy::sol_types::private::FixedBytes<32>,
9961 ) -> alloy_contract::SolCallBuilder<&P, getOperationStateCall, N> {
9962 self.call_builder(&getOperationStateCall { id })
9963 }
9964 pub fn getRoleAdmin(
9966 &self,
9967 role: alloy::sol_types::private::FixedBytes<32>,
9968 ) -> alloy_contract::SolCallBuilder<&P, getRoleAdminCall, N> {
9969 self.call_builder(&getRoleAdminCall { role })
9970 }
9971 pub fn getTimestamp(
9973 &self,
9974 id: alloy::sol_types::private::FixedBytes<32>,
9975 ) -> alloy_contract::SolCallBuilder<&P, getTimestampCall, N> {
9976 self.call_builder(&getTimestampCall { id })
9977 }
9978 pub fn grantRole(
9980 &self,
9981 role: alloy::sol_types::private::FixedBytes<32>,
9982 account: alloy::sol_types::private::Address,
9983 ) -> alloy_contract::SolCallBuilder<&P, grantRoleCall, N> {
9984 self.call_builder(&grantRoleCall { role, account })
9985 }
9986 pub fn hasRole(
9988 &self,
9989 role: alloy::sol_types::private::FixedBytes<32>,
9990 account: alloy::sol_types::private::Address,
9991 ) -> alloy_contract::SolCallBuilder<&P, hasRoleCall, N> {
9992 self.call_builder(&hasRoleCall { role, account })
9993 }
9994 pub fn hashOperation(
9996 &self,
9997 target: alloy::sol_types::private::Address,
9998 value: alloy::sol_types::private::primitives::aliases::U256,
9999 data: alloy::sol_types::private::Bytes,
10000 predecessor: alloy::sol_types::private::FixedBytes<32>,
10001 salt: alloy::sol_types::private::FixedBytes<32>,
10002 ) -> alloy_contract::SolCallBuilder<&P, hashOperationCall, N> {
10003 self.call_builder(
10004 &hashOperationCall {
10005 target,
10006 value,
10007 data,
10008 predecessor,
10009 salt,
10010 },
10011 )
10012 }
10013 pub fn hashOperationBatch(
10015 &self,
10016 targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10017 values: alloy::sol_types::private::Vec<
10018 alloy::sol_types::private::primitives::aliases::U256,
10019 >,
10020 payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
10021 predecessor: alloy::sol_types::private::FixedBytes<32>,
10022 salt: alloy::sol_types::private::FixedBytes<32>,
10023 ) -> alloy_contract::SolCallBuilder<&P, hashOperationBatchCall, N> {
10024 self.call_builder(
10025 &hashOperationBatchCall {
10026 targets,
10027 values,
10028 payloads,
10029 predecessor,
10030 salt,
10031 },
10032 )
10033 }
10034 pub fn isOperation(
10036 &self,
10037 id: alloy::sol_types::private::FixedBytes<32>,
10038 ) -> alloy_contract::SolCallBuilder<&P, isOperationCall, N> {
10039 self.call_builder(&isOperationCall { id })
10040 }
10041 pub fn isOperationDone(
10043 &self,
10044 id: alloy::sol_types::private::FixedBytes<32>,
10045 ) -> alloy_contract::SolCallBuilder<&P, isOperationDoneCall, N> {
10046 self.call_builder(&isOperationDoneCall { id })
10047 }
10048 pub fn isOperationPending(
10050 &self,
10051 id: alloy::sol_types::private::FixedBytes<32>,
10052 ) -> alloy_contract::SolCallBuilder<&P, isOperationPendingCall, N> {
10053 self.call_builder(&isOperationPendingCall { id })
10054 }
10055 pub fn isOperationReady(
10057 &self,
10058 id: alloy::sol_types::private::FixedBytes<32>,
10059 ) -> alloy_contract::SolCallBuilder<&P, isOperationReadyCall, N> {
10060 self.call_builder(&isOperationReadyCall { id })
10061 }
10062 pub fn onERC1155BatchReceived(
10064 &self,
10065 _0: alloy::sol_types::private::Address,
10066 _1: alloy::sol_types::private::Address,
10067 _2: alloy::sol_types::private::Vec<
10068 alloy::sol_types::private::primitives::aliases::U256,
10069 >,
10070 _3: alloy::sol_types::private::Vec<
10071 alloy::sol_types::private::primitives::aliases::U256,
10072 >,
10073 _4: alloy::sol_types::private::Bytes,
10074 ) -> alloy_contract::SolCallBuilder<&P, onERC1155BatchReceivedCall, N> {
10075 self.call_builder(
10076 &onERC1155BatchReceivedCall {
10077 _0,
10078 _1,
10079 _2,
10080 _3,
10081 _4,
10082 },
10083 )
10084 }
10085 pub fn onERC1155Received(
10087 &self,
10088 _0: alloy::sol_types::private::Address,
10089 _1: alloy::sol_types::private::Address,
10090 _2: alloy::sol_types::private::primitives::aliases::U256,
10091 _3: alloy::sol_types::private::primitives::aliases::U256,
10092 _4: alloy::sol_types::private::Bytes,
10093 ) -> alloy_contract::SolCallBuilder<&P, onERC1155ReceivedCall, N> {
10094 self.call_builder(
10095 &onERC1155ReceivedCall {
10096 _0,
10097 _1,
10098 _2,
10099 _3,
10100 _4,
10101 },
10102 )
10103 }
10104 pub fn onERC721Received(
10106 &self,
10107 _0: alloy::sol_types::private::Address,
10108 _1: alloy::sol_types::private::Address,
10109 _2: alloy::sol_types::private::primitives::aliases::U256,
10110 _3: alloy::sol_types::private::Bytes,
10111 ) -> alloy_contract::SolCallBuilder<&P, onERC721ReceivedCall, N> {
10112 self.call_builder(
10113 &onERC721ReceivedCall {
10114 _0,
10115 _1,
10116 _2,
10117 _3,
10118 },
10119 )
10120 }
10121 pub fn renounceRole(
10123 &self,
10124 role: alloy::sol_types::private::FixedBytes<32>,
10125 callerConfirmation: alloy::sol_types::private::Address,
10126 ) -> alloy_contract::SolCallBuilder<&P, renounceRoleCall, N> {
10127 self.call_builder(
10128 &renounceRoleCall {
10129 role,
10130 callerConfirmation,
10131 },
10132 )
10133 }
10134 pub fn revokeRole(
10136 &self,
10137 role: alloy::sol_types::private::FixedBytes<32>,
10138 account: alloy::sol_types::private::Address,
10139 ) -> alloy_contract::SolCallBuilder<&P, revokeRoleCall, N> {
10140 self.call_builder(&revokeRoleCall { role, account })
10141 }
10142 pub fn schedule(
10144 &self,
10145 target: alloy::sol_types::private::Address,
10146 value: alloy::sol_types::private::primitives::aliases::U256,
10147 data: alloy::sol_types::private::Bytes,
10148 predecessor: alloy::sol_types::private::FixedBytes<32>,
10149 salt: alloy::sol_types::private::FixedBytes<32>,
10150 delay: alloy::sol_types::private::primitives::aliases::U256,
10151 ) -> alloy_contract::SolCallBuilder<&P, scheduleCall, N> {
10152 self.call_builder(
10153 &scheduleCall {
10154 target,
10155 value,
10156 data,
10157 predecessor,
10158 salt,
10159 delay,
10160 },
10161 )
10162 }
10163 pub fn scheduleBatch(
10165 &self,
10166 targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10167 values: alloy::sol_types::private::Vec<
10168 alloy::sol_types::private::primitives::aliases::U256,
10169 >,
10170 payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
10171 predecessor: alloy::sol_types::private::FixedBytes<32>,
10172 salt: alloy::sol_types::private::FixedBytes<32>,
10173 delay: alloy::sol_types::private::primitives::aliases::U256,
10174 ) -> alloy_contract::SolCallBuilder<&P, scheduleBatchCall, N> {
10175 self.call_builder(
10176 &scheduleBatchCall {
10177 targets,
10178 values,
10179 payloads,
10180 predecessor,
10181 salt,
10182 delay,
10183 },
10184 )
10185 }
10186 pub fn supportsInterface(
10188 &self,
10189 interfaceId: alloy::sol_types::private::FixedBytes<4>,
10190 ) -> alloy_contract::SolCallBuilder<&P, supportsInterfaceCall, N> {
10191 self.call_builder(
10192 &supportsInterfaceCall {
10193 interfaceId,
10194 },
10195 )
10196 }
10197 pub fn updateDelay(
10199 &self,
10200 newDelay: alloy::sol_types::private::primitives::aliases::U256,
10201 ) -> alloy_contract::SolCallBuilder<&P, updateDelayCall, N> {
10202 self.call_builder(&updateDelayCall { newDelay })
10203 }
10204 }
10205 #[automatically_derived]
10207 impl<
10208 P: alloy_contract::private::Provider<N>,
10209 N: alloy_contract::private::Network,
10210 > OpsTimelockInstance<P, N> {
10211 pub fn event_filter<E: alloy_sol_types::SolEvent>(
10216 &self,
10217 ) -> alloy_contract::Event<&P, E, N> {
10218 alloy_contract::Event::new_sol(&self.provider, &self.address)
10219 }
10220 pub fn CallExecuted_filter(&self) -> alloy_contract::Event<&P, CallExecuted, N> {
10222 self.event_filter::<CallExecuted>()
10223 }
10224 pub fn CallSalt_filter(&self) -> alloy_contract::Event<&P, CallSalt, N> {
10226 self.event_filter::<CallSalt>()
10227 }
10228 pub fn CallScheduled_filter(
10230 &self,
10231 ) -> alloy_contract::Event<&P, CallScheduled, N> {
10232 self.event_filter::<CallScheduled>()
10233 }
10234 pub fn Cancelled_filter(&self) -> alloy_contract::Event<&P, Cancelled, N> {
10236 self.event_filter::<Cancelled>()
10237 }
10238 pub fn MinDelayChange_filter(
10240 &self,
10241 ) -> alloy_contract::Event<&P, MinDelayChange, N> {
10242 self.event_filter::<MinDelayChange>()
10243 }
10244 pub fn RoleAdminChanged_filter(
10246 &self,
10247 ) -> alloy_contract::Event<&P, RoleAdminChanged, N> {
10248 self.event_filter::<RoleAdminChanged>()
10249 }
10250 pub fn RoleGranted_filter(&self) -> alloy_contract::Event<&P, RoleGranted, N> {
10252 self.event_filter::<RoleGranted>()
10253 }
10254 pub fn RoleRevoked_filter(&self) -> alloy_contract::Event<&P, RoleRevoked, N> {
10256 self.event_filter::<RoleRevoked>()
10257 }
10258 }
10259}