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 SafeExitTimelock {
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 SafeExitTimelockCalls {
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 SafeExitTimelockCalls {
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 SafeExitTimelockCalls {
8033 const NAME: &'static str = "SafeExitTimelockCalls";
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<SafeExitTimelockCalls>] = &[
8134 {
8135 fn schedule(
8136 data: &[u8],
8137 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8138 <scheduleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
8139 .map(SafeExitTimelockCalls::schedule)
8140 }
8141 schedule
8142 },
8143 {
8144 fn supportsInterface(
8145 data: &[u8],
8146 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8147 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(
8148 data,
8149 )
8150 .map(SafeExitTimelockCalls::supportsInterface)
8151 }
8152 supportsInterface
8153 },
8154 {
8155 fn EXECUTOR_ROLE(
8156 data: &[u8],
8157 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8158 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
8159 data,
8160 )
8161 .map(SafeExitTimelockCalls::EXECUTOR_ROLE)
8162 }
8163 EXECUTOR_ROLE
8164 },
8165 {
8166 fn execute(
8167 data: &[u8],
8168 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8169 <executeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
8170 .map(SafeExitTimelockCalls::execute)
8171 }
8172 execute
8173 },
8174 {
8175 fn isOperationReady(
8176 data: &[u8],
8177 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8178 <isOperationReadyCall as alloy_sol_types::SolCall>::abi_decode_raw(
8179 data,
8180 )
8181 .map(SafeExitTimelockCalls::isOperationReady)
8182 }
8183 isOperationReady
8184 },
8185 {
8186 fn onERC721Received(
8187 data: &[u8],
8188 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8189 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
8190 data,
8191 )
8192 .map(SafeExitTimelockCalls::onERC721Received)
8193 }
8194 onERC721Received
8195 },
8196 {
8197 fn getRoleAdmin(
8198 data: &[u8],
8199 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8200 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
8201 data,
8202 )
8203 .map(SafeExitTimelockCalls::getRoleAdmin)
8204 }
8205 getRoleAdmin
8206 },
8207 {
8208 fn isOperationDone(
8209 data: &[u8],
8210 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8211 <isOperationDoneCall as alloy_sol_types::SolCall>::abi_decode_raw(
8212 data,
8213 )
8214 .map(SafeExitTimelockCalls::isOperationDone)
8215 }
8216 isOperationDone
8217 },
8218 {
8219 fn grantRole(
8220 data: &[u8],
8221 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8222 <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
8223 .map(SafeExitTimelockCalls::grantRole)
8224 }
8225 grantRole
8226 },
8227 {
8228 fn isOperation(
8229 data: &[u8],
8230 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8231 <isOperationCall as alloy_sol_types::SolCall>::abi_decode_raw(
8232 data,
8233 )
8234 .map(SafeExitTimelockCalls::isOperation)
8235 }
8236 isOperation
8237 },
8238 {
8239 fn renounceRole(
8240 data: &[u8],
8241 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8242 <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
8243 data,
8244 )
8245 .map(SafeExitTimelockCalls::renounceRole)
8246 }
8247 renounceRole
8248 },
8249 {
8250 fn isOperationPending(
8251 data: &[u8],
8252 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8253 <isOperationPendingCall as alloy_sol_types::SolCall>::abi_decode_raw(
8254 data,
8255 )
8256 .map(SafeExitTimelockCalls::isOperationPending)
8257 }
8258 isOperationPending
8259 },
8260 {
8261 fn updateDelay(
8262 data: &[u8],
8263 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8264 <updateDelayCall as alloy_sol_types::SolCall>::abi_decode_raw(
8265 data,
8266 )
8267 .map(SafeExitTimelockCalls::updateDelay)
8268 }
8269 updateDelay
8270 },
8271 {
8272 fn getOperationState(
8273 data: &[u8],
8274 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8275 <getOperationStateCall as alloy_sol_types::SolCall>::abi_decode_raw(
8276 data,
8277 )
8278 .map(SafeExitTimelockCalls::getOperationState)
8279 }
8280 getOperationState
8281 },
8282 {
8283 fn hashOperation(
8284 data: &[u8],
8285 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8286 <hashOperationCall as alloy_sol_types::SolCall>::abi_decode_raw(
8287 data,
8288 )
8289 .map(SafeExitTimelockCalls::hashOperation)
8290 }
8291 hashOperation
8292 },
8293 {
8294 fn scheduleBatch(
8295 data: &[u8],
8296 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8297 <scheduleBatchCall as alloy_sol_types::SolCall>::abi_decode_raw(
8298 data,
8299 )
8300 .map(SafeExitTimelockCalls::scheduleBatch)
8301 }
8302 scheduleBatch
8303 },
8304 {
8305 fn PROPOSER_ROLE(
8306 data: &[u8],
8307 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8308 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
8309 data,
8310 )
8311 .map(SafeExitTimelockCalls::PROPOSER_ROLE)
8312 }
8313 PROPOSER_ROLE
8314 },
8315 {
8316 fn hasRole(
8317 data: &[u8],
8318 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8319 <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
8320 .map(SafeExitTimelockCalls::hasRole)
8321 }
8322 hasRole
8323 },
8324 {
8325 fn DEFAULT_ADMIN_ROLE(
8326 data: &[u8],
8327 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8328 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
8329 data,
8330 )
8331 .map(SafeExitTimelockCalls::DEFAULT_ADMIN_ROLE)
8332 }
8333 DEFAULT_ADMIN_ROLE
8334 },
8335 {
8336 fn CANCELLER_ROLE(
8337 data: &[u8],
8338 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8339 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
8340 data,
8341 )
8342 .map(SafeExitTimelockCalls::CANCELLER_ROLE)
8343 }
8344 CANCELLER_ROLE
8345 },
8346 {
8347 fn hashOperationBatch(
8348 data: &[u8],
8349 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8350 <hashOperationBatchCall as alloy_sol_types::SolCall>::abi_decode_raw(
8351 data,
8352 )
8353 .map(SafeExitTimelockCalls::hashOperationBatch)
8354 }
8355 hashOperationBatch
8356 },
8357 {
8358 fn onERC1155BatchReceived(
8359 data: &[u8],
8360 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8361 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
8362 data,
8363 )
8364 .map(SafeExitTimelockCalls::onERC1155BatchReceived)
8365 }
8366 onERC1155BatchReceived
8367 },
8368 {
8369 fn cancel(
8370 data: &[u8],
8371 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8372 <cancelCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
8373 .map(SafeExitTimelockCalls::cancel)
8374 }
8375 cancel
8376 },
8377 {
8378 fn getTimestamp(
8379 data: &[u8],
8380 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8381 <getTimestampCall as alloy_sol_types::SolCall>::abi_decode_raw(
8382 data,
8383 )
8384 .map(SafeExitTimelockCalls::getTimestamp)
8385 }
8386 getTimestamp
8387 },
8388 {
8389 fn revokeRole(
8390 data: &[u8],
8391 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8392 <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
8393 data,
8394 )
8395 .map(SafeExitTimelockCalls::revokeRole)
8396 }
8397 revokeRole
8398 },
8399 {
8400 fn executeBatch(
8401 data: &[u8],
8402 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8403 <executeBatchCall as alloy_sol_types::SolCall>::abi_decode_raw(
8404 data,
8405 )
8406 .map(SafeExitTimelockCalls::executeBatch)
8407 }
8408 executeBatch
8409 },
8410 {
8411 fn onERC1155Received(
8412 data: &[u8],
8413 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8414 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
8415 data,
8416 )
8417 .map(SafeExitTimelockCalls::onERC1155Received)
8418 }
8419 onERC1155Received
8420 },
8421 {
8422 fn getMinDelay(
8423 data: &[u8],
8424 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8425 <getMinDelayCall as alloy_sol_types::SolCall>::abi_decode_raw(
8426 data,
8427 )
8428 .map(SafeExitTimelockCalls::getMinDelay)
8429 }
8430 getMinDelay
8431 },
8432 ];
8433 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
8434 return Err(
8435 alloy_sol_types::Error::unknown_selector(
8436 <Self as alloy_sol_types::SolInterface>::NAME,
8437 selector,
8438 ),
8439 );
8440 };
8441 DECODE_SHIMS[idx](data)
8442 }
8443 #[inline]
8444 #[allow(non_snake_case)]
8445 fn abi_decode_raw_validate(
8446 selector: [u8; 4],
8447 data: &[u8],
8448 ) -> alloy_sol_types::Result<Self> {
8449 static DECODE_VALIDATE_SHIMS: &[fn(
8450 &[u8],
8451 ) -> alloy_sol_types::Result<SafeExitTimelockCalls>] = &[
8452 {
8453 fn schedule(
8454 data: &[u8],
8455 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8456 <scheduleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8457 data,
8458 )
8459 .map(SafeExitTimelockCalls::schedule)
8460 }
8461 schedule
8462 },
8463 {
8464 fn supportsInterface(
8465 data: &[u8],
8466 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8467 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8468 data,
8469 )
8470 .map(SafeExitTimelockCalls::supportsInterface)
8471 }
8472 supportsInterface
8473 },
8474 {
8475 fn EXECUTOR_ROLE(
8476 data: &[u8],
8477 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8478 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8479 data,
8480 )
8481 .map(SafeExitTimelockCalls::EXECUTOR_ROLE)
8482 }
8483 EXECUTOR_ROLE
8484 },
8485 {
8486 fn execute(
8487 data: &[u8],
8488 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8489 <executeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8490 data,
8491 )
8492 .map(SafeExitTimelockCalls::execute)
8493 }
8494 execute
8495 },
8496 {
8497 fn isOperationReady(
8498 data: &[u8],
8499 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8500 <isOperationReadyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8501 data,
8502 )
8503 .map(SafeExitTimelockCalls::isOperationReady)
8504 }
8505 isOperationReady
8506 },
8507 {
8508 fn onERC721Received(
8509 data: &[u8],
8510 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8511 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8512 data,
8513 )
8514 .map(SafeExitTimelockCalls::onERC721Received)
8515 }
8516 onERC721Received
8517 },
8518 {
8519 fn getRoleAdmin(
8520 data: &[u8],
8521 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8522 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8523 data,
8524 )
8525 .map(SafeExitTimelockCalls::getRoleAdmin)
8526 }
8527 getRoleAdmin
8528 },
8529 {
8530 fn isOperationDone(
8531 data: &[u8],
8532 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8533 <isOperationDoneCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8534 data,
8535 )
8536 .map(SafeExitTimelockCalls::isOperationDone)
8537 }
8538 isOperationDone
8539 },
8540 {
8541 fn grantRole(
8542 data: &[u8],
8543 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8544 <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8545 data,
8546 )
8547 .map(SafeExitTimelockCalls::grantRole)
8548 }
8549 grantRole
8550 },
8551 {
8552 fn isOperation(
8553 data: &[u8],
8554 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8555 <isOperationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8556 data,
8557 )
8558 .map(SafeExitTimelockCalls::isOperation)
8559 }
8560 isOperation
8561 },
8562 {
8563 fn renounceRole(
8564 data: &[u8],
8565 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8566 <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8567 data,
8568 )
8569 .map(SafeExitTimelockCalls::renounceRole)
8570 }
8571 renounceRole
8572 },
8573 {
8574 fn isOperationPending(
8575 data: &[u8],
8576 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8577 <isOperationPendingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8578 data,
8579 )
8580 .map(SafeExitTimelockCalls::isOperationPending)
8581 }
8582 isOperationPending
8583 },
8584 {
8585 fn updateDelay(
8586 data: &[u8],
8587 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8588 <updateDelayCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8589 data,
8590 )
8591 .map(SafeExitTimelockCalls::updateDelay)
8592 }
8593 updateDelay
8594 },
8595 {
8596 fn getOperationState(
8597 data: &[u8],
8598 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8599 <getOperationStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8600 data,
8601 )
8602 .map(SafeExitTimelockCalls::getOperationState)
8603 }
8604 getOperationState
8605 },
8606 {
8607 fn hashOperation(
8608 data: &[u8],
8609 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8610 <hashOperationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8611 data,
8612 )
8613 .map(SafeExitTimelockCalls::hashOperation)
8614 }
8615 hashOperation
8616 },
8617 {
8618 fn scheduleBatch(
8619 data: &[u8],
8620 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8621 <scheduleBatchCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8622 data,
8623 )
8624 .map(SafeExitTimelockCalls::scheduleBatch)
8625 }
8626 scheduleBatch
8627 },
8628 {
8629 fn PROPOSER_ROLE(
8630 data: &[u8],
8631 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8632 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8633 data,
8634 )
8635 .map(SafeExitTimelockCalls::PROPOSER_ROLE)
8636 }
8637 PROPOSER_ROLE
8638 },
8639 {
8640 fn hasRole(
8641 data: &[u8],
8642 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8643 <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8644 data,
8645 )
8646 .map(SafeExitTimelockCalls::hasRole)
8647 }
8648 hasRole
8649 },
8650 {
8651 fn DEFAULT_ADMIN_ROLE(
8652 data: &[u8],
8653 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8654 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8655 data,
8656 )
8657 .map(SafeExitTimelockCalls::DEFAULT_ADMIN_ROLE)
8658 }
8659 DEFAULT_ADMIN_ROLE
8660 },
8661 {
8662 fn CANCELLER_ROLE(
8663 data: &[u8],
8664 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8665 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8666 data,
8667 )
8668 .map(SafeExitTimelockCalls::CANCELLER_ROLE)
8669 }
8670 CANCELLER_ROLE
8671 },
8672 {
8673 fn hashOperationBatch(
8674 data: &[u8],
8675 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8676 <hashOperationBatchCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8677 data,
8678 )
8679 .map(SafeExitTimelockCalls::hashOperationBatch)
8680 }
8681 hashOperationBatch
8682 },
8683 {
8684 fn onERC1155BatchReceived(
8685 data: &[u8],
8686 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8687 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8688 data,
8689 )
8690 .map(SafeExitTimelockCalls::onERC1155BatchReceived)
8691 }
8692 onERC1155BatchReceived
8693 },
8694 {
8695 fn cancel(
8696 data: &[u8],
8697 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8698 <cancelCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8699 data,
8700 )
8701 .map(SafeExitTimelockCalls::cancel)
8702 }
8703 cancel
8704 },
8705 {
8706 fn getTimestamp(
8707 data: &[u8],
8708 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8709 <getTimestampCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8710 data,
8711 )
8712 .map(SafeExitTimelockCalls::getTimestamp)
8713 }
8714 getTimestamp
8715 },
8716 {
8717 fn revokeRole(
8718 data: &[u8],
8719 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8720 <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8721 data,
8722 )
8723 .map(SafeExitTimelockCalls::revokeRole)
8724 }
8725 revokeRole
8726 },
8727 {
8728 fn executeBatch(
8729 data: &[u8],
8730 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8731 <executeBatchCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8732 data,
8733 )
8734 .map(SafeExitTimelockCalls::executeBatch)
8735 }
8736 executeBatch
8737 },
8738 {
8739 fn onERC1155Received(
8740 data: &[u8],
8741 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8742 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8743 data,
8744 )
8745 .map(SafeExitTimelockCalls::onERC1155Received)
8746 }
8747 onERC1155Received
8748 },
8749 {
8750 fn getMinDelay(
8751 data: &[u8],
8752 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
8753 <getMinDelayCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
8754 data,
8755 )
8756 .map(SafeExitTimelockCalls::getMinDelay)
8757 }
8758 getMinDelay
8759 },
8760 ];
8761 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
8762 return Err(
8763 alloy_sol_types::Error::unknown_selector(
8764 <Self as alloy_sol_types::SolInterface>::NAME,
8765 selector,
8766 ),
8767 );
8768 };
8769 DECODE_VALIDATE_SHIMS[idx](data)
8770 }
8771 #[inline]
8772 fn abi_encoded_size(&self) -> usize {
8773 match self {
8774 Self::CANCELLER_ROLE(inner) => {
8775 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
8776 inner,
8777 )
8778 }
8779 Self::DEFAULT_ADMIN_ROLE(inner) => {
8780 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
8781 inner,
8782 )
8783 }
8784 Self::EXECUTOR_ROLE(inner) => {
8785 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
8786 inner,
8787 )
8788 }
8789 Self::PROPOSER_ROLE(inner) => {
8790 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
8791 inner,
8792 )
8793 }
8794 Self::cancel(inner) => {
8795 <cancelCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8796 }
8797 Self::execute(inner) => {
8798 <executeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8799 }
8800 Self::executeBatch(inner) => {
8801 <executeBatchCall as alloy_sol_types::SolCall>::abi_encoded_size(
8802 inner,
8803 )
8804 }
8805 Self::getMinDelay(inner) => {
8806 <getMinDelayCall as alloy_sol_types::SolCall>::abi_encoded_size(
8807 inner,
8808 )
8809 }
8810 Self::getOperationState(inner) => {
8811 <getOperationStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
8812 inner,
8813 )
8814 }
8815 Self::getRoleAdmin(inner) => {
8816 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
8817 inner,
8818 )
8819 }
8820 Self::getTimestamp(inner) => {
8821 <getTimestampCall as alloy_sol_types::SolCall>::abi_encoded_size(
8822 inner,
8823 )
8824 }
8825 Self::grantRole(inner) => {
8826 <grantRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8827 }
8828 Self::hasRole(inner) => {
8829 <hasRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8830 }
8831 Self::hashOperation(inner) => {
8832 <hashOperationCall as alloy_sol_types::SolCall>::abi_encoded_size(
8833 inner,
8834 )
8835 }
8836 Self::hashOperationBatch(inner) => {
8837 <hashOperationBatchCall as alloy_sol_types::SolCall>::abi_encoded_size(
8838 inner,
8839 )
8840 }
8841 Self::isOperation(inner) => {
8842 <isOperationCall as alloy_sol_types::SolCall>::abi_encoded_size(
8843 inner,
8844 )
8845 }
8846 Self::isOperationDone(inner) => {
8847 <isOperationDoneCall as alloy_sol_types::SolCall>::abi_encoded_size(
8848 inner,
8849 )
8850 }
8851 Self::isOperationPending(inner) => {
8852 <isOperationPendingCall as alloy_sol_types::SolCall>::abi_encoded_size(
8853 inner,
8854 )
8855 }
8856 Self::isOperationReady(inner) => {
8857 <isOperationReadyCall as alloy_sol_types::SolCall>::abi_encoded_size(
8858 inner,
8859 )
8860 }
8861 Self::onERC1155BatchReceived(inner) => {
8862 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
8863 inner,
8864 )
8865 }
8866 Self::onERC1155Received(inner) => {
8867 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
8868 inner,
8869 )
8870 }
8871 Self::onERC721Received(inner) => {
8872 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
8873 inner,
8874 )
8875 }
8876 Self::renounceRole(inner) => {
8877 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(
8878 inner,
8879 )
8880 }
8881 Self::revokeRole(inner) => {
8882 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8883 }
8884 Self::schedule(inner) => {
8885 <scheduleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
8886 }
8887 Self::scheduleBatch(inner) => {
8888 <scheduleBatchCall as alloy_sol_types::SolCall>::abi_encoded_size(
8889 inner,
8890 )
8891 }
8892 Self::supportsInterface(inner) => {
8893 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(
8894 inner,
8895 )
8896 }
8897 Self::updateDelay(inner) => {
8898 <updateDelayCall as alloy_sol_types::SolCall>::abi_encoded_size(
8899 inner,
8900 )
8901 }
8902 }
8903 }
8904 #[inline]
8905 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
8906 match self {
8907 Self::CANCELLER_ROLE(inner) => {
8908 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
8909 inner,
8910 out,
8911 )
8912 }
8913 Self::DEFAULT_ADMIN_ROLE(inner) => {
8914 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
8915 inner,
8916 out,
8917 )
8918 }
8919 Self::EXECUTOR_ROLE(inner) => {
8920 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
8921 inner,
8922 out,
8923 )
8924 }
8925 Self::PROPOSER_ROLE(inner) => {
8926 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
8927 inner,
8928 out,
8929 )
8930 }
8931 Self::cancel(inner) => {
8932 <cancelCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8933 }
8934 Self::execute(inner) => {
8935 <executeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8936 }
8937 Self::executeBatch(inner) => {
8938 <executeBatchCall as alloy_sol_types::SolCall>::abi_encode_raw(
8939 inner,
8940 out,
8941 )
8942 }
8943 Self::getMinDelay(inner) => {
8944 <getMinDelayCall as alloy_sol_types::SolCall>::abi_encode_raw(
8945 inner,
8946 out,
8947 )
8948 }
8949 Self::getOperationState(inner) => {
8950 <getOperationStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
8951 inner,
8952 out,
8953 )
8954 }
8955 Self::getRoleAdmin(inner) => {
8956 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
8957 inner,
8958 out,
8959 )
8960 }
8961 Self::getTimestamp(inner) => {
8962 <getTimestampCall as alloy_sol_types::SolCall>::abi_encode_raw(
8963 inner,
8964 out,
8965 )
8966 }
8967 Self::grantRole(inner) => {
8968 <grantRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
8969 inner,
8970 out,
8971 )
8972 }
8973 Self::hasRole(inner) => {
8974 <hasRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
8975 }
8976 Self::hashOperation(inner) => {
8977 <hashOperationCall as alloy_sol_types::SolCall>::abi_encode_raw(
8978 inner,
8979 out,
8980 )
8981 }
8982 Self::hashOperationBatch(inner) => {
8983 <hashOperationBatchCall as alloy_sol_types::SolCall>::abi_encode_raw(
8984 inner,
8985 out,
8986 )
8987 }
8988 Self::isOperation(inner) => {
8989 <isOperationCall as alloy_sol_types::SolCall>::abi_encode_raw(
8990 inner,
8991 out,
8992 )
8993 }
8994 Self::isOperationDone(inner) => {
8995 <isOperationDoneCall as alloy_sol_types::SolCall>::abi_encode_raw(
8996 inner,
8997 out,
8998 )
8999 }
9000 Self::isOperationPending(inner) => {
9001 <isOperationPendingCall as alloy_sol_types::SolCall>::abi_encode_raw(
9002 inner,
9003 out,
9004 )
9005 }
9006 Self::isOperationReady(inner) => {
9007 <isOperationReadyCall as alloy_sol_types::SolCall>::abi_encode_raw(
9008 inner,
9009 out,
9010 )
9011 }
9012 Self::onERC1155BatchReceived(inner) => {
9013 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
9014 inner,
9015 out,
9016 )
9017 }
9018 Self::onERC1155Received(inner) => {
9019 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
9020 inner,
9021 out,
9022 )
9023 }
9024 Self::onERC721Received(inner) => {
9025 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
9026 inner,
9027 out,
9028 )
9029 }
9030 Self::renounceRole(inner) => {
9031 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
9032 inner,
9033 out,
9034 )
9035 }
9036 Self::revokeRole(inner) => {
9037 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
9038 inner,
9039 out,
9040 )
9041 }
9042 Self::schedule(inner) => {
9043 <scheduleCall as alloy_sol_types::SolCall>::abi_encode_raw(
9044 inner,
9045 out,
9046 )
9047 }
9048 Self::scheduleBatch(inner) => {
9049 <scheduleBatchCall as alloy_sol_types::SolCall>::abi_encode_raw(
9050 inner,
9051 out,
9052 )
9053 }
9054 Self::supportsInterface(inner) => {
9055 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(
9056 inner,
9057 out,
9058 )
9059 }
9060 Self::updateDelay(inner) => {
9061 <updateDelayCall as alloy_sol_types::SolCall>::abi_encode_raw(
9062 inner,
9063 out,
9064 )
9065 }
9066 }
9067 }
9068 }
9069 #[derive(serde::Serialize, serde::Deserialize)]
9071 #[derive(Debug, PartialEq, Eq, Hash)]
9072 pub enum SafeExitTimelockErrors {
9073 #[allow(missing_docs)]
9074 AccessControlBadConfirmation(AccessControlBadConfirmation),
9075 #[allow(missing_docs)]
9076 AccessControlUnauthorizedAccount(AccessControlUnauthorizedAccount),
9077 #[allow(missing_docs)]
9078 FailedInnerCall(FailedInnerCall),
9079 #[allow(missing_docs)]
9080 TimelockInsufficientDelay(TimelockInsufficientDelay),
9081 #[allow(missing_docs)]
9082 TimelockInvalidOperationLength(TimelockInvalidOperationLength),
9083 #[allow(missing_docs)]
9084 TimelockUnauthorizedCaller(TimelockUnauthorizedCaller),
9085 #[allow(missing_docs)]
9086 TimelockUnexecutedPredecessor(TimelockUnexecutedPredecessor),
9087 #[allow(missing_docs)]
9088 TimelockUnexpectedOperationState(TimelockUnexpectedOperationState),
9089 }
9090 #[automatically_derived]
9091 impl SafeExitTimelockErrors {
9092 pub const SELECTORS: &'static [[u8; 4usize]] = &[
9099 [20u8, 37u8, 234u8, 66u8],
9100 [84u8, 51u8, 102u8, 9u8],
9101 [94u8, 173u8, 142u8, 181u8],
9102 [102u8, 151u8, 178u8, 50u8],
9103 [144u8, 169u8, 166u8, 24u8],
9104 [226u8, 81u8, 125u8, 63u8],
9105 [226u8, 133u8, 12u8, 89u8],
9106 [255u8, 176u8, 50u8, 17u8],
9107 ];
9108 }
9109 #[automatically_derived]
9110 impl alloy_sol_types::SolInterface for SafeExitTimelockErrors {
9111 const NAME: &'static str = "SafeExitTimelockErrors";
9112 const MIN_DATA_LENGTH: usize = 0usize;
9113 const COUNT: usize = 8usize;
9114 #[inline]
9115 fn selector(&self) -> [u8; 4] {
9116 match self {
9117 Self::AccessControlBadConfirmation(_) => {
9118 <AccessControlBadConfirmation as alloy_sol_types::SolError>::SELECTOR
9119 }
9120 Self::AccessControlUnauthorizedAccount(_) => {
9121 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
9122 }
9123 Self::FailedInnerCall(_) => {
9124 <FailedInnerCall as alloy_sol_types::SolError>::SELECTOR
9125 }
9126 Self::TimelockInsufficientDelay(_) => {
9127 <TimelockInsufficientDelay as alloy_sol_types::SolError>::SELECTOR
9128 }
9129 Self::TimelockInvalidOperationLength(_) => {
9130 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::SELECTOR
9131 }
9132 Self::TimelockUnauthorizedCaller(_) => {
9133 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::SELECTOR
9134 }
9135 Self::TimelockUnexecutedPredecessor(_) => {
9136 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::SELECTOR
9137 }
9138 Self::TimelockUnexpectedOperationState(_) => {
9139 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::SELECTOR
9140 }
9141 }
9142 }
9143 #[inline]
9144 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
9145 Self::SELECTORS.get(i).copied()
9146 }
9147 #[inline]
9148 fn valid_selector(selector: [u8; 4]) -> bool {
9149 Self::SELECTORS.binary_search(&selector).is_ok()
9150 }
9151 #[inline]
9152 #[allow(non_snake_case)]
9153 fn abi_decode_raw(
9154 selector: [u8; 4],
9155 data: &[u8],
9156 ) -> alloy_sol_types::Result<Self> {
9157 static DECODE_SHIMS: &[fn(
9158 &[u8],
9159 ) -> alloy_sol_types::Result<SafeExitTimelockErrors>] = &[
9160 {
9161 fn FailedInnerCall(
9162 data: &[u8],
9163 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9164 <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw(
9165 data,
9166 )
9167 .map(SafeExitTimelockErrors::FailedInnerCall)
9168 }
9169 FailedInnerCall
9170 },
9171 {
9172 fn TimelockInsufficientDelay(
9173 data: &[u8],
9174 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9175 <TimelockInsufficientDelay as alloy_sol_types::SolError>::abi_decode_raw(
9176 data,
9177 )
9178 .map(SafeExitTimelockErrors::TimelockInsufficientDelay)
9179 }
9180 TimelockInsufficientDelay
9181 },
9182 {
9183 fn TimelockUnexpectedOperationState(
9184 data: &[u8],
9185 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9186 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::abi_decode_raw(
9187 data,
9188 )
9189 .map(
9190 SafeExitTimelockErrors::TimelockUnexpectedOperationState,
9191 )
9192 }
9193 TimelockUnexpectedOperationState
9194 },
9195 {
9196 fn AccessControlBadConfirmation(
9197 data: &[u8],
9198 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9199 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_decode_raw(
9200 data,
9201 )
9202 .map(SafeExitTimelockErrors::AccessControlBadConfirmation)
9203 }
9204 AccessControlBadConfirmation
9205 },
9206 {
9207 fn TimelockUnexecutedPredecessor(
9208 data: &[u8],
9209 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9210 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::abi_decode_raw(
9211 data,
9212 )
9213 .map(SafeExitTimelockErrors::TimelockUnexecutedPredecessor)
9214 }
9215 TimelockUnexecutedPredecessor
9216 },
9217 {
9218 fn AccessControlUnauthorizedAccount(
9219 data: &[u8],
9220 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9221 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw(
9222 data,
9223 )
9224 .map(
9225 SafeExitTimelockErrors::AccessControlUnauthorizedAccount,
9226 )
9227 }
9228 AccessControlUnauthorizedAccount
9229 },
9230 {
9231 fn TimelockUnauthorizedCaller(
9232 data: &[u8],
9233 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9234 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::abi_decode_raw(
9235 data,
9236 )
9237 .map(SafeExitTimelockErrors::TimelockUnauthorizedCaller)
9238 }
9239 TimelockUnauthorizedCaller
9240 },
9241 {
9242 fn TimelockInvalidOperationLength(
9243 data: &[u8],
9244 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9245 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::abi_decode_raw(
9246 data,
9247 )
9248 .map(SafeExitTimelockErrors::TimelockInvalidOperationLength)
9249 }
9250 TimelockInvalidOperationLength
9251 },
9252 ];
9253 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
9254 return Err(
9255 alloy_sol_types::Error::unknown_selector(
9256 <Self as alloy_sol_types::SolInterface>::NAME,
9257 selector,
9258 ),
9259 );
9260 };
9261 DECODE_SHIMS[idx](data)
9262 }
9263 #[inline]
9264 #[allow(non_snake_case)]
9265 fn abi_decode_raw_validate(
9266 selector: [u8; 4],
9267 data: &[u8],
9268 ) -> alloy_sol_types::Result<Self> {
9269 static DECODE_VALIDATE_SHIMS: &[fn(
9270 &[u8],
9271 ) -> alloy_sol_types::Result<SafeExitTimelockErrors>] = &[
9272 {
9273 fn FailedInnerCall(
9274 data: &[u8],
9275 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9276 <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw_validate(
9277 data,
9278 )
9279 .map(SafeExitTimelockErrors::FailedInnerCall)
9280 }
9281 FailedInnerCall
9282 },
9283 {
9284 fn TimelockInsufficientDelay(
9285 data: &[u8],
9286 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9287 <TimelockInsufficientDelay as alloy_sol_types::SolError>::abi_decode_raw_validate(
9288 data,
9289 )
9290 .map(SafeExitTimelockErrors::TimelockInsufficientDelay)
9291 }
9292 TimelockInsufficientDelay
9293 },
9294 {
9295 fn TimelockUnexpectedOperationState(
9296 data: &[u8],
9297 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9298 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::abi_decode_raw_validate(
9299 data,
9300 )
9301 .map(
9302 SafeExitTimelockErrors::TimelockUnexpectedOperationState,
9303 )
9304 }
9305 TimelockUnexpectedOperationState
9306 },
9307 {
9308 fn AccessControlBadConfirmation(
9309 data: &[u8],
9310 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9311 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_decode_raw_validate(
9312 data,
9313 )
9314 .map(SafeExitTimelockErrors::AccessControlBadConfirmation)
9315 }
9316 AccessControlBadConfirmation
9317 },
9318 {
9319 fn TimelockUnexecutedPredecessor(
9320 data: &[u8],
9321 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9322 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::abi_decode_raw_validate(
9323 data,
9324 )
9325 .map(SafeExitTimelockErrors::TimelockUnexecutedPredecessor)
9326 }
9327 TimelockUnexecutedPredecessor
9328 },
9329 {
9330 fn AccessControlUnauthorizedAccount(
9331 data: &[u8],
9332 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9333 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw_validate(
9334 data,
9335 )
9336 .map(
9337 SafeExitTimelockErrors::AccessControlUnauthorizedAccount,
9338 )
9339 }
9340 AccessControlUnauthorizedAccount
9341 },
9342 {
9343 fn TimelockUnauthorizedCaller(
9344 data: &[u8],
9345 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9346 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::abi_decode_raw_validate(
9347 data,
9348 )
9349 .map(SafeExitTimelockErrors::TimelockUnauthorizedCaller)
9350 }
9351 TimelockUnauthorizedCaller
9352 },
9353 {
9354 fn TimelockInvalidOperationLength(
9355 data: &[u8],
9356 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
9357 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::abi_decode_raw_validate(
9358 data,
9359 )
9360 .map(SafeExitTimelockErrors::TimelockInvalidOperationLength)
9361 }
9362 TimelockInvalidOperationLength
9363 },
9364 ];
9365 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
9366 return Err(
9367 alloy_sol_types::Error::unknown_selector(
9368 <Self as alloy_sol_types::SolInterface>::NAME,
9369 selector,
9370 ),
9371 );
9372 };
9373 DECODE_VALIDATE_SHIMS[idx](data)
9374 }
9375 #[inline]
9376 fn abi_encoded_size(&self) -> usize {
9377 match self {
9378 Self::AccessControlBadConfirmation(inner) => {
9379 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_encoded_size(
9380 inner,
9381 )
9382 }
9383 Self::AccessControlUnauthorizedAccount(inner) => {
9384 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
9385 inner,
9386 )
9387 }
9388 Self::FailedInnerCall(inner) => {
9389 <FailedInnerCall as alloy_sol_types::SolError>::abi_encoded_size(
9390 inner,
9391 )
9392 }
9393 Self::TimelockInsufficientDelay(inner) => {
9394 <TimelockInsufficientDelay as alloy_sol_types::SolError>::abi_encoded_size(
9395 inner,
9396 )
9397 }
9398 Self::TimelockInvalidOperationLength(inner) => {
9399 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::abi_encoded_size(
9400 inner,
9401 )
9402 }
9403 Self::TimelockUnauthorizedCaller(inner) => {
9404 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::abi_encoded_size(
9405 inner,
9406 )
9407 }
9408 Self::TimelockUnexecutedPredecessor(inner) => {
9409 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::abi_encoded_size(
9410 inner,
9411 )
9412 }
9413 Self::TimelockUnexpectedOperationState(inner) => {
9414 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::abi_encoded_size(
9415 inner,
9416 )
9417 }
9418 }
9419 }
9420 #[inline]
9421 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
9422 match self {
9423 Self::AccessControlBadConfirmation(inner) => {
9424 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_encode_raw(
9425 inner,
9426 out,
9427 )
9428 }
9429 Self::AccessControlUnauthorizedAccount(inner) => {
9430 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
9431 inner,
9432 out,
9433 )
9434 }
9435 Self::FailedInnerCall(inner) => {
9436 <FailedInnerCall as alloy_sol_types::SolError>::abi_encode_raw(
9437 inner,
9438 out,
9439 )
9440 }
9441 Self::TimelockInsufficientDelay(inner) => {
9442 <TimelockInsufficientDelay as alloy_sol_types::SolError>::abi_encode_raw(
9443 inner,
9444 out,
9445 )
9446 }
9447 Self::TimelockInvalidOperationLength(inner) => {
9448 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::abi_encode_raw(
9449 inner,
9450 out,
9451 )
9452 }
9453 Self::TimelockUnauthorizedCaller(inner) => {
9454 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::abi_encode_raw(
9455 inner,
9456 out,
9457 )
9458 }
9459 Self::TimelockUnexecutedPredecessor(inner) => {
9460 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::abi_encode_raw(
9461 inner,
9462 out,
9463 )
9464 }
9465 Self::TimelockUnexpectedOperationState(inner) => {
9466 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::abi_encode_raw(
9467 inner,
9468 out,
9469 )
9470 }
9471 }
9472 }
9473 }
9474 #[derive(serde::Serialize, serde::Deserialize)]
9476 #[derive(Debug, PartialEq, Eq, Hash)]
9477 pub enum SafeExitTimelockEvents {
9478 #[allow(missing_docs)]
9479 CallExecuted(CallExecuted),
9480 #[allow(missing_docs)]
9481 CallSalt(CallSalt),
9482 #[allow(missing_docs)]
9483 CallScheduled(CallScheduled),
9484 #[allow(missing_docs)]
9485 Cancelled(Cancelled),
9486 #[allow(missing_docs)]
9487 MinDelayChange(MinDelayChange),
9488 #[allow(missing_docs)]
9489 RoleAdminChanged(RoleAdminChanged),
9490 #[allow(missing_docs)]
9491 RoleGranted(RoleGranted),
9492 #[allow(missing_docs)]
9493 RoleRevoked(RoleRevoked),
9494 }
9495 #[automatically_derived]
9496 impl SafeExitTimelockEvents {
9497 pub const SELECTORS: &'static [[u8; 32usize]] = &[
9504 [
9505 17u8, 194u8, 79u8, 78u8, 173u8, 22u8, 80u8, 124u8, 105u8, 172u8, 70u8,
9506 127u8, 189u8, 94u8, 78u8, 237u8, 95u8, 181u8, 198u8, 153u8, 98u8, 109u8,
9507 44u8, 198u8, 214u8, 100u8, 33u8, 223u8, 37u8, 56u8, 134u8, 213u8,
9508 ],
9509 [
9510 32u8, 253u8, 165u8, 253u8, 39u8, 161u8, 234u8, 123u8, 245u8, 185u8, 86u8,
9511 127u8, 20u8, 58u8, 197u8, 71u8, 11u8, 176u8, 89u8, 55u8, 74u8, 39u8,
9512 232u8, 246u8, 124u8, 180u8, 79u8, 148u8, 111u8, 109u8, 3u8, 135u8,
9513 ],
9514 [
9515 47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8,
9516 236u8, 121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8,
9517 64u8, 48u8, 69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
9518 ],
9519 [
9520 76u8, 244u8, 65u8, 12u8, 197u8, 112u8, 64u8, 228u8, 72u8, 98u8, 239u8,
9521 15u8, 69u8, 243u8, 221u8, 90u8, 94u8, 2u8, 219u8, 142u8, 184u8, 173u8,
9522 214u8, 72u8, 212u8, 176u8, 226u8, 54u8, 241u8, 208u8, 125u8, 202u8,
9523 ],
9524 [
9525 186u8, 161u8, 235u8, 34u8, 242u8, 164u8, 146u8, 186u8, 26u8, 95u8, 234u8,
9526 97u8, 184u8, 223u8, 77u8, 39u8, 198u8, 200u8, 181u8, 243u8, 151u8, 30u8,
9527 99u8, 187u8, 88u8, 250u8, 20u8, 255u8, 114u8, 238u8, 219u8, 112u8,
9528 ],
9529 [
9530 189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8,
9531 81u8, 66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8,
9532 71u8, 92u8, 58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
9533 ],
9534 [
9535 194u8, 97u8, 126u8, 250u8, 105u8, 186u8, 182u8, 103u8, 130u8, 250u8,
9536 33u8, 149u8, 67u8, 113u8, 67u8, 56u8, 72u8, 156u8, 78u8, 158u8, 23u8,
9537 130u8, 113u8, 86u8, 10u8, 145u8, 184u8, 44u8, 63u8, 97u8, 43u8, 88u8,
9538 ],
9539 [
9540 246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8,
9541 103u8, 11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8,
9542 253u8, 100u8, 235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
9543 ],
9544 ];
9545 }
9546 #[automatically_derived]
9547 impl alloy_sol_types::SolEventInterface for SafeExitTimelockEvents {
9548 const NAME: &'static str = "SafeExitTimelockEvents";
9549 const COUNT: usize = 8usize;
9550 fn decode_raw_log(
9551 topics: &[alloy_sol_types::Word],
9552 data: &[u8],
9553 ) -> alloy_sol_types::Result<Self> {
9554 match topics.first().copied() {
9555 Some(<CallExecuted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9556 <CallExecuted as alloy_sol_types::SolEvent>::decode_raw_log(
9557 topics,
9558 data,
9559 )
9560 .map(Self::CallExecuted)
9561 }
9562 Some(<CallSalt as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9563 <CallSalt as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
9564 .map(Self::CallSalt)
9565 }
9566 Some(<CallScheduled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9567 <CallScheduled as alloy_sol_types::SolEvent>::decode_raw_log(
9568 topics,
9569 data,
9570 )
9571 .map(Self::CallScheduled)
9572 }
9573 Some(<Cancelled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9574 <Cancelled as alloy_sol_types::SolEvent>::decode_raw_log(
9575 topics,
9576 data,
9577 )
9578 .map(Self::Cancelled)
9579 }
9580 Some(<MinDelayChange as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9581 <MinDelayChange as alloy_sol_types::SolEvent>::decode_raw_log(
9582 topics,
9583 data,
9584 )
9585 .map(Self::MinDelayChange)
9586 }
9587 Some(<RoleAdminChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9588 <RoleAdminChanged as alloy_sol_types::SolEvent>::decode_raw_log(
9589 topics,
9590 data,
9591 )
9592 .map(Self::RoleAdminChanged)
9593 }
9594 Some(<RoleGranted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9595 <RoleGranted as alloy_sol_types::SolEvent>::decode_raw_log(
9596 topics,
9597 data,
9598 )
9599 .map(Self::RoleGranted)
9600 }
9601 Some(<RoleRevoked as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
9602 <RoleRevoked as alloy_sol_types::SolEvent>::decode_raw_log(
9603 topics,
9604 data,
9605 )
9606 .map(Self::RoleRevoked)
9607 }
9608 _ => {
9609 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
9610 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
9611 log: alloy_sol_types::private::Box::new(
9612 alloy_sol_types::private::LogData::new_unchecked(
9613 topics.to_vec(),
9614 data.to_vec().into(),
9615 ),
9616 ),
9617 })
9618 }
9619 }
9620 }
9621 }
9622 #[automatically_derived]
9623 impl alloy_sol_types::private::IntoLogData for SafeExitTimelockEvents {
9624 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
9625 match self {
9626 Self::CallExecuted(inner) => {
9627 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9628 }
9629 Self::CallSalt(inner) => {
9630 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9631 }
9632 Self::CallScheduled(inner) => {
9633 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9634 }
9635 Self::Cancelled(inner) => {
9636 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9637 }
9638 Self::MinDelayChange(inner) => {
9639 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9640 }
9641 Self::RoleAdminChanged(inner) => {
9642 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9643 }
9644 Self::RoleGranted(inner) => {
9645 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9646 }
9647 Self::RoleRevoked(inner) => {
9648 alloy_sol_types::private::IntoLogData::to_log_data(inner)
9649 }
9650 }
9651 }
9652 fn into_log_data(self) -> alloy_sol_types::private::LogData {
9653 match self {
9654 Self::CallExecuted(inner) => {
9655 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9656 }
9657 Self::CallSalt(inner) => {
9658 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9659 }
9660 Self::CallScheduled(inner) => {
9661 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9662 }
9663 Self::Cancelled(inner) => {
9664 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9665 }
9666 Self::MinDelayChange(inner) => {
9667 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9668 }
9669 Self::RoleAdminChanged(inner) => {
9670 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9671 }
9672 Self::RoleGranted(inner) => {
9673 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9674 }
9675 Self::RoleRevoked(inner) => {
9676 alloy_sol_types::private::IntoLogData::into_log_data(inner)
9677 }
9678 }
9679 }
9680 }
9681 use alloy::contract as alloy_contract;
9682 #[inline]
9686 pub const fn new<
9687 P: alloy_contract::private::Provider<N>,
9688 N: alloy_contract::private::Network,
9689 >(
9690 address: alloy_sol_types::private::Address,
9691 __provider: P,
9692 ) -> SafeExitTimelockInstance<P, N> {
9693 SafeExitTimelockInstance::<P, N>::new(address, __provider)
9694 }
9695 #[inline]
9701 pub fn deploy<
9702 P: alloy_contract::private::Provider<N>,
9703 N: alloy_contract::private::Network,
9704 >(
9705 __provider: P,
9706 minDelay: alloy::sol_types::private::primitives::aliases::U256,
9707 proposers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9708 executors: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9709 admin: alloy::sol_types::private::Address,
9710 ) -> impl ::core::future::Future<
9711 Output = alloy_contract::Result<SafeExitTimelockInstance<P, N>>,
9712 > {
9713 SafeExitTimelockInstance::<
9714 P,
9715 N,
9716 >::deploy(__provider, minDelay, proposers, executors, admin)
9717 }
9718 #[inline]
9724 pub fn deploy_builder<
9725 P: alloy_contract::private::Provider<N>,
9726 N: alloy_contract::private::Network,
9727 >(
9728 __provider: P,
9729 minDelay: alloy::sol_types::private::primitives::aliases::U256,
9730 proposers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9731 executors: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9732 admin: alloy::sol_types::private::Address,
9733 ) -> alloy_contract::RawCallBuilder<P, N> {
9734 SafeExitTimelockInstance::<
9735 P,
9736 N,
9737 >::deploy_builder(__provider, minDelay, proposers, executors, admin)
9738 }
9739 #[derive(Clone)]
9751 pub struct SafeExitTimelockInstance<P, N = alloy_contract::private::Ethereum> {
9752 address: alloy_sol_types::private::Address,
9753 provider: P,
9754 _network: ::core::marker::PhantomData<N>,
9755 }
9756 #[automatically_derived]
9757 impl<P, N> ::core::fmt::Debug for SafeExitTimelockInstance<P, N> {
9758 #[inline]
9759 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
9760 f.debug_tuple("SafeExitTimelockInstance").field(&self.address).finish()
9761 }
9762 }
9763 #[automatically_derived]
9765 impl<
9766 P: alloy_contract::private::Provider<N>,
9767 N: alloy_contract::private::Network,
9768 > SafeExitTimelockInstance<P, N> {
9769 #[inline]
9773 pub const fn new(
9774 address: alloy_sol_types::private::Address,
9775 __provider: P,
9776 ) -> Self {
9777 Self {
9778 address,
9779 provider: __provider,
9780 _network: ::core::marker::PhantomData,
9781 }
9782 }
9783 #[inline]
9789 pub async fn deploy(
9790 __provider: P,
9791 minDelay: alloy::sol_types::private::primitives::aliases::U256,
9792 proposers: alloy::sol_types::private::Vec<
9793 alloy::sol_types::private::Address,
9794 >,
9795 executors: alloy::sol_types::private::Vec<
9796 alloy::sol_types::private::Address,
9797 >,
9798 admin: alloy::sol_types::private::Address,
9799 ) -> alloy_contract::Result<SafeExitTimelockInstance<P, N>> {
9800 let call_builder = Self::deploy_builder(
9801 __provider,
9802 minDelay,
9803 proposers,
9804 executors,
9805 admin,
9806 );
9807 let contract_address = call_builder.deploy().await?;
9808 Ok(Self::new(contract_address, call_builder.provider))
9809 }
9810 #[inline]
9816 pub fn deploy_builder(
9817 __provider: P,
9818 minDelay: alloy::sol_types::private::primitives::aliases::U256,
9819 proposers: alloy::sol_types::private::Vec<
9820 alloy::sol_types::private::Address,
9821 >,
9822 executors: alloy::sol_types::private::Vec<
9823 alloy::sol_types::private::Address,
9824 >,
9825 admin: alloy::sol_types::private::Address,
9826 ) -> alloy_contract::RawCallBuilder<P, N> {
9827 alloy_contract::RawCallBuilder::new_raw_deploy(
9828 __provider,
9829 [
9830 &BYTECODE[..],
9831 &alloy_sol_types::SolConstructor::abi_encode(
9832 &constructorCall {
9833 minDelay,
9834 proposers,
9835 executors,
9836 admin,
9837 },
9838 )[..],
9839 ]
9840 .concat()
9841 .into(),
9842 )
9843 }
9844 #[inline]
9846 pub const fn address(&self) -> &alloy_sol_types::private::Address {
9847 &self.address
9848 }
9849 #[inline]
9851 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
9852 self.address = address;
9853 }
9854 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
9856 self.set_address(address);
9857 self
9858 }
9859 #[inline]
9861 pub const fn provider(&self) -> &P {
9862 &self.provider
9863 }
9864 }
9865 impl<P: ::core::clone::Clone, N> SafeExitTimelockInstance<&P, N> {
9866 #[inline]
9868 pub fn with_cloned_provider(self) -> SafeExitTimelockInstance<P, N> {
9869 SafeExitTimelockInstance {
9870 address: self.address,
9871 provider: ::core::clone::Clone::clone(&self.provider),
9872 _network: ::core::marker::PhantomData,
9873 }
9874 }
9875 }
9876 #[automatically_derived]
9878 impl<
9879 P: alloy_contract::private::Provider<N>,
9880 N: alloy_contract::private::Network,
9881 > SafeExitTimelockInstance<P, N> {
9882 pub fn call_builder<C: alloy_sol_types::SolCall>(
9887 &self,
9888 call: &C,
9889 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
9890 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
9891 }
9892 pub fn CANCELLER_ROLE(
9894 &self,
9895 ) -> alloy_contract::SolCallBuilder<&P, CANCELLER_ROLECall, N> {
9896 self.call_builder(&CANCELLER_ROLECall)
9897 }
9898 pub fn DEFAULT_ADMIN_ROLE(
9900 &self,
9901 ) -> alloy_contract::SolCallBuilder<&P, DEFAULT_ADMIN_ROLECall, N> {
9902 self.call_builder(&DEFAULT_ADMIN_ROLECall)
9903 }
9904 pub fn EXECUTOR_ROLE(
9906 &self,
9907 ) -> alloy_contract::SolCallBuilder<&P, EXECUTOR_ROLECall, N> {
9908 self.call_builder(&EXECUTOR_ROLECall)
9909 }
9910 pub fn PROPOSER_ROLE(
9912 &self,
9913 ) -> alloy_contract::SolCallBuilder<&P, PROPOSER_ROLECall, N> {
9914 self.call_builder(&PROPOSER_ROLECall)
9915 }
9916 pub fn cancel(
9918 &self,
9919 id: alloy::sol_types::private::FixedBytes<32>,
9920 ) -> alloy_contract::SolCallBuilder<&P, cancelCall, N> {
9921 self.call_builder(&cancelCall { id })
9922 }
9923 pub fn execute(
9925 &self,
9926 target: alloy::sol_types::private::Address,
9927 value: alloy::sol_types::private::primitives::aliases::U256,
9928 payload: alloy::sol_types::private::Bytes,
9929 predecessor: alloy::sol_types::private::FixedBytes<32>,
9930 salt: alloy::sol_types::private::FixedBytes<32>,
9931 ) -> alloy_contract::SolCallBuilder<&P, executeCall, N> {
9932 self.call_builder(
9933 &executeCall {
9934 target,
9935 value,
9936 payload,
9937 predecessor,
9938 salt,
9939 },
9940 )
9941 }
9942 pub fn executeBatch(
9944 &self,
9945 targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9946 values: alloy::sol_types::private::Vec<
9947 alloy::sol_types::private::primitives::aliases::U256,
9948 >,
9949 payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
9950 predecessor: alloy::sol_types::private::FixedBytes<32>,
9951 salt: alloy::sol_types::private::FixedBytes<32>,
9952 ) -> alloy_contract::SolCallBuilder<&P, executeBatchCall, N> {
9953 self.call_builder(
9954 &executeBatchCall {
9955 targets,
9956 values,
9957 payloads,
9958 predecessor,
9959 salt,
9960 },
9961 )
9962 }
9963 pub fn getMinDelay(
9965 &self,
9966 ) -> alloy_contract::SolCallBuilder<&P, getMinDelayCall, N> {
9967 self.call_builder(&getMinDelayCall)
9968 }
9969 pub fn getOperationState(
9971 &self,
9972 id: alloy::sol_types::private::FixedBytes<32>,
9973 ) -> alloy_contract::SolCallBuilder<&P, getOperationStateCall, N> {
9974 self.call_builder(&getOperationStateCall { id })
9975 }
9976 pub fn getRoleAdmin(
9978 &self,
9979 role: alloy::sol_types::private::FixedBytes<32>,
9980 ) -> alloy_contract::SolCallBuilder<&P, getRoleAdminCall, N> {
9981 self.call_builder(&getRoleAdminCall { role })
9982 }
9983 pub fn getTimestamp(
9985 &self,
9986 id: alloy::sol_types::private::FixedBytes<32>,
9987 ) -> alloy_contract::SolCallBuilder<&P, getTimestampCall, N> {
9988 self.call_builder(&getTimestampCall { id })
9989 }
9990 pub fn grantRole(
9992 &self,
9993 role: alloy::sol_types::private::FixedBytes<32>,
9994 account: alloy::sol_types::private::Address,
9995 ) -> alloy_contract::SolCallBuilder<&P, grantRoleCall, N> {
9996 self.call_builder(&grantRoleCall { role, account })
9997 }
9998 pub fn hasRole(
10000 &self,
10001 role: alloy::sol_types::private::FixedBytes<32>,
10002 account: alloy::sol_types::private::Address,
10003 ) -> alloy_contract::SolCallBuilder<&P, hasRoleCall, N> {
10004 self.call_builder(&hasRoleCall { role, account })
10005 }
10006 pub fn hashOperation(
10008 &self,
10009 target: alloy::sol_types::private::Address,
10010 value: alloy::sol_types::private::primitives::aliases::U256,
10011 data: alloy::sol_types::private::Bytes,
10012 predecessor: alloy::sol_types::private::FixedBytes<32>,
10013 salt: alloy::sol_types::private::FixedBytes<32>,
10014 ) -> alloy_contract::SolCallBuilder<&P, hashOperationCall, N> {
10015 self.call_builder(
10016 &hashOperationCall {
10017 target,
10018 value,
10019 data,
10020 predecessor,
10021 salt,
10022 },
10023 )
10024 }
10025 pub fn hashOperationBatch(
10027 &self,
10028 targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10029 values: alloy::sol_types::private::Vec<
10030 alloy::sol_types::private::primitives::aliases::U256,
10031 >,
10032 payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
10033 predecessor: alloy::sol_types::private::FixedBytes<32>,
10034 salt: alloy::sol_types::private::FixedBytes<32>,
10035 ) -> alloy_contract::SolCallBuilder<&P, hashOperationBatchCall, N> {
10036 self.call_builder(
10037 &hashOperationBatchCall {
10038 targets,
10039 values,
10040 payloads,
10041 predecessor,
10042 salt,
10043 },
10044 )
10045 }
10046 pub fn isOperation(
10048 &self,
10049 id: alloy::sol_types::private::FixedBytes<32>,
10050 ) -> alloy_contract::SolCallBuilder<&P, isOperationCall, N> {
10051 self.call_builder(&isOperationCall { id })
10052 }
10053 pub fn isOperationDone(
10055 &self,
10056 id: alloy::sol_types::private::FixedBytes<32>,
10057 ) -> alloy_contract::SolCallBuilder<&P, isOperationDoneCall, N> {
10058 self.call_builder(&isOperationDoneCall { id })
10059 }
10060 pub fn isOperationPending(
10062 &self,
10063 id: alloy::sol_types::private::FixedBytes<32>,
10064 ) -> alloy_contract::SolCallBuilder<&P, isOperationPendingCall, N> {
10065 self.call_builder(&isOperationPendingCall { id })
10066 }
10067 pub fn isOperationReady(
10069 &self,
10070 id: alloy::sol_types::private::FixedBytes<32>,
10071 ) -> alloy_contract::SolCallBuilder<&P, isOperationReadyCall, N> {
10072 self.call_builder(&isOperationReadyCall { id })
10073 }
10074 pub fn onERC1155BatchReceived(
10076 &self,
10077 _0: alloy::sol_types::private::Address,
10078 _1: alloy::sol_types::private::Address,
10079 _2: alloy::sol_types::private::Vec<
10080 alloy::sol_types::private::primitives::aliases::U256,
10081 >,
10082 _3: alloy::sol_types::private::Vec<
10083 alloy::sol_types::private::primitives::aliases::U256,
10084 >,
10085 _4: alloy::sol_types::private::Bytes,
10086 ) -> alloy_contract::SolCallBuilder<&P, onERC1155BatchReceivedCall, N> {
10087 self.call_builder(
10088 &onERC1155BatchReceivedCall {
10089 _0,
10090 _1,
10091 _2,
10092 _3,
10093 _4,
10094 },
10095 )
10096 }
10097 pub fn onERC1155Received(
10099 &self,
10100 _0: alloy::sol_types::private::Address,
10101 _1: alloy::sol_types::private::Address,
10102 _2: alloy::sol_types::private::primitives::aliases::U256,
10103 _3: alloy::sol_types::private::primitives::aliases::U256,
10104 _4: alloy::sol_types::private::Bytes,
10105 ) -> alloy_contract::SolCallBuilder<&P, onERC1155ReceivedCall, N> {
10106 self.call_builder(
10107 &onERC1155ReceivedCall {
10108 _0,
10109 _1,
10110 _2,
10111 _3,
10112 _4,
10113 },
10114 )
10115 }
10116 pub fn onERC721Received(
10118 &self,
10119 _0: alloy::sol_types::private::Address,
10120 _1: alloy::sol_types::private::Address,
10121 _2: alloy::sol_types::private::primitives::aliases::U256,
10122 _3: alloy::sol_types::private::Bytes,
10123 ) -> alloy_contract::SolCallBuilder<&P, onERC721ReceivedCall, N> {
10124 self.call_builder(
10125 &onERC721ReceivedCall {
10126 _0,
10127 _1,
10128 _2,
10129 _3,
10130 },
10131 )
10132 }
10133 pub fn renounceRole(
10135 &self,
10136 role: alloy::sol_types::private::FixedBytes<32>,
10137 callerConfirmation: alloy::sol_types::private::Address,
10138 ) -> alloy_contract::SolCallBuilder<&P, renounceRoleCall, N> {
10139 self.call_builder(
10140 &renounceRoleCall {
10141 role,
10142 callerConfirmation,
10143 },
10144 )
10145 }
10146 pub fn revokeRole(
10148 &self,
10149 role: alloy::sol_types::private::FixedBytes<32>,
10150 account: alloy::sol_types::private::Address,
10151 ) -> alloy_contract::SolCallBuilder<&P, revokeRoleCall, N> {
10152 self.call_builder(&revokeRoleCall { role, account })
10153 }
10154 pub fn schedule(
10156 &self,
10157 target: alloy::sol_types::private::Address,
10158 value: alloy::sol_types::private::primitives::aliases::U256,
10159 data: alloy::sol_types::private::Bytes,
10160 predecessor: alloy::sol_types::private::FixedBytes<32>,
10161 salt: alloy::sol_types::private::FixedBytes<32>,
10162 delay: alloy::sol_types::private::primitives::aliases::U256,
10163 ) -> alloy_contract::SolCallBuilder<&P, scheduleCall, N> {
10164 self.call_builder(
10165 &scheduleCall {
10166 target,
10167 value,
10168 data,
10169 predecessor,
10170 salt,
10171 delay,
10172 },
10173 )
10174 }
10175 pub fn scheduleBatch(
10177 &self,
10178 targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10179 values: alloy::sol_types::private::Vec<
10180 alloy::sol_types::private::primitives::aliases::U256,
10181 >,
10182 payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
10183 predecessor: alloy::sol_types::private::FixedBytes<32>,
10184 salt: alloy::sol_types::private::FixedBytes<32>,
10185 delay: alloy::sol_types::private::primitives::aliases::U256,
10186 ) -> alloy_contract::SolCallBuilder<&P, scheduleBatchCall, N> {
10187 self.call_builder(
10188 &scheduleBatchCall {
10189 targets,
10190 values,
10191 payloads,
10192 predecessor,
10193 salt,
10194 delay,
10195 },
10196 )
10197 }
10198 pub fn supportsInterface(
10200 &self,
10201 interfaceId: alloy::sol_types::private::FixedBytes<4>,
10202 ) -> alloy_contract::SolCallBuilder<&P, supportsInterfaceCall, N> {
10203 self.call_builder(
10204 &supportsInterfaceCall {
10205 interfaceId,
10206 },
10207 )
10208 }
10209 pub fn updateDelay(
10211 &self,
10212 newDelay: alloy::sol_types::private::primitives::aliases::U256,
10213 ) -> alloy_contract::SolCallBuilder<&P, updateDelayCall, N> {
10214 self.call_builder(&updateDelayCall { newDelay })
10215 }
10216 }
10217 #[automatically_derived]
10219 impl<
10220 P: alloy_contract::private::Provider<N>,
10221 N: alloy_contract::private::Network,
10222 > SafeExitTimelockInstance<P, N> {
10223 pub fn event_filter<E: alloy_sol_types::SolEvent>(
10228 &self,
10229 ) -> alloy_contract::Event<&P, E, N> {
10230 alloy_contract::Event::new_sol(&self.provider, &self.address)
10231 }
10232 pub fn CallExecuted_filter(&self) -> alloy_contract::Event<&P, CallExecuted, N> {
10234 self.event_filter::<CallExecuted>()
10235 }
10236 pub fn CallSalt_filter(&self) -> alloy_contract::Event<&P, CallSalt, N> {
10238 self.event_filter::<CallSalt>()
10239 }
10240 pub fn CallScheduled_filter(
10242 &self,
10243 ) -> alloy_contract::Event<&P, CallScheduled, N> {
10244 self.event_filter::<CallScheduled>()
10245 }
10246 pub fn Cancelled_filter(&self) -> alloy_contract::Event<&P, Cancelled, N> {
10248 self.event_filter::<Cancelled>()
10249 }
10250 pub fn MinDelayChange_filter(
10252 &self,
10253 ) -> alloy_contract::Event<&P, MinDelayChange, N> {
10254 self.event_filter::<MinDelayChange>()
10255 }
10256 pub fn RoleAdminChanged_filter(
10258 &self,
10259 ) -> alloy_contract::Event<&P, RoleAdminChanged, N> {
10260 self.event_filter::<RoleAdminChanged>()
10261 }
10262 pub fn RoleGranted_filter(&self) -> alloy_contract::Event<&P, RoleGranted, N> {
10264 self.event_filter::<RoleGranted>()
10265 }
10266 pub fn RoleRevoked_filter(&self) -> alloy_contract::Event<&P, RoleRevoked, N> {
10268 self.event_filter::<RoleRevoked>()
10269 }
10270 }
10271}