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(Default, Debug, PartialEq, Eq, Hash)]
20 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
21 #[derive(Clone)]
22 pub struct OperationState(u8);
23 const _: () = {
24 use alloy::sol_types as alloy_sol_types;
25 #[automatically_derived]
26 impl alloy_sol_types::private::SolTypeValue<OperationState> for u8 {
27 #[inline]
28 fn stv_to_tokens(
29 &self,
30 ) -> <alloy::sol_types::sol_data::Uint<
31 8,
32 > as alloy_sol_types::SolType>::Token<'_> {
33 alloy_sol_types::private::SolTypeValue::<
34 alloy::sol_types::sol_data::Uint<8>,
35 >::stv_to_tokens(self)
36 }
37 #[inline]
38 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
39 <alloy::sol_types::sol_data::Uint<
40 8,
41 > as alloy_sol_types::SolType>::tokenize(self)
42 .0
43 }
44 #[inline]
45 fn stv_abi_encode_packed_to(
46 &self,
47 out: &mut alloy_sol_types::private::Vec<u8>,
48 ) {
49 <alloy::sol_types::sol_data::Uint<
50 8,
51 > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
52 }
53 #[inline]
54 fn stv_abi_packed_encoded_size(&self) -> usize {
55 <alloy::sol_types::sol_data::Uint<
56 8,
57 > as alloy_sol_types::SolType>::abi_encoded_size(self)
58 }
59 }
60 #[automatically_derived]
61 impl OperationState {
62 pub const NAME: &'static str = stringify!(@ name);
64 #[inline]
66 pub const fn from(value: u8) -> Self {
67 Self(value)
68 }
69 #[inline]
71 pub const fn into(self) -> u8 {
72 self.0
73 }
74 #[inline]
77 pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
78 <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
79 }
80 #[inline]
83 pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
84 <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
85 }
86 }
87 #[automatically_derived]
88 impl alloy_sol_types::SolType for OperationState {
89 type RustType = u8;
90 type Token<'a> = <alloy::sol_types::sol_data::Uint<
91 8,
92 > as alloy_sol_types::SolType>::Token<'a>;
93 const SOL_NAME: &'static str = Self::NAME;
94 const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
95 8,
96 > as alloy_sol_types::SolType>::ENCODED_SIZE;
97 const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
98 8,
99 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
100 #[inline]
101 fn valid_token(token: &Self::Token<'_>) -> bool {
102 Self::type_check(token).is_ok()
103 }
104 #[inline]
105 fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
106 <alloy::sol_types::sol_data::Uint<
107 8,
108 > as alloy_sol_types::SolType>::type_check(token)
109 }
110 #[inline]
111 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
112 <alloy::sol_types::sol_data::Uint<
113 8,
114 > as alloy_sol_types::SolType>::detokenize(token)
115 }
116 }
117 #[automatically_derived]
118 impl alloy_sol_types::EventTopic for OperationState {
119 #[inline]
120 fn topic_preimage_length(rust: &Self::RustType) -> usize {
121 <alloy::sol_types::sol_data::Uint<
122 8,
123 > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
124 }
125 #[inline]
126 fn encode_topic_preimage(
127 rust: &Self::RustType,
128 out: &mut alloy_sol_types::private::Vec<u8>,
129 ) {
130 <alloy::sol_types::sol_data::Uint<
131 8,
132 > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
133 }
134 #[inline]
135 fn encode_topic(
136 rust: &Self::RustType,
137 ) -> alloy_sol_types::abi::token::WordToken {
138 <alloy::sol_types::sol_data::Uint<
139 8,
140 > as alloy_sol_types::EventTopic>::encode_topic(rust)
141 }
142 }
143 };
144 use alloy::contract as alloy_contract;
145 #[inline]
149 pub const fn new<
150 T: alloy_contract::private::Transport + ::core::clone::Clone,
151 P: alloy_contract::private::Provider<T, N>,
152 N: alloy_contract::private::Network,
153 >(
154 address: alloy_sol_types::private::Address,
155 provider: P,
156 ) -> TimelockControllerInstance<T, P, N> {
157 TimelockControllerInstance::<T, P, N>::new(address, provider)
158 }
159 #[derive(Clone)]
171 pub struct TimelockControllerInstance<T, P, N = alloy_contract::private::Ethereum> {
172 address: alloy_sol_types::private::Address,
173 provider: P,
174 _network_transport: ::core::marker::PhantomData<(N, T)>,
175 }
176 #[automatically_derived]
177 impl<T, P, N> ::core::fmt::Debug for TimelockControllerInstance<T, P, N> {
178 #[inline]
179 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
180 f.debug_tuple("TimelockControllerInstance").field(&self.address).finish()
181 }
182 }
183 #[automatically_derived]
185 impl<
186 T: alloy_contract::private::Transport + ::core::clone::Clone,
187 P: alloy_contract::private::Provider<T, N>,
188 N: alloy_contract::private::Network,
189 > TimelockControllerInstance<T, P, N> {
190 #[inline]
194 pub const fn new(
195 address: alloy_sol_types::private::Address,
196 provider: P,
197 ) -> Self {
198 Self {
199 address,
200 provider,
201 _network_transport: ::core::marker::PhantomData,
202 }
203 }
204 #[inline]
206 pub const fn address(&self) -> &alloy_sol_types::private::Address {
207 &self.address
208 }
209 #[inline]
211 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
212 self.address = address;
213 }
214 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
216 self.set_address(address);
217 self
218 }
219 #[inline]
221 pub const fn provider(&self) -> &P {
222 &self.provider
223 }
224 }
225 impl<T, P: ::core::clone::Clone, N> TimelockControllerInstance<T, &P, N> {
226 #[inline]
228 pub fn with_cloned_provider(self) -> TimelockControllerInstance<T, P, N> {
229 TimelockControllerInstance {
230 address: self.address,
231 provider: ::core::clone::Clone::clone(&self.provider),
232 _network_transport: ::core::marker::PhantomData,
233 }
234 }
235 }
236 #[automatically_derived]
238 impl<
239 T: alloy_contract::private::Transport + ::core::clone::Clone,
240 P: alloy_contract::private::Provider<T, N>,
241 N: alloy_contract::private::Network,
242 > TimelockControllerInstance<T, P, N> {
243 pub fn call_builder<C: alloy_sol_types::SolCall>(
248 &self,
249 call: &C,
250 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
251 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
252 }
253 }
254 #[automatically_derived]
256 impl<
257 T: alloy_contract::private::Transport + ::core::clone::Clone,
258 P: alloy_contract::private::Provider<T, N>,
259 N: alloy_contract::private::Network,
260 > TimelockControllerInstance<T, P, N> {
261 pub fn event_filter<E: alloy_sol_types::SolEvent>(
266 &self,
267 ) -> alloy_contract::Event<T, &P, E, N> {
268 alloy_contract::Event::new_sol(&self.provider, &self.address)
269 }
270 }
271}
272#[allow(
1336 non_camel_case_types,
1337 non_snake_case,
1338 clippy::pub_underscore_fields,
1339 clippy::style,
1340 clippy::empty_structs_with_brackets
1341)]
1342pub mod SafeExitTimelock {
1343 use super::*;
1344 use alloy::sol_types as alloy_sol_types;
1345 #[rustfmt::skip]
1351 #[allow(clippy::all)]
1352 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
1353 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",
1354 );
1355 #[rustfmt::skip]
1361 #[allow(clippy::all)]
1362 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
1363 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",
1364 );
1365 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1366 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1371 #[derive(Clone)]
1372 pub struct AccessControlBadConfirmation {}
1373 #[allow(
1374 non_camel_case_types,
1375 non_snake_case,
1376 clippy::pub_underscore_fields,
1377 clippy::style
1378 )]
1379 const _: () = {
1380 use alloy::sol_types as alloy_sol_types;
1381 #[doc(hidden)]
1382 type UnderlyingSolTuple<'a> = ();
1383 #[doc(hidden)]
1384 type UnderlyingRustTuple<'a> = ();
1385 #[cfg(test)]
1386 #[allow(dead_code, unreachable_patterns)]
1387 fn _type_assertion(
1388 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1389 ) {
1390 match _t {
1391 alloy_sol_types::private::AssertTypeEq::<
1392 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1393 >(_) => {}
1394 }
1395 }
1396 #[automatically_derived]
1397 #[doc(hidden)]
1398 impl ::core::convert::From<AccessControlBadConfirmation>
1399 for UnderlyingRustTuple<'_> {
1400 fn from(value: AccessControlBadConfirmation) -> Self {
1401 ()
1402 }
1403 }
1404 #[automatically_derived]
1405 #[doc(hidden)]
1406 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1407 for AccessControlBadConfirmation {
1408 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1409 Self {}
1410 }
1411 }
1412 #[automatically_derived]
1413 impl alloy_sol_types::SolError for AccessControlBadConfirmation {
1414 type Parameters<'a> = UnderlyingSolTuple<'a>;
1415 type Token<'a> = <Self::Parameters<
1416 'a,
1417 > as alloy_sol_types::SolType>::Token<'a>;
1418 const SIGNATURE: &'static str = "AccessControlBadConfirmation()";
1419 const SELECTOR: [u8; 4] = [102u8, 151u8, 178u8, 50u8];
1420 #[inline]
1421 fn new<'a>(
1422 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1423 ) -> Self {
1424 tuple.into()
1425 }
1426 #[inline]
1427 fn tokenize(&self) -> Self::Token<'_> {
1428 ()
1429 }
1430 }
1431 };
1432 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1433 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1438 #[derive(Clone)]
1439 pub struct AccessControlUnauthorizedAccount {
1440 #[allow(missing_docs)]
1441 pub account: alloy::sol_types::private::Address,
1442 #[allow(missing_docs)]
1443 pub neededRole: alloy::sol_types::private::FixedBytes<32>,
1444 }
1445 #[allow(
1446 non_camel_case_types,
1447 non_snake_case,
1448 clippy::pub_underscore_fields,
1449 clippy::style
1450 )]
1451 const _: () = {
1452 use alloy::sol_types as alloy_sol_types;
1453 #[doc(hidden)]
1454 type UnderlyingSolTuple<'a> = (
1455 alloy::sol_types::sol_data::Address,
1456 alloy::sol_types::sol_data::FixedBytes<32>,
1457 );
1458 #[doc(hidden)]
1459 type UnderlyingRustTuple<'a> = (
1460 alloy::sol_types::private::Address,
1461 alloy::sol_types::private::FixedBytes<32>,
1462 );
1463 #[cfg(test)]
1464 #[allow(dead_code, unreachable_patterns)]
1465 fn _type_assertion(
1466 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1467 ) {
1468 match _t {
1469 alloy_sol_types::private::AssertTypeEq::<
1470 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1471 >(_) => {}
1472 }
1473 }
1474 #[automatically_derived]
1475 #[doc(hidden)]
1476 impl ::core::convert::From<AccessControlUnauthorizedAccount>
1477 for UnderlyingRustTuple<'_> {
1478 fn from(value: AccessControlUnauthorizedAccount) -> Self {
1479 (value.account, value.neededRole)
1480 }
1481 }
1482 #[automatically_derived]
1483 #[doc(hidden)]
1484 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1485 for AccessControlUnauthorizedAccount {
1486 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1487 Self {
1488 account: tuple.0,
1489 neededRole: tuple.1,
1490 }
1491 }
1492 }
1493 #[automatically_derived]
1494 impl alloy_sol_types::SolError for AccessControlUnauthorizedAccount {
1495 type Parameters<'a> = UnderlyingSolTuple<'a>;
1496 type Token<'a> = <Self::Parameters<
1497 'a,
1498 > as alloy_sol_types::SolType>::Token<'a>;
1499 const SIGNATURE: &'static str = "AccessControlUnauthorizedAccount(address,bytes32)";
1500 const SELECTOR: [u8; 4] = [226u8, 81u8, 125u8, 63u8];
1501 #[inline]
1502 fn new<'a>(
1503 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1504 ) -> Self {
1505 tuple.into()
1506 }
1507 #[inline]
1508 fn tokenize(&self) -> Self::Token<'_> {
1509 (
1510 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1511 &self.account,
1512 ),
1513 <alloy::sol_types::sol_data::FixedBytes<
1514 32,
1515 > as alloy_sol_types::SolType>::tokenize(&self.neededRole),
1516 )
1517 }
1518 }
1519 };
1520 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1521 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1526 #[derive(Clone)]
1527 pub struct FailedInnerCall {}
1528 #[allow(
1529 non_camel_case_types,
1530 non_snake_case,
1531 clippy::pub_underscore_fields,
1532 clippy::style
1533 )]
1534 const _: () = {
1535 use alloy::sol_types as alloy_sol_types;
1536 #[doc(hidden)]
1537 type UnderlyingSolTuple<'a> = ();
1538 #[doc(hidden)]
1539 type UnderlyingRustTuple<'a> = ();
1540 #[cfg(test)]
1541 #[allow(dead_code, unreachable_patterns)]
1542 fn _type_assertion(
1543 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1544 ) {
1545 match _t {
1546 alloy_sol_types::private::AssertTypeEq::<
1547 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1548 >(_) => {}
1549 }
1550 }
1551 #[automatically_derived]
1552 #[doc(hidden)]
1553 impl ::core::convert::From<FailedInnerCall> for UnderlyingRustTuple<'_> {
1554 fn from(value: FailedInnerCall) -> Self {
1555 ()
1556 }
1557 }
1558 #[automatically_derived]
1559 #[doc(hidden)]
1560 impl ::core::convert::From<UnderlyingRustTuple<'_>> for FailedInnerCall {
1561 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1562 Self {}
1563 }
1564 }
1565 #[automatically_derived]
1566 impl alloy_sol_types::SolError for FailedInnerCall {
1567 type Parameters<'a> = UnderlyingSolTuple<'a>;
1568 type Token<'a> = <Self::Parameters<
1569 'a,
1570 > as alloy_sol_types::SolType>::Token<'a>;
1571 const SIGNATURE: &'static str = "FailedInnerCall()";
1572 const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8];
1573 #[inline]
1574 fn new<'a>(
1575 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1576 ) -> Self {
1577 tuple.into()
1578 }
1579 #[inline]
1580 fn tokenize(&self) -> Self::Token<'_> {
1581 ()
1582 }
1583 }
1584 };
1585 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1586 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1591 #[derive(Clone)]
1592 pub struct TimelockInsufficientDelay {
1593 #[allow(missing_docs)]
1594 pub delay: alloy::sol_types::private::primitives::aliases::U256,
1595 #[allow(missing_docs)]
1596 pub minDelay: alloy::sol_types::private::primitives::aliases::U256,
1597 }
1598 #[allow(
1599 non_camel_case_types,
1600 non_snake_case,
1601 clippy::pub_underscore_fields,
1602 clippy::style
1603 )]
1604 const _: () = {
1605 use alloy::sol_types as alloy_sol_types;
1606 #[doc(hidden)]
1607 type UnderlyingSolTuple<'a> = (
1608 alloy::sol_types::sol_data::Uint<256>,
1609 alloy::sol_types::sol_data::Uint<256>,
1610 );
1611 #[doc(hidden)]
1612 type UnderlyingRustTuple<'a> = (
1613 alloy::sol_types::private::primitives::aliases::U256,
1614 alloy::sol_types::private::primitives::aliases::U256,
1615 );
1616 #[cfg(test)]
1617 #[allow(dead_code, unreachable_patterns)]
1618 fn _type_assertion(
1619 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1620 ) {
1621 match _t {
1622 alloy_sol_types::private::AssertTypeEq::<
1623 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1624 >(_) => {}
1625 }
1626 }
1627 #[automatically_derived]
1628 #[doc(hidden)]
1629 impl ::core::convert::From<TimelockInsufficientDelay>
1630 for UnderlyingRustTuple<'_> {
1631 fn from(value: TimelockInsufficientDelay) -> Self {
1632 (value.delay, value.minDelay)
1633 }
1634 }
1635 #[automatically_derived]
1636 #[doc(hidden)]
1637 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1638 for TimelockInsufficientDelay {
1639 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1640 Self {
1641 delay: tuple.0,
1642 minDelay: tuple.1,
1643 }
1644 }
1645 }
1646 #[automatically_derived]
1647 impl alloy_sol_types::SolError for TimelockInsufficientDelay {
1648 type Parameters<'a> = UnderlyingSolTuple<'a>;
1649 type Token<'a> = <Self::Parameters<
1650 'a,
1651 > as alloy_sol_types::SolType>::Token<'a>;
1652 const SIGNATURE: &'static str = "TimelockInsufficientDelay(uint256,uint256)";
1653 const SELECTOR: [u8; 4] = [84u8, 51u8, 102u8, 9u8];
1654 #[inline]
1655 fn new<'a>(
1656 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1657 ) -> Self {
1658 tuple.into()
1659 }
1660 #[inline]
1661 fn tokenize(&self) -> Self::Token<'_> {
1662 (
1663 <alloy::sol_types::sol_data::Uint<
1664 256,
1665 > as alloy_sol_types::SolType>::tokenize(&self.delay),
1666 <alloy::sol_types::sol_data::Uint<
1667 256,
1668 > as alloy_sol_types::SolType>::tokenize(&self.minDelay),
1669 )
1670 }
1671 }
1672 };
1673 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1674 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1679 #[derive(Clone)]
1680 pub struct TimelockInvalidOperationLength {
1681 #[allow(missing_docs)]
1682 pub targets: alloy::sol_types::private::primitives::aliases::U256,
1683 #[allow(missing_docs)]
1684 pub payloads: alloy::sol_types::private::primitives::aliases::U256,
1685 #[allow(missing_docs)]
1686 pub values: alloy::sol_types::private::primitives::aliases::U256,
1687 }
1688 #[allow(
1689 non_camel_case_types,
1690 non_snake_case,
1691 clippy::pub_underscore_fields,
1692 clippy::style
1693 )]
1694 const _: () = {
1695 use alloy::sol_types as alloy_sol_types;
1696 #[doc(hidden)]
1697 type UnderlyingSolTuple<'a> = (
1698 alloy::sol_types::sol_data::Uint<256>,
1699 alloy::sol_types::sol_data::Uint<256>,
1700 alloy::sol_types::sol_data::Uint<256>,
1701 );
1702 #[doc(hidden)]
1703 type UnderlyingRustTuple<'a> = (
1704 alloy::sol_types::private::primitives::aliases::U256,
1705 alloy::sol_types::private::primitives::aliases::U256,
1706 alloy::sol_types::private::primitives::aliases::U256,
1707 );
1708 #[cfg(test)]
1709 #[allow(dead_code, unreachable_patterns)]
1710 fn _type_assertion(
1711 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1712 ) {
1713 match _t {
1714 alloy_sol_types::private::AssertTypeEq::<
1715 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1716 >(_) => {}
1717 }
1718 }
1719 #[automatically_derived]
1720 #[doc(hidden)]
1721 impl ::core::convert::From<TimelockInvalidOperationLength>
1722 for UnderlyingRustTuple<'_> {
1723 fn from(value: TimelockInvalidOperationLength) -> Self {
1724 (value.targets, value.payloads, value.values)
1725 }
1726 }
1727 #[automatically_derived]
1728 #[doc(hidden)]
1729 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1730 for TimelockInvalidOperationLength {
1731 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1732 Self {
1733 targets: tuple.0,
1734 payloads: tuple.1,
1735 values: tuple.2,
1736 }
1737 }
1738 }
1739 #[automatically_derived]
1740 impl alloy_sol_types::SolError for TimelockInvalidOperationLength {
1741 type Parameters<'a> = UnderlyingSolTuple<'a>;
1742 type Token<'a> = <Self::Parameters<
1743 'a,
1744 > as alloy_sol_types::SolType>::Token<'a>;
1745 const SIGNATURE: &'static str = "TimelockInvalidOperationLength(uint256,uint256,uint256)";
1746 const SELECTOR: [u8; 4] = [255u8, 176u8, 50u8, 17u8];
1747 #[inline]
1748 fn new<'a>(
1749 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1750 ) -> Self {
1751 tuple.into()
1752 }
1753 #[inline]
1754 fn tokenize(&self) -> Self::Token<'_> {
1755 (
1756 <alloy::sol_types::sol_data::Uint<
1757 256,
1758 > as alloy_sol_types::SolType>::tokenize(&self.targets),
1759 <alloy::sol_types::sol_data::Uint<
1760 256,
1761 > as alloy_sol_types::SolType>::tokenize(&self.payloads),
1762 <alloy::sol_types::sol_data::Uint<
1763 256,
1764 > as alloy_sol_types::SolType>::tokenize(&self.values),
1765 )
1766 }
1767 }
1768 };
1769 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1770 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1775 #[derive(Clone)]
1776 pub struct TimelockUnauthorizedCaller {
1777 #[allow(missing_docs)]
1778 pub caller: alloy::sol_types::private::Address,
1779 }
1780 #[allow(
1781 non_camel_case_types,
1782 non_snake_case,
1783 clippy::pub_underscore_fields,
1784 clippy::style
1785 )]
1786 const _: () = {
1787 use alloy::sol_types as alloy_sol_types;
1788 #[doc(hidden)]
1789 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1790 #[doc(hidden)]
1791 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1792 #[cfg(test)]
1793 #[allow(dead_code, unreachable_patterns)]
1794 fn _type_assertion(
1795 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1796 ) {
1797 match _t {
1798 alloy_sol_types::private::AssertTypeEq::<
1799 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1800 >(_) => {}
1801 }
1802 }
1803 #[automatically_derived]
1804 #[doc(hidden)]
1805 impl ::core::convert::From<TimelockUnauthorizedCaller>
1806 for UnderlyingRustTuple<'_> {
1807 fn from(value: TimelockUnauthorizedCaller) -> Self {
1808 (value.caller,)
1809 }
1810 }
1811 #[automatically_derived]
1812 #[doc(hidden)]
1813 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1814 for TimelockUnauthorizedCaller {
1815 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1816 Self { caller: tuple.0 }
1817 }
1818 }
1819 #[automatically_derived]
1820 impl alloy_sol_types::SolError for TimelockUnauthorizedCaller {
1821 type Parameters<'a> = UnderlyingSolTuple<'a>;
1822 type Token<'a> = <Self::Parameters<
1823 'a,
1824 > as alloy_sol_types::SolType>::Token<'a>;
1825 const SIGNATURE: &'static str = "TimelockUnauthorizedCaller(address)";
1826 const SELECTOR: [u8; 4] = [226u8, 133u8, 12u8, 89u8];
1827 #[inline]
1828 fn new<'a>(
1829 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1830 ) -> Self {
1831 tuple.into()
1832 }
1833 #[inline]
1834 fn tokenize(&self) -> Self::Token<'_> {
1835 (
1836 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1837 &self.caller,
1838 ),
1839 )
1840 }
1841 }
1842 };
1843 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1844 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1849 #[derive(Clone)]
1850 pub struct TimelockUnexecutedPredecessor {
1851 #[allow(missing_docs)]
1852 pub predecessorId: alloy::sol_types::private::FixedBytes<32>,
1853 }
1854 #[allow(
1855 non_camel_case_types,
1856 non_snake_case,
1857 clippy::pub_underscore_fields,
1858 clippy::style
1859 )]
1860 const _: () = {
1861 use alloy::sol_types as alloy_sol_types;
1862 #[doc(hidden)]
1863 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1864 #[doc(hidden)]
1865 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1866 #[cfg(test)]
1867 #[allow(dead_code, unreachable_patterns)]
1868 fn _type_assertion(
1869 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1870 ) {
1871 match _t {
1872 alloy_sol_types::private::AssertTypeEq::<
1873 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1874 >(_) => {}
1875 }
1876 }
1877 #[automatically_derived]
1878 #[doc(hidden)]
1879 impl ::core::convert::From<TimelockUnexecutedPredecessor>
1880 for UnderlyingRustTuple<'_> {
1881 fn from(value: TimelockUnexecutedPredecessor) -> Self {
1882 (value.predecessorId,)
1883 }
1884 }
1885 #[automatically_derived]
1886 #[doc(hidden)]
1887 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1888 for TimelockUnexecutedPredecessor {
1889 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1890 Self { predecessorId: tuple.0 }
1891 }
1892 }
1893 #[automatically_derived]
1894 impl alloy_sol_types::SolError for TimelockUnexecutedPredecessor {
1895 type Parameters<'a> = UnderlyingSolTuple<'a>;
1896 type Token<'a> = <Self::Parameters<
1897 'a,
1898 > as alloy_sol_types::SolType>::Token<'a>;
1899 const SIGNATURE: &'static str = "TimelockUnexecutedPredecessor(bytes32)";
1900 const SELECTOR: [u8; 4] = [144u8, 169u8, 166u8, 24u8];
1901 #[inline]
1902 fn new<'a>(
1903 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1904 ) -> Self {
1905 tuple.into()
1906 }
1907 #[inline]
1908 fn tokenize(&self) -> Self::Token<'_> {
1909 (
1910 <alloy::sol_types::sol_data::FixedBytes<
1911 32,
1912 > as alloy_sol_types::SolType>::tokenize(&self.predecessorId),
1913 )
1914 }
1915 }
1916 };
1917 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1918 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1923 #[derive(Clone)]
1924 pub struct TimelockUnexpectedOperationState {
1925 #[allow(missing_docs)]
1926 pub operationId: alloy::sol_types::private::FixedBytes<32>,
1927 #[allow(missing_docs)]
1928 pub expectedStates: alloy::sol_types::private::FixedBytes<32>,
1929 }
1930 #[allow(
1931 non_camel_case_types,
1932 non_snake_case,
1933 clippy::pub_underscore_fields,
1934 clippy::style
1935 )]
1936 const _: () = {
1937 use alloy::sol_types as alloy_sol_types;
1938 #[doc(hidden)]
1939 type UnderlyingSolTuple<'a> = (
1940 alloy::sol_types::sol_data::FixedBytes<32>,
1941 alloy::sol_types::sol_data::FixedBytes<32>,
1942 );
1943 #[doc(hidden)]
1944 type UnderlyingRustTuple<'a> = (
1945 alloy::sol_types::private::FixedBytes<32>,
1946 alloy::sol_types::private::FixedBytes<32>,
1947 );
1948 #[cfg(test)]
1949 #[allow(dead_code, unreachable_patterns)]
1950 fn _type_assertion(
1951 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1952 ) {
1953 match _t {
1954 alloy_sol_types::private::AssertTypeEq::<
1955 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1956 >(_) => {}
1957 }
1958 }
1959 #[automatically_derived]
1960 #[doc(hidden)]
1961 impl ::core::convert::From<TimelockUnexpectedOperationState>
1962 for UnderlyingRustTuple<'_> {
1963 fn from(value: TimelockUnexpectedOperationState) -> Self {
1964 (value.operationId, value.expectedStates)
1965 }
1966 }
1967 #[automatically_derived]
1968 #[doc(hidden)]
1969 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1970 for TimelockUnexpectedOperationState {
1971 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1972 Self {
1973 operationId: tuple.0,
1974 expectedStates: tuple.1,
1975 }
1976 }
1977 }
1978 #[automatically_derived]
1979 impl alloy_sol_types::SolError for TimelockUnexpectedOperationState {
1980 type Parameters<'a> = UnderlyingSolTuple<'a>;
1981 type Token<'a> = <Self::Parameters<
1982 'a,
1983 > as alloy_sol_types::SolType>::Token<'a>;
1984 const SIGNATURE: &'static str = "TimelockUnexpectedOperationState(bytes32,bytes32)";
1985 const SELECTOR: [u8; 4] = [94u8, 173u8, 142u8, 181u8];
1986 #[inline]
1987 fn new<'a>(
1988 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1989 ) -> Self {
1990 tuple.into()
1991 }
1992 #[inline]
1993 fn tokenize(&self) -> Self::Token<'_> {
1994 (
1995 <alloy::sol_types::sol_data::FixedBytes<
1996 32,
1997 > as alloy_sol_types::SolType>::tokenize(&self.operationId),
1998 <alloy::sol_types::sol_data::FixedBytes<
1999 32,
2000 > as alloy_sol_types::SolType>::tokenize(&self.expectedStates),
2001 )
2002 }
2003 }
2004 };
2005 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2006 #[allow(
2011 non_camel_case_types,
2012 non_snake_case,
2013 clippy::pub_underscore_fields,
2014 clippy::style
2015 )]
2016 #[derive(Clone)]
2017 pub struct CallExecuted {
2018 #[allow(missing_docs)]
2019 pub id: alloy::sol_types::private::FixedBytes<32>,
2020 #[allow(missing_docs)]
2021 pub index: alloy::sol_types::private::primitives::aliases::U256,
2022 #[allow(missing_docs)]
2023 pub target: alloy::sol_types::private::Address,
2024 #[allow(missing_docs)]
2025 pub value: alloy::sol_types::private::primitives::aliases::U256,
2026 #[allow(missing_docs)]
2027 pub data: alloy::sol_types::private::Bytes,
2028 }
2029 #[allow(
2030 non_camel_case_types,
2031 non_snake_case,
2032 clippy::pub_underscore_fields,
2033 clippy::style
2034 )]
2035 const _: () = {
2036 use alloy::sol_types as alloy_sol_types;
2037 #[automatically_derived]
2038 impl alloy_sol_types::SolEvent for CallExecuted {
2039 type DataTuple<'a> = (
2040 alloy::sol_types::sol_data::Address,
2041 alloy::sol_types::sol_data::Uint<256>,
2042 alloy::sol_types::sol_data::Bytes,
2043 );
2044 type DataToken<'a> = <Self::DataTuple<
2045 'a,
2046 > as alloy_sol_types::SolType>::Token<'a>;
2047 type TopicList = (
2048 alloy_sol_types::sol_data::FixedBytes<32>,
2049 alloy::sol_types::sol_data::FixedBytes<32>,
2050 alloy::sol_types::sol_data::Uint<256>,
2051 );
2052 const SIGNATURE: &'static str = "CallExecuted(bytes32,uint256,address,uint256,bytes)";
2053 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2054 194u8, 97u8, 126u8, 250u8, 105u8, 186u8, 182u8, 103u8, 130u8, 250u8,
2055 33u8, 149u8, 67u8, 113u8, 67u8, 56u8, 72u8, 156u8, 78u8, 158u8, 23u8,
2056 130u8, 113u8, 86u8, 10u8, 145u8, 184u8, 44u8, 63u8, 97u8, 43u8, 88u8,
2057 ]);
2058 const ANONYMOUS: bool = false;
2059 #[allow(unused_variables)]
2060 #[inline]
2061 fn new(
2062 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2063 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2064 ) -> Self {
2065 Self {
2066 id: topics.1,
2067 index: topics.2,
2068 target: data.0,
2069 value: data.1,
2070 data: data.2,
2071 }
2072 }
2073 #[inline]
2074 fn check_signature(
2075 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2076 ) -> alloy_sol_types::Result<()> {
2077 if topics.0 != Self::SIGNATURE_HASH {
2078 return Err(
2079 alloy_sol_types::Error::invalid_event_signature_hash(
2080 Self::SIGNATURE,
2081 topics.0,
2082 Self::SIGNATURE_HASH,
2083 ),
2084 );
2085 }
2086 Ok(())
2087 }
2088 #[inline]
2089 fn tokenize_body(&self) -> Self::DataToken<'_> {
2090 (
2091 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2092 &self.target,
2093 ),
2094 <alloy::sol_types::sol_data::Uint<
2095 256,
2096 > as alloy_sol_types::SolType>::tokenize(&self.value),
2097 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
2098 &self.data,
2099 ),
2100 )
2101 }
2102 #[inline]
2103 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2104 (Self::SIGNATURE_HASH.into(), self.id.clone(), self.index.clone())
2105 }
2106 #[inline]
2107 fn encode_topics_raw(
2108 &self,
2109 out: &mut [alloy_sol_types::abi::token::WordToken],
2110 ) -> alloy_sol_types::Result<()> {
2111 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2112 return Err(alloy_sol_types::Error::Overrun);
2113 }
2114 out[0usize] = alloy_sol_types::abi::token::WordToken(
2115 Self::SIGNATURE_HASH,
2116 );
2117 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2118 32,
2119 > as alloy_sol_types::EventTopic>::encode_topic(&self.id);
2120 out[2usize] = <alloy::sol_types::sol_data::Uint<
2121 256,
2122 > as alloy_sol_types::EventTopic>::encode_topic(&self.index);
2123 Ok(())
2124 }
2125 }
2126 #[automatically_derived]
2127 impl alloy_sol_types::private::IntoLogData for CallExecuted {
2128 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2129 From::from(self)
2130 }
2131 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2132 From::from(&self)
2133 }
2134 }
2135 #[automatically_derived]
2136 impl From<&CallExecuted> for alloy_sol_types::private::LogData {
2137 #[inline]
2138 fn from(this: &CallExecuted) -> alloy_sol_types::private::LogData {
2139 alloy_sol_types::SolEvent::encode_log_data(this)
2140 }
2141 }
2142 };
2143 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2144 #[allow(
2149 non_camel_case_types,
2150 non_snake_case,
2151 clippy::pub_underscore_fields,
2152 clippy::style
2153 )]
2154 #[derive(Clone)]
2155 pub struct CallSalt {
2156 #[allow(missing_docs)]
2157 pub id: alloy::sol_types::private::FixedBytes<32>,
2158 #[allow(missing_docs)]
2159 pub salt: alloy::sol_types::private::FixedBytes<32>,
2160 }
2161 #[allow(
2162 non_camel_case_types,
2163 non_snake_case,
2164 clippy::pub_underscore_fields,
2165 clippy::style
2166 )]
2167 const _: () = {
2168 use alloy::sol_types as alloy_sol_types;
2169 #[automatically_derived]
2170 impl alloy_sol_types::SolEvent for CallSalt {
2171 type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2172 type DataToken<'a> = <Self::DataTuple<
2173 'a,
2174 > as alloy_sol_types::SolType>::Token<'a>;
2175 type TopicList = (
2176 alloy_sol_types::sol_data::FixedBytes<32>,
2177 alloy::sol_types::sol_data::FixedBytes<32>,
2178 );
2179 const SIGNATURE: &'static str = "CallSalt(bytes32,bytes32)";
2180 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2181 32u8, 253u8, 165u8, 253u8, 39u8, 161u8, 234u8, 123u8, 245u8, 185u8, 86u8,
2182 127u8, 20u8, 58u8, 197u8, 71u8, 11u8, 176u8, 89u8, 55u8, 74u8, 39u8,
2183 232u8, 246u8, 124u8, 180u8, 79u8, 148u8, 111u8, 109u8, 3u8, 135u8,
2184 ]);
2185 const ANONYMOUS: bool = false;
2186 #[allow(unused_variables)]
2187 #[inline]
2188 fn new(
2189 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2190 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2191 ) -> Self {
2192 Self { id: topics.1, salt: data.0 }
2193 }
2194 #[inline]
2195 fn check_signature(
2196 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2197 ) -> alloy_sol_types::Result<()> {
2198 if topics.0 != Self::SIGNATURE_HASH {
2199 return Err(
2200 alloy_sol_types::Error::invalid_event_signature_hash(
2201 Self::SIGNATURE,
2202 topics.0,
2203 Self::SIGNATURE_HASH,
2204 ),
2205 );
2206 }
2207 Ok(())
2208 }
2209 #[inline]
2210 fn tokenize_body(&self) -> Self::DataToken<'_> {
2211 (
2212 <alloy::sol_types::sol_data::FixedBytes<
2213 32,
2214 > as alloy_sol_types::SolType>::tokenize(&self.salt),
2215 )
2216 }
2217 #[inline]
2218 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2219 (Self::SIGNATURE_HASH.into(), self.id.clone())
2220 }
2221 #[inline]
2222 fn encode_topics_raw(
2223 &self,
2224 out: &mut [alloy_sol_types::abi::token::WordToken],
2225 ) -> alloy_sol_types::Result<()> {
2226 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2227 return Err(alloy_sol_types::Error::Overrun);
2228 }
2229 out[0usize] = alloy_sol_types::abi::token::WordToken(
2230 Self::SIGNATURE_HASH,
2231 );
2232 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2233 32,
2234 > as alloy_sol_types::EventTopic>::encode_topic(&self.id);
2235 Ok(())
2236 }
2237 }
2238 #[automatically_derived]
2239 impl alloy_sol_types::private::IntoLogData for CallSalt {
2240 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2241 From::from(self)
2242 }
2243 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2244 From::from(&self)
2245 }
2246 }
2247 #[automatically_derived]
2248 impl From<&CallSalt> for alloy_sol_types::private::LogData {
2249 #[inline]
2250 fn from(this: &CallSalt) -> alloy_sol_types::private::LogData {
2251 alloy_sol_types::SolEvent::encode_log_data(this)
2252 }
2253 }
2254 };
2255 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2256 #[allow(
2261 non_camel_case_types,
2262 non_snake_case,
2263 clippy::pub_underscore_fields,
2264 clippy::style
2265 )]
2266 #[derive(Clone)]
2267 pub struct CallScheduled {
2268 #[allow(missing_docs)]
2269 pub id: alloy::sol_types::private::FixedBytes<32>,
2270 #[allow(missing_docs)]
2271 pub index: alloy::sol_types::private::primitives::aliases::U256,
2272 #[allow(missing_docs)]
2273 pub target: alloy::sol_types::private::Address,
2274 #[allow(missing_docs)]
2275 pub value: alloy::sol_types::private::primitives::aliases::U256,
2276 #[allow(missing_docs)]
2277 pub data: alloy::sol_types::private::Bytes,
2278 #[allow(missing_docs)]
2279 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
2280 #[allow(missing_docs)]
2281 pub delay: alloy::sol_types::private::primitives::aliases::U256,
2282 }
2283 #[allow(
2284 non_camel_case_types,
2285 non_snake_case,
2286 clippy::pub_underscore_fields,
2287 clippy::style
2288 )]
2289 const _: () = {
2290 use alloy::sol_types as alloy_sol_types;
2291 #[automatically_derived]
2292 impl alloy_sol_types::SolEvent for CallScheduled {
2293 type DataTuple<'a> = (
2294 alloy::sol_types::sol_data::Address,
2295 alloy::sol_types::sol_data::Uint<256>,
2296 alloy::sol_types::sol_data::Bytes,
2297 alloy::sol_types::sol_data::FixedBytes<32>,
2298 alloy::sol_types::sol_data::Uint<256>,
2299 );
2300 type DataToken<'a> = <Self::DataTuple<
2301 'a,
2302 > as alloy_sol_types::SolType>::Token<'a>;
2303 type TopicList = (
2304 alloy_sol_types::sol_data::FixedBytes<32>,
2305 alloy::sol_types::sol_data::FixedBytes<32>,
2306 alloy::sol_types::sol_data::Uint<256>,
2307 );
2308 const SIGNATURE: &'static str = "CallScheduled(bytes32,uint256,address,uint256,bytes,bytes32,uint256)";
2309 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2310 76u8, 244u8, 65u8, 12u8, 197u8, 112u8, 64u8, 228u8, 72u8, 98u8, 239u8,
2311 15u8, 69u8, 243u8, 221u8, 90u8, 94u8, 2u8, 219u8, 142u8, 184u8, 173u8,
2312 214u8, 72u8, 212u8, 176u8, 226u8, 54u8, 241u8, 208u8, 125u8, 202u8,
2313 ]);
2314 const ANONYMOUS: bool = false;
2315 #[allow(unused_variables)]
2316 #[inline]
2317 fn new(
2318 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2319 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2320 ) -> Self {
2321 Self {
2322 id: topics.1,
2323 index: topics.2,
2324 target: data.0,
2325 value: data.1,
2326 data: data.2,
2327 predecessor: data.3,
2328 delay: data.4,
2329 }
2330 }
2331 #[inline]
2332 fn check_signature(
2333 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2334 ) -> alloy_sol_types::Result<()> {
2335 if topics.0 != Self::SIGNATURE_HASH {
2336 return Err(
2337 alloy_sol_types::Error::invalid_event_signature_hash(
2338 Self::SIGNATURE,
2339 topics.0,
2340 Self::SIGNATURE_HASH,
2341 ),
2342 );
2343 }
2344 Ok(())
2345 }
2346 #[inline]
2347 fn tokenize_body(&self) -> Self::DataToken<'_> {
2348 (
2349 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2350 &self.target,
2351 ),
2352 <alloy::sol_types::sol_data::Uint<
2353 256,
2354 > as alloy_sol_types::SolType>::tokenize(&self.value),
2355 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
2356 &self.data,
2357 ),
2358 <alloy::sol_types::sol_data::FixedBytes<
2359 32,
2360 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
2361 <alloy::sol_types::sol_data::Uint<
2362 256,
2363 > as alloy_sol_types::SolType>::tokenize(&self.delay),
2364 )
2365 }
2366 #[inline]
2367 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2368 (Self::SIGNATURE_HASH.into(), self.id.clone(), self.index.clone())
2369 }
2370 #[inline]
2371 fn encode_topics_raw(
2372 &self,
2373 out: &mut [alloy_sol_types::abi::token::WordToken],
2374 ) -> alloy_sol_types::Result<()> {
2375 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2376 return Err(alloy_sol_types::Error::Overrun);
2377 }
2378 out[0usize] = alloy_sol_types::abi::token::WordToken(
2379 Self::SIGNATURE_HASH,
2380 );
2381 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2382 32,
2383 > as alloy_sol_types::EventTopic>::encode_topic(&self.id);
2384 out[2usize] = <alloy::sol_types::sol_data::Uint<
2385 256,
2386 > as alloy_sol_types::EventTopic>::encode_topic(&self.index);
2387 Ok(())
2388 }
2389 }
2390 #[automatically_derived]
2391 impl alloy_sol_types::private::IntoLogData for CallScheduled {
2392 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2393 From::from(self)
2394 }
2395 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2396 From::from(&self)
2397 }
2398 }
2399 #[automatically_derived]
2400 impl From<&CallScheduled> for alloy_sol_types::private::LogData {
2401 #[inline]
2402 fn from(this: &CallScheduled) -> alloy_sol_types::private::LogData {
2403 alloy_sol_types::SolEvent::encode_log_data(this)
2404 }
2405 }
2406 };
2407 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2408 #[allow(
2413 non_camel_case_types,
2414 non_snake_case,
2415 clippy::pub_underscore_fields,
2416 clippy::style
2417 )]
2418 #[derive(Clone)]
2419 pub struct Cancelled {
2420 #[allow(missing_docs)]
2421 pub id: alloy::sol_types::private::FixedBytes<32>,
2422 }
2423 #[allow(
2424 non_camel_case_types,
2425 non_snake_case,
2426 clippy::pub_underscore_fields,
2427 clippy::style
2428 )]
2429 const _: () = {
2430 use alloy::sol_types as alloy_sol_types;
2431 #[automatically_derived]
2432 impl alloy_sol_types::SolEvent for Cancelled {
2433 type DataTuple<'a> = ();
2434 type DataToken<'a> = <Self::DataTuple<
2435 'a,
2436 > as alloy_sol_types::SolType>::Token<'a>;
2437 type TopicList = (
2438 alloy_sol_types::sol_data::FixedBytes<32>,
2439 alloy::sol_types::sol_data::FixedBytes<32>,
2440 );
2441 const SIGNATURE: &'static str = "Cancelled(bytes32)";
2442 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2443 186u8, 161u8, 235u8, 34u8, 242u8, 164u8, 146u8, 186u8, 26u8, 95u8, 234u8,
2444 97u8, 184u8, 223u8, 77u8, 39u8, 198u8, 200u8, 181u8, 243u8, 151u8, 30u8,
2445 99u8, 187u8, 88u8, 250u8, 20u8, 255u8, 114u8, 238u8, 219u8, 112u8,
2446 ]);
2447 const ANONYMOUS: bool = false;
2448 #[allow(unused_variables)]
2449 #[inline]
2450 fn new(
2451 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2452 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2453 ) -> Self {
2454 Self { id: topics.1 }
2455 }
2456 #[inline]
2457 fn check_signature(
2458 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2459 ) -> alloy_sol_types::Result<()> {
2460 if topics.0 != Self::SIGNATURE_HASH {
2461 return Err(
2462 alloy_sol_types::Error::invalid_event_signature_hash(
2463 Self::SIGNATURE,
2464 topics.0,
2465 Self::SIGNATURE_HASH,
2466 ),
2467 );
2468 }
2469 Ok(())
2470 }
2471 #[inline]
2472 fn tokenize_body(&self) -> Self::DataToken<'_> {
2473 ()
2474 }
2475 #[inline]
2476 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2477 (Self::SIGNATURE_HASH.into(), self.id.clone())
2478 }
2479 #[inline]
2480 fn encode_topics_raw(
2481 &self,
2482 out: &mut [alloy_sol_types::abi::token::WordToken],
2483 ) -> alloy_sol_types::Result<()> {
2484 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2485 return Err(alloy_sol_types::Error::Overrun);
2486 }
2487 out[0usize] = alloy_sol_types::abi::token::WordToken(
2488 Self::SIGNATURE_HASH,
2489 );
2490 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2491 32,
2492 > as alloy_sol_types::EventTopic>::encode_topic(&self.id);
2493 Ok(())
2494 }
2495 }
2496 #[automatically_derived]
2497 impl alloy_sol_types::private::IntoLogData for Cancelled {
2498 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2499 From::from(self)
2500 }
2501 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2502 From::from(&self)
2503 }
2504 }
2505 #[automatically_derived]
2506 impl From<&Cancelled> for alloy_sol_types::private::LogData {
2507 #[inline]
2508 fn from(this: &Cancelled) -> alloy_sol_types::private::LogData {
2509 alloy_sol_types::SolEvent::encode_log_data(this)
2510 }
2511 }
2512 };
2513 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2514 #[allow(
2519 non_camel_case_types,
2520 non_snake_case,
2521 clippy::pub_underscore_fields,
2522 clippy::style
2523 )]
2524 #[derive(Clone)]
2525 pub struct MinDelayChange {
2526 #[allow(missing_docs)]
2527 pub oldDuration: alloy::sol_types::private::primitives::aliases::U256,
2528 #[allow(missing_docs)]
2529 pub newDuration: alloy::sol_types::private::primitives::aliases::U256,
2530 }
2531 #[allow(
2532 non_camel_case_types,
2533 non_snake_case,
2534 clippy::pub_underscore_fields,
2535 clippy::style
2536 )]
2537 const _: () = {
2538 use alloy::sol_types as alloy_sol_types;
2539 #[automatically_derived]
2540 impl alloy_sol_types::SolEvent for MinDelayChange {
2541 type DataTuple<'a> = (
2542 alloy::sol_types::sol_data::Uint<256>,
2543 alloy::sol_types::sol_data::Uint<256>,
2544 );
2545 type DataToken<'a> = <Self::DataTuple<
2546 'a,
2547 > as alloy_sol_types::SolType>::Token<'a>;
2548 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
2549 const SIGNATURE: &'static str = "MinDelayChange(uint256,uint256)";
2550 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2551 17u8, 194u8, 79u8, 78u8, 173u8, 22u8, 80u8, 124u8, 105u8, 172u8, 70u8,
2552 127u8, 189u8, 94u8, 78u8, 237u8, 95u8, 181u8, 198u8, 153u8, 98u8, 109u8,
2553 44u8, 198u8, 214u8, 100u8, 33u8, 223u8, 37u8, 56u8, 134u8, 213u8,
2554 ]);
2555 const ANONYMOUS: bool = false;
2556 #[allow(unused_variables)]
2557 #[inline]
2558 fn new(
2559 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2560 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2561 ) -> Self {
2562 Self {
2563 oldDuration: data.0,
2564 newDuration: data.1,
2565 }
2566 }
2567 #[inline]
2568 fn check_signature(
2569 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2570 ) -> alloy_sol_types::Result<()> {
2571 if topics.0 != Self::SIGNATURE_HASH {
2572 return Err(
2573 alloy_sol_types::Error::invalid_event_signature_hash(
2574 Self::SIGNATURE,
2575 topics.0,
2576 Self::SIGNATURE_HASH,
2577 ),
2578 );
2579 }
2580 Ok(())
2581 }
2582 #[inline]
2583 fn tokenize_body(&self) -> Self::DataToken<'_> {
2584 (
2585 <alloy::sol_types::sol_data::Uint<
2586 256,
2587 > as alloy_sol_types::SolType>::tokenize(&self.oldDuration),
2588 <alloy::sol_types::sol_data::Uint<
2589 256,
2590 > as alloy_sol_types::SolType>::tokenize(&self.newDuration),
2591 )
2592 }
2593 #[inline]
2594 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2595 (Self::SIGNATURE_HASH.into(),)
2596 }
2597 #[inline]
2598 fn encode_topics_raw(
2599 &self,
2600 out: &mut [alloy_sol_types::abi::token::WordToken],
2601 ) -> alloy_sol_types::Result<()> {
2602 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2603 return Err(alloy_sol_types::Error::Overrun);
2604 }
2605 out[0usize] = alloy_sol_types::abi::token::WordToken(
2606 Self::SIGNATURE_HASH,
2607 );
2608 Ok(())
2609 }
2610 }
2611 #[automatically_derived]
2612 impl alloy_sol_types::private::IntoLogData for MinDelayChange {
2613 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2614 From::from(self)
2615 }
2616 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2617 From::from(&self)
2618 }
2619 }
2620 #[automatically_derived]
2621 impl From<&MinDelayChange> for alloy_sol_types::private::LogData {
2622 #[inline]
2623 fn from(this: &MinDelayChange) -> alloy_sol_types::private::LogData {
2624 alloy_sol_types::SolEvent::encode_log_data(this)
2625 }
2626 }
2627 };
2628 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2629 #[allow(
2634 non_camel_case_types,
2635 non_snake_case,
2636 clippy::pub_underscore_fields,
2637 clippy::style
2638 )]
2639 #[derive(Clone)]
2640 pub struct RoleAdminChanged {
2641 #[allow(missing_docs)]
2642 pub role: alloy::sol_types::private::FixedBytes<32>,
2643 #[allow(missing_docs)]
2644 pub previousAdminRole: alloy::sol_types::private::FixedBytes<32>,
2645 #[allow(missing_docs)]
2646 pub newAdminRole: alloy::sol_types::private::FixedBytes<32>,
2647 }
2648 #[allow(
2649 non_camel_case_types,
2650 non_snake_case,
2651 clippy::pub_underscore_fields,
2652 clippy::style
2653 )]
2654 const _: () = {
2655 use alloy::sol_types as alloy_sol_types;
2656 #[automatically_derived]
2657 impl alloy_sol_types::SolEvent for RoleAdminChanged {
2658 type DataTuple<'a> = ();
2659 type DataToken<'a> = <Self::DataTuple<
2660 'a,
2661 > as alloy_sol_types::SolType>::Token<'a>;
2662 type TopicList = (
2663 alloy_sol_types::sol_data::FixedBytes<32>,
2664 alloy::sol_types::sol_data::FixedBytes<32>,
2665 alloy::sol_types::sol_data::FixedBytes<32>,
2666 alloy::sol_types::sol_data::FixedBytes<32>,
2667 );
2668 const SIGNATURE: &'static str = "RoleAdminChanged(bytes32,bytes32,bytes32)";
2669 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2670 189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8,
2671 81u8, 66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8,
2672 71u8, 92u8, 58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
2673 ]);
2674 const ANONYMOUS: bool = false;
2675 #[allow(unused_variables)]
2676 #[inline]
2677 fn new(
2678 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2679 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2680 ) -> Self {
2681 Self {
2682 role: topics.1,
2683 previousAdminRole: topics.2,
2684 newAdminRole: topics.3,
2685 }
2686 }
2687 #[inline]
2688 fn check_signature(
2689 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2690 ) -> alloy_sol_types::Result<()> {
2691 if topics.0 != Self::SIGNATURE_HASH {
2692 return Err(
2693 alloy_sol_types::Error::invalid_event_signature_hash(
2694 Self::SIGNATURE,
2695 topics.0,
2696 Self::SIGNATURE_HASH,
2697 ),
2698 );
2699 }
2700 Ok(())
2701 }
2702 #[inline]
2703 fn tokenize_body(&self) -> Self::DataToken<'_> {
2704 ()
2705 }
2706 #[inline]
2707 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2708 (
2709 Self::SIGNATURE_HASH.into(),
2710 self.role.clone(),
2711 self.previousAdminRole.clone(),
2712 self.newAdminRole.clone(),
2713 )
2714 }
2715 #[inline]
2716 fn encode_topics_raw(
2717 &self,
2718 out: &mut [alloy_sol_types::abi::token::WordToken],
2719 ) -> alloy_sol_types::Result<()> {
2720 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2721 return Err(alloy_sol_types::Error::Overrun);
2722 }
2723 out[0usize] = alloy_sol_types::abi::token::WordToken(
2724 Self::SIGNATURE_HASH,
2725 );
2726 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2727 32,
2728 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
2729 out[2usize] = <alloy::sol_types::sol_data::FixedBytes<
2730 32,
2731 > as alloy_sol_types::EventTopic>::encode_topic(&self.previousAdminRole);
2732 out[3usize] = <alloy::sol_types::sol_data::FixedBytes<
2733 32,
2734 > as alloy_sol_types::EventTopic>::encode_topic(&self.newAdminRole);
2735 Ok(())
2736 }
2737 }
2738 #[automatically_derived]
2739 impl alloy_sol_types::private::IntoLogData for RoleAdminChanged {
2740 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2741 From::from(self)
2742 }
2743 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2744 From::from(&self)
2745 }
2746 }
2747 #[automatically_derived]
2748 impl From<&RoleAdminChanged> for alloy_sol_types::private::LogData {
2749 #[inline]
2750 fn from(this: &RoleAdminChanged) -> alloy_sol_types::private::LogData {
2751 alloy_sol_types::SolEvent::encode_log_data(this)
2752 }
2753 }
2754 };
2755 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2756 #[allow(
2761 non_camel_case_types,
2762 non_snake_case,
2763 clippy::pub_underscore_fields,
2764 clippy::style
2765 )]
2766 #[derive(Clone)]
2767 pub struct RoleGranted {
2768 #[allow(missing_docs)]
2769 pub role: alloy::sol_types::private::FixedBytes<32>,
2770 #[allow(missing_docs)]
2771 pub account: alloy::sol_types::private::Address,
2772 #[allow(missing_docs)]
2773 pub sender: alloy::sol_types::private::Address,
2774 }
2775 #[allow(
2776 non_camel_case_types,
2777 non_snake_case,
2778 clippy::pub_underscore_fields,
2779 clippy::style
2780 )]
2781 const _: () = {
2782 use alloy::sol_types as alloy_sol_types;
2783 #[automatically_derived]
2784 impl alloy_sol_types::SolEvent for RoleGranted {
2785 type DataTuple<'a> = ();
2786 type DataToken<'a> = <Self::DataTuple<
2787 'a,
2788 > as alloy_sol_types::SolType>::Token<'a>;
2789 type TopicList = (
2790 alloy_sol_types::sol_data::FixedBytes<32>,
2791 alloy::sol_types::sol_data::FixedBytes<32>,
2792 alloy::sol_types::sol_data::Address,
2793 alloy::sol_types::sol_data::Address,
2794 );
2795 const SIGNATURE: &'static str = "RoleGranted(bytes32,address,address)";
2796 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2797 47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8,
2798 236u8, 121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8,
2799 64u8, 48u8, 69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
2800 ]);
2801 const ANONYMOUS: bool = false;
2802 #[allow(unused_variables)]
2803 #[inline]
2804 fn new(
2805 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2806 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2807 ) -> Self {
2808 Self {
2809 role: topics.1,
2810 account: topics.2,
2811 sender: topics.3,
2812 }
2813 }
2814 #[inline]
2815 fn check_signature(
2816 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2817 ) -> alloy_sol_types::Result<()> {
2818 if topics.0 != Self::SIGNATURE_HASH {
2819 return Err(
2820 alloy_sol_types::Error::invalid_event_signature_hash(
2821 Self::SIGNATURE,
2822 topics.0,
2823 Self::SIGNATURE_HASH,
2824 ),
2825 );
2826 }
2827 Ok(())
2828 }
2829 #[inline]
2830 fn tokenize_body(&self) -> Self::DataToken<'_> {
2831 ()
2832 }
2833 #[inline]
2834 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2835 (
2836 Self::SIGNATURE_HASH.into(),
2837 self.role.clone(),
2838 self.account.clone(),
2839 self.sender.clone(),
2840 )
2841 }
2842 #[inline]
2843 fn encode_topics_raw(
2844 &self,
2845 out: &mut [alloy_sol_types::abi::token::WordToken],
2846 ) -> alloy_sol_types::Result<()> {
2847 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2848 return Err(alloy_sol_types::Error::Overrun);
2849 }
2850 out[0usize] = alloy_sol_types::abi::token::WordToken(
2851 Self::SIGNATURE_HASH,
2852 );
2853 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2854 32,
2855 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
2856 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2857 &self.account,
2858 );
2859 out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2860 &self.sender,
2861 );
2862 Ok(())
2863 }
2864 }
2865 #[automatically_derived]
2866 impl alloy_sol_types::private::IntoLogData for RoleGranted {
2867 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2868 From::from(self)
2869 }
2870 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2871 From::from(&self)
2872 }
2873 }
2874 #[automatically_derived]
2875 impl From<&RoleGranted> for alloy_sol_types::private::LogData {
2876 #[inline]
2877 fn from(this: &RoleGranted) -> alloy_sol_types::private::LogData {
2878 alloy_sol_types::SolEvent::encode_log_data(this)
2879 }
2880 }
2881 };
2882 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2883 #[allow(
2888 non_camel_case_types,
2889 non_snake_case,
2890 clippy::pub_underscore_fields,
2891 clippy::style
2892 )]
2893 #[derive(Clone)]
2894 pub struct RoleRevoked {
2895 #[allow(missing_docs)]
2896 pub role: alloy::sol_types::private::FixedBytes<32>,
2897 #[allow(missing_docs)]
2898 pub account: alloy::sol_types::private::Address,
2899 #[allow(missing_docs)]
2900 pub sender: alloy::sol_types::private::Address,
2901 }
2902 #[allow(
2903 non_camel_case_types,
2904 non_snake_case,
2905 clippy::pub_underscore_fields,
2906 clippy::style
2907 )]
2908 const _: () = {
2909 use alloy::sol_types as alloy_sol_types;
2910 #[automatically_derived]
2911 impl alloy_sol_types::SolEvent for RoleRevoked {
2912 type DataTuple<'a> = ();
2913 type DataToken<'a> = <Self::DataTuple<
2914 'a,
2915 > as alloy_sol_types::SolType>::Token<'a>;
2916 type TopicList = (
2917 alloy_sol_types::sol_data::FixedBytes<32>,
2918 alloy::sol_types::sol_data::FixedBytes<32>,
2919 alloy::sol_types::sol_data::Address,
2920 alloy::sol_types::sol_data::Address,
2921 );
2922 const SIGNATURE: &'static str = "RoleRevoked(bytes32,address,address)";
2923 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2924 246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8,
2925 103u8, 11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8,
2926 253u8, 100u8, 235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
2927 ]);
2928 const ANONYMOUS: bool = false;
2929 #[allow(unused_variables)]
2930 #[inline]
2931 fn new(
2932 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2933 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2934 ) -> Self {
2935 Self {
2936 role: topics.1,
2937 account: topics.2,
2938 sender: topics.3,
2939 }
2940 }
2941 #[inline]
2942 fn check_signature(
2943 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2944 ) -> alloy_sol_types::Result<()> {
2945 if topics.0 != Self::SIGNATURE_HASH {
2946 return Err(
2947 alloy_sol_types::Error::invalid_event_signature_hash(
2948 Self::SIGNATURE,
2949 topics.0,
2950 Self::SIGNATURE_HASH,
2951 ),
2952 );
2953 }
2954 Ok(())
2955 }
2956 #[inline]
2957 fn tokenize_body(&self) -> Self::DataToken<'_> {
2958 ()
2959 }
2960 #[inline]
2961 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2962 (
2963 Self::SIGNATURE_HASH.into(),
2964 self.role.clone(),
2965 self.account.clone(),
2966 self.sender.clone(),
2967 )
2968 }
2969 #[inline]
2970 fn encode_topics_raw(
2971 &self,
2972 out: &mut [alloy_sol_types::abi::token::WordToken],
2973 ) -> alloy_sol_types::Result<()> {
2974 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2975 return Err(alloy_sol_types::Error::Overrun);
2976 }
2977 out[0usize] = alloy_sol_types::abi::token::WordToken(
2978 Self::SIGNATURE_HASH,
2979 );
2980 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
2981 32,
2982 > as alloy_sol_types::EventTopic>::encode_topic(&self.role);
2983 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2984 &self.account,
2985 );
2986 out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2987 &self.sender,
2988 );
2989 Ok(())
2990 }
2991 }
2992 #[automatically_derived]
2993 impl alloy_sol_types::private::IntoLogData for RoleRevoked {
2994 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2995 From::from(self)
2996 }
2997 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2998 From::from(&self)
2999 }
3000 }
3001 #[automatically_derived]
3002 impl From<&RoleRevoked> for alloy_sol_types::private::LogData {
3003 #[inline]
3004 fn from(this: &RoleRevoked) -> alloy_sol_types::private::LogData {
3005 alloy_sol_types::SolEvent::encode_log_data(this)
3006 }
3007 }
3008 };
3009 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3014 #[derive(Clone)]
3015 pub struct constructorCall {
3016 #[allow(missing_docs)]
3017 pub minDelay: alloy::sol_types::private::primitives::aliases::U256,
3018 #[allow(missing_docs)]
3019 pub proposers: alloy::sol_types::private::Vec<
3020 alloy::sol_types::private::Address,
3021 >,
3022 #[allow(missing_docs)]
3023 pub executors: alloy::sol_types::private::Vec<
3024 alloy::sol_types::private::Address,
3025 >,
3026 #[allow(missing_docs)]
3027 pub admin: alloy::sol_types::private::Address,
3028 }
3029 const _: () = {
3030 use alloy::sol_types as alloy_sol_types;
3031 {
3032 #[doc(hidden)]
3033 type UnderlyingSolTuple<'a> = (
3034 alloy::sol_types::sol_data::Uint<256>,
3035 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3036 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3037 alloy::sol_types::sol_data::Address,
3038 );
3039 #[doc(hidden)]
3040 type UnderlyingRustTuple<'a> = (
3041 alloy::sol_types::private::primitives::aliases::U256,
3042 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3043 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3044 alloy::sol_types::private::Address,
3045 );
3046 #[cfg(test)]
3047 #[allow(dead_code, unreachable_patterns)]
3048 fn _type_assertion(
3049 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3050 ) {
3051 match _t {
3052 alloy_sol_types::private::AssertTypeEq::<
3053 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3054 >(_) => {}
3055 }
3056 }
3057 #[automatically_derived]
3058 #[doc(hidden)]
3059 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
3060 fn from(value: constructorCall) -> Self {
3061 (value.minDelay, value.proposers, value.executors, value.admin)
3062 }
3063 }
3064 #[automatically_derived]
3065 #[doc(hidden)]
3066 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
3067 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3068 Self {
3069 minDelay: tuple.0,
3070 proposers: tuple.1,
3071 executors: tuple.2,
3072 admin: tuple.3,
3073 }
3074 }
3075 }
3076 }
3077 #[automatically_derived]
3078 impl alloy_sol_types::SolConstructor for constructorCall {
3079 type Parameters<'a> = (
3080 alloy::sol_types::sol_data::Uint<256>,
3081 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3082 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3083 alloy::sol_types::sol_data::Address,
3084 );
3085 type Token<'a> = <Self::Parameters<
3086 'a,
3087 > as alloy_sol_types::SolType>::Token<'a>;
3088 #[inline]
3089 fn new<'a>(
3090 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3091 ) -> Self {
3092 tuple.into()
3093 }
3094 #[inline]
3095 fn tokenize(&self) -> Self::Token<'_> {
3096 (
3097 <alloy::sol_types::sol_data::Uint<
3098 256,
3099 > as alloy_sol_types::SolType>::tokenize(&self.minDelay),
3100 <alloy::sol_types::sol_data::Array<
3101 alloy::sol_types::sol_data::Address,
3102 > as alloy_sol_types::SolType>::tokenize(&self.proposers),
3103 <alloy::sol_types::sol_data::Array<
3104 alloy::sol_types::sol_data::Address,
3105 > as alloy_sol_types::SolType>::tokenize(&self.executors),
3106 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3107 &self.admin,
3108 ),
3109 )
3110 }
3111 }
3112 };
3113 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3114 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3119 #[derive(Clone)]
3120 pub struct CANCELLER_ROLECall {}
3121 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3122 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3124 #[derive(Clone)]
3125 pub struct CANCELLER_ROLEReturn {
3126 #[allow(missing_docs)]
3127 pub _0: alloy::sol_types::private::FixedBytes<32>,
3128 }
3129 #[allow(
3130 non_camel_case_types,
3131 non_snake_case,
3132 clippy::pub_underscore_fields,
3133 clippy::style
3134 )]
3135 const _: () = {
3136 use alloy::sol_types as alloy_sol_types;
3137 {
3138 #[doc(hidden)]
3139 type UnderlyingSolTuple<'a> = ();
3140 #[doc(hidden)]
3141 type UnderlyingRustTuple<'a> = ();
3142 #[cfg(test)]
3143 #[allow(dead_code, unreachable_patterns)]
3144 fn _type_assertion(
3145 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3146 ) {
3147 match _t {
3148 alloy_sol_types::private::AssertTypeEq::<
3149 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3150 >(_) => {}
3151 }
3152 }
3153 #[automatically_derived]
3154 #[doc(hidden)]
3155 impl ::core::convert::From<CANCELLER_ROLECall> for UnderlyingRustTuple<'_> {
3156 fn from(value: CANCELLER_ROLECall) -> Self {
3157 ()
3158 }
3159 }
3160 #[automatically_derived]
3161 #[doc(hidden)]
3162 impl ::core::convert::From<UnderlyingRustTuple<'_>> for CANCELLER_ROLECall {
3163 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3164 Self {}
3165 }
3166 }
3167 }
3168 {
3169 #[doc(hidden)]
3170 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3171 #[doc(hidden)]
3172 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3173 #[cfg(test)]
3174 #[allow(dead_code, unreachable_patterns)]
3175 fn _type_assertion(
3176 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3177 ) {
3178 match _t {
3179 alloy_sol_types::private::AssertTypeEq::<
3180 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3181 >(_) => {}
3182 }
3183 }
3184 #[automatically_derived]
3185 #[doc(hidden)]
3186 impl ::core::convert::From<CANCELLER_ROLEReturn>
3187 for UnderlyingRustTuple<'_> {
3188 fn from(value: CANCELLER_ROLEReturn) -> Self {
3189 (value._0,)
3190 }
3191 }
3192 #[automatically_derived]
3193 #[doc(hidden)]
3194 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3195 for CANCELLER_ROLEReturn {
3196 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3197 Self { _0: tuple.0 }
3198 }
3199 }
3200 }
3201 #[automatically_derived]
3202 impl alloy_sol_types::SolCall for CANCELLER_ROLECall {
3203 type Parameters<'a> = ();
3204 type Token<'a> = <Self::Parameters<
3205 'a,
3206 > as alloy_sol_types::SolType>::Token<'a>;
3207 type Return = CANCELLER_ROLEReturn;
3208 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3209 type ReturnToken<'a> = <Self::ReturnTuple<
3210 'a,
3211 > as alloy_sol_types::SolType>::Token<'a>;
3212 const SIGNATURE: &'static str = "CANCELLER_ROLE()";
3213 const SELECTOR: [u8; 4] = [176u8, 142u8, 81u8, 192u8];
3214 #[inline]
3215 fn new<'a>(
3216 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3217 ) -> Self {
3218 tuple.into()
3219 }
3220 #[inline]
3221 fn tokenize(&self) -> Self::Token<'_> {
3222 ()
3223 }
3224 #[inline]
3225 fn abi_decode_returns(
3226 data: &[u8],
3227 validate: bool,
3228 ) -> alloy_sol_types::Result<Self::Return> {
3229 <Self::ReturnTuple<
3230 '_,
3231 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3232 .map(Into::into)
3233 }
3234 }
3235 };
3236 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3237 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3242 #[derive(Clone)]
3243 pub struct DEFAULT_ADMIN_ROLECall {}
3244 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3245 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3247 #[derive(Clone)]
3248 pub struct DEFAULT_ADMIN_ROLEReturn {
3249 #[allow(missing_docs)]
3250 pub _0: alloy::sol_types::private::FixedBytes<32>,
3251 }
3252 #[allow(
3253 non_camel_case_types,
3254 non_snake_case,
3255 clippy::pub_underscore_fields,
3256 clippy::style
3257 )]
3258 const _: () = {
3259 use alloy::sol_types as alloy_sol_types;
3260 {
3261 #[doc(hidden)]
3262 type UnderlyingSolTuple<'a> = ();
3263 #[doc(hidden)]
3264 type UnderlyingRustTuple<'a> = ();
3265 #[cfg(test)]
3266 #[allow(dead_code, unreachable_patterns)]
3267 fn _type_assertion(
3268 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3269 ) {
3270 match _t {
3271 alloy_sol_types::private::AssertTypeEq::<
3272 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3273 >(_) => {}
3274 }
3275 }
3276 #[automatically_derived]
3277 #[doc(hidden)]
3278 impl ::core::convert::From<DEFAULT_ADMIN_ROLECall>
3279 for UnderlyingRustTuple<'_> {
3280 fn from(value: DEFAULT_ADMIN_ROLECall) -> Self {
3281 ()
3282 }
3283 }
3284 #[automatically_derived]
3285 #[doc(hidden)]
3286 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3287 for DEFAULT_ADMIN_ROLECall {
3288 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3289 Self {}
3290 }
3291 }
3292 }
3293 {
3294 #[doc(hidden)]
3295 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3296 #[doc(hidden)]
3297 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3298 #[cfg(test)]
3299 #[allow(dead_code, unreachable_patterns)]
3300 fn _type_assertion(
3301 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3302 ) {
3303 match _t {
3304 alloy_sol_types::private::AssertTypeEq::<
3305 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3306 >(_) => {}
3307 }
3308 }
3309 #[automatically_derived]
3310 #[doc(hidden)]
3311 impl ::core::convert::From<DEFAULT_ADMIN_ROLEReturn>
3312 for UnderlyingRustTuple<'_> {
3313 fn from(value: DEFAULT_ADMIN_ROLEReturn) -> Self {
3314 (value._0,)
3315 }
3316 }
3317 #[automatically_derived]
3318 #[doc(hidden)]
3319 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3320 for DEFAULT_ADMIN_ROLEReturn {
3321 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3322 Self { _0: tuple.0 }
3323 }
3324 }
3325 }
3326 #[automatically_derived]
3327 impl alloy_sol_types::SolCall for DEFAULT_ADMIN_ROLECall {
3328 type Parameters<'a> = ();
3329 type Token<'a> = <Self::Parameters<
3330 'a,
3331 > as alloy_sol_types::SolType>::Token<'a>;
3332 type Return = DEFAULT_ADMIN_ROLEReturn;
3333 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3334 type ReturnToken<'a> = <Self::ReturnTuple<
3335 'a,
3336 > as alloy_sol_types::SolType>::Token<'a>;
3337 const SIGNATURE: &'static str = "DEFAULT_ADMIN_ROLE()";
3338 const SELECTOR: [u8; 4] = [162u8, 23u8, 253u8, 223u8];
3339 #[inline]
3340 fn new<'a>(
3341 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3342 ) -> Self {
3343 tuple.into()
3344 }
3345 #[inline]
3346 fn tokenize(&self) -> Self::Token<'_> {
3347 ()
3348 }
3349 #[inline]
3350 fn abi_decode_returns(
3351 data: &[u8],
3352 validate: bool,
3353 ) -> alloy_sol_types::Result<Self::Return> {
3354 <Self::ReturnTuple<
3355 '_,
3356 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3357 .map(Into::into)
3358 }
3359 }
3360 };
3361 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3362 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3367 #[derive(Clone)]
3368 pub struct EXECUTOR_ROLECall {}
3369 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3370 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3372 #[derive(Clone)]
3373 pub struct EXECUTOR_ROLEReturn {
3374 #[allow(missing_docs)]
3375 pub _0: alloy::sol_types::private::FixedBytes<32>,
3376 }
3377 #[allow(
3378 non_camel_case_types,
3379 non_snake_case,
3380 clippy::pub_underscore_fields,
3381 clippy::style
3382 )]
3383 const _: () = {
3384 use alloy::sol_types as alloy_sol_types;
3385 {
3386 #[doc(hidden)]
3387 type UnderlyingSolTuple<'a> = ();
3388 #[doc(hidden)]
3389 type UnderlyingRustTuple<'a> = ();
3390 #[cfg(test)]
3391 #[allow(dead_code, unreachable_patterns)]
3392 fn _type_assertion(
3393 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3394 ) {
3395 match _t {
3396 alloy_sol_types::private::AssertTypeEq::<
3397 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3398 >(_) => {}
3399 }
3400 }
3401 #[automatically_derived]
3402 #[doc(hidden)]
3403 impl ::core::convert::From<EXECUTOR_ROLECall> for UnderlyingRustTuple<'_> {
3404 fn from(value: EXECUTOR_ROLECall) -> Self {
3405 ()
3406 }
3407 }
3408 #[automatically_derived]
3409 #[doc(hidden)]
3410 impl ::core::convert::From<UnderlyingRustTuple<'_>> for EXECUTOR_ROLECall {
3411 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3412 Self {}
3413 }
3414 }
3415 }
3416 {
3417 #[doc(hidden)]
3418 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3419 #[doc(hidden)]
3420 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3421 #[cfg(test)]
3422 #[allow(dead_code, unreachable_patterns)]
3423 fn _type_assertion(
3424 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3425 ) {
3426 match _t {
3427 alloy_sol_types::private::AssertTypeEq::<
3428 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3429 >(_) => {}
3430 }
3431 }
3432 #[automatically_derived]
3433 #[doc(hidden)]
3434 impl ::core::convert::From<EXECUTOR_ROLEReturn> for UnderlyingRustTuple<'_> {
3435 fn from(value: EXECUTOR_ROLEReturn) -> Self {
3436 (value._0,)
3437 }
3438 }
3439 #[automatically_derived]
3440 #[doc(hidden)]
3441 impl ::core::convert::From<UnderlyingRustTuple<'_>> for EXECUTOR_ROLEReturn {
3442 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3443 Self { _0: tuple.0 }
3444 }
3445 }
3446 }
3447 #[automatically_derived]
3448 impl alloy_sol_types::SolCall for EXECUTOR_ROLECall {
3449 type Parameters<'a> = ();
3450 type Token<'a> = <Self::Parameters<
3451 'a,
3452 > as alloy_sol_types::SolType>::Token<'a>;
3453 type Return = EXECUTOR_ROLEReturn;
3454 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3455 type ReturnToken<'a> = <Self::ReturnTuple<
3456 'a,
3457 > as alloy_sol_types::SolType>::Token<'a>;
3458 const SIGNATURE: &'static str = "EXECUTOR_ROLE()";
3459 const SELECTOR: [u8; 4] = [7u8, 189u8, 2u8, 101u8];
3460 #[inline]
3461 fn new<'a>(
3462 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3463 ) -> Self {
3464 tuple.into()
3465 }
3466 #[inline]
3467 fn tokenize(&self) -> Self::Token<'_> {
3468 ()
3469 }
3470 #[inline]
3471 fn abi_decode_returns(
3472 data: &[u8],
3473 validate: bool,
3474 ) -> alloy_sol_types::Result<Self::Return> {
3475 <Self::ReturnTuple<
3476 '_,
3477 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3478 .map(Into::into)
3479 }
3480 }
3481 };
3482 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3483 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3488 #[derive(Clone)]
3489 pub struct PROPOSER_ROLECall {}
3490 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3491 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3493 #[derive(Clone)]
3494 pub struct PROPOSER_ROLEReturn {
3495 #[allow(missing_docs)]
3496 pub _0: alloy::sol_types::private::FixedBytes<32>,
3497 }
3498 #[allow(
3499 non_camel_case_types,
3500 non_snake_case,
3501 clippy::pub_underscore_fields,
3502 clippy::style
3503 )]
3504 const _: () = {
3505 use alloy::sol_types as alloy_sol_types;
3506 {
3507 #[doc(hidden)]
3508 type UnderlyingSolTuple<'a> = ();
3509 #[doc(hidden)]
3510 type UnderlyingRustTuple<'a> = ();
3511 #[cfg(test)]
3512 #[allow(dead_code, unreachable_patterns)]
3513 fn _type_assertion(
3514 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3515 ) {
3516 match _t {
3517 alloy_sol_types::private::AssertTypeEq::<
3518 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3519 >(_) => {}
3520 }
3521 }
3522 #[automatically_derived]
3523 #[doc(hidden)]
3524 impl ::core::convert::From<PROPOSER_ROLECall> for UnderlyingRustTuple<'_> {
3525 fn from(value: PROPOSER_ROLECall) -> Self {
3526 ()
3527 }
3528 }
3529 #[automatically_derived]
3530 #[doc(hidden)]
3531 impl ::core::convert::From<UnderlyingRustTuple<'_>> for PROPOSER_ROLECall {
3532 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3533 Self {}
3534 }
3535 }
3536 }
3537 {
3538 #[doc(hidden)]
3539 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3540 #[doc(hidden)]
3541 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3542 #[cfg(test)]
3543 #[allow(dead_code, unreachable_patterns)]
3544 fn _type_assertion(
3545 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3546 ) {
3547 match _t {
3548 alloy_sol_types::private::AssertTypeEq::<
3549 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3550 >(_) => {}
3551 }
3552 }
3553 #[automatically_derived]
3554 #[doc(hidden)]
3555 impl ::core::convert::From<PROPOSER_ROLEReturn> for UnderlyingRustTuple<'_> {
3556 fn from(value: PROPOSER_ROLEReturn) -> Self {
3557 (value._0,)
3558 }
3559 }
3560 #[automatically_derived]
3561 #[doc(hidden)]
3562 impl ::core::convert::From<UnderlyingRustTuple<'_>> for PROPOSER_ROLEReturn {
3563 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3564 Self { _0: tuple.0 }
3565 }
3566 }
3567 }
3568 #[automatically_derived]
3569 impl alloy_sol_types::SolCall for PROPOSER_ROLECall {
3570 type Parameters<'a> = ();
3571 type Token<'a> = <Self::Parameters<
3572 'a,
3573 > as alloy_sol_types::SolType>::Token<'a>;
3574 type Return = PROPOSER_ROLEReturn;
3575 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3576 type ReturnToken<'a> = <Self::ReturnTuple<
3577 'a,
3578 > as alloy_sol_types::SolType>::Token<'a>;
3579 const SIGNATURE: &'static str = "PROPOSER_ROLE()";
3580 const SELECTOR: [u8; 4] = [143u8, 97u8, 244u8, 245u8];
3581 #[inline]
3582 fn new<'a>(
3583 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3584 ) -> Self {
3585 tuple.into()
3586 }
3587 #[inline]
3588 fn tokenize(&self) -> Self::Token<'_> {
3589 ()
3590 }
3591 #[inline]
3592 fn abi_decode_returns(
3593 data: &[u8],
3594 validate: bool,
3595 ) -> alloy_sol_types::Result<Self::Return> {
3596 <Self::ReturnTuple<
3597 '_,
3598 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3599 .map(Into::into)
3600 }
3601 }
3602 };
3603 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3604 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3609 #[derive(Clone)]
3610 pub struct cancelCall {
3611 #[allow(missing_docs)]
3612 pub id: alloy::sol_types::private::FixedBytes<32>,
3613 }
3614 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3616 #[derive(Clone)]
3617 pub struct cancelReturn {}
3618 #[allow(
3619 non_camel_case_types,
3620 non_snake_case,
3621 clippy::pub_underscore_fields,
3622 clippy::style
3623 )]
3624 const _: () = {
3625 use alloy::sol_types as alloy_sol_types;
3626 {
3627 #[doc(hidden)]
3628 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3629 #[doc(hidden)]
3630 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
3631 #[cfg(test)]
3632 #[allow(dead_code, unreachable_patterns)]
3633 fn _type_assertion(
3634 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3635 ) {
3636 match _t {
3637 alloy_sol_types::private::AssertTypeEq::<
3638 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3639 >(_) => {}
3640 }
3641 }
3642 #[automatically_derived]
3643 #[doc(hidden)]
3644 impl ::core::convert::From<cancelCall> for UnderlyingRustTuple<'_> {
3645 fn from(value: cancelCall) -> Self {
3646 (value.id,)
3647 }
3648 }
3649 #[automatically_derived]
3650 #[doc(hidden)]
3651 impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelCall {
3652 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3653 Self { id: tuple.0 }
3654 }
3655 }
3656 }
3657 {
3658 #[doc(hidden)]
3659 type UnderlyingSolTuple<'a> = ();
3660 #[doc(hidden)]
3661 type UnderlyingRustTuple<'a> = ();
3662 #[cfg(test)]
3663 #[allow(dead_code, unreachable_patterns)]
3664 fn _type_assertion(
3665 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3666 ) {
3667 match _t {
3668 alloy_sol_types::private::AssertTypeEq::<
3669 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3670 >(_) => {}
3671 }
3672 }
3673 #[automatically_derived]
3674 #[doc(hidden)]
3675 impl ::core::convert::From<cancelReturn> for UnderlyingRustTuple<'_> {
3676 fn from(value: cancelReturn) -> Self {
3677 ()
3678 }
3679 }
3680 #[automatically_derived]
3681 #[doc(hidden)]
3682 impl ::core::convert::From<UnderlyingRustTuple<'_>> for cancelReturn {
3683 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3684 Self {}
3685 }
3686 }
3687 }
3688 #[automatically_derived]
3689 impl alloy_sol_types::SolCall for cancelCall {
3690 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
3691 type Token<'a> = <Self::Parameters<
3692 'a,
3693 > as alloy_sol_types::SolType>::Token<'a>;
3694 type Return = cancelReturn;
3695 type ReturnTuple<'a> = ();
3696 type ReturnToken<'a> = <Self::ReturnTuple<
3697 'a,
3698 > as alloy_sol_types::SolType>::Token<'a>;
3699 const SIGNATURE: &'static str = "cancel(bytes32)";
3700 const SELECTOR: [u8; 4] = [196u8, 210u8, 82u8, 245u8];
3701 #[inline]
3702 fn new<'a>(
3703 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3704 ) -> Self {
3705 tuple.into()
3706 }
3707 #[inline]
3708 fn tokenize(&self) -> Self::Token<'_> {
3709 (
3710 <alloy::sol_types::sol_data::FixedBytes<
3711 32,
3712 > as alloy_sol_types::SolType>::tokenize(&self.id),
3713 )
3714 }
3715 #[inline]
3716 fn abi_decode_returns(
3717 data: &[u8],
3718 validate: bool,
3719 ) -> alloy_sol_types::Result<Self::Return> {
3720 <Self::ReturnTuple<
3721 '_,
3722 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3723 .map(Into::into)
3724 }
3725 }
3726 };
3727 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3728 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3733 #[derive(Clone)]
3734 pub struct executeCall {
3735 #[allow(missing_docs)]
3736 pub target: alloy::sol_types::private::Address,
3737 #[allow(missing_docs)]
3738 pub value: alloy::sol_types::private::primitives::aliases::U256,
3739 #[allow(missing_docs)]
3740 pub payload: alloy::sol_types::private::Bytes,
3741 #[allow(missing_docs)]
3742 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
3743 #[allow(missing_docs)]
3744 pub salt: alloy::sol_types::private::FixedBytes<32>,
3745 }
3746 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3748 #[derive(Clone)]
3749 pub struct executeReturn {}
3750 #[allow(
3751 non_camel_case_types,
3752 non_snake_case,
3753 clippy::pub_underscore_fields,
3754 clippy::style
3755 )]
3756 const _: () = {
3757 use alloy::sol_types as alloy_sol_types;
3758 {
3759 #[doc(hidden)]
3760 type UnderlyingSolTuple<'a> = (
3761 alloy::sol_types::sol_data::Address,
3762 alloy::sol_types::sol_data::Uint<256>,
3763 alloy::sol_types::sol_data::Bytes,
3764 alloy::sol_types::sol_data::FixedBytes<32>,
3765 alloy::sol_types::sol_data::FixedBytes<32>,
3766 );
3767 #[doc(hidden)]
3768 type UnderlyingRustTuple<'a> = (
3769 alloy::sol_types::private::Address,
3770 alloy::sol_types::private::primitives::aliases::U256,
3771 alloy::sol_types::private::Bytes,
3772 alloy::sol_types::private::FixedBytes<32>,
3773 alloy::sol_types::private::FixedBytes<32>,
3774 );
3775 #[cfg(test)]
3776 #[allow(dead_code, unreachable_patterns)]
3777 fn _type_assertion(
3778 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3779 ) {
3780 match _t {
3781 alloy_sol_types::private::AssertTypeEq::<
3782 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3783 >(_) => {}
3784 }
3785 }
3786 #[automatically_derived]
3787 #[doc(hidden)]
3788 impl ::core::convert::From<executeCall> for UnderlyingRustTuple<'_> {
3789 fn from(value: executeCall) -> Self {
3790 (
3791 value.target,
3792 value.value,
3793 value.payload,
3794 value.predecessor,
3795 value.salt,
3796 )
3797 }
3798 }
3799 #[automatically_derived]
3800 #[doc(hidden)]
3801 impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeCall {
3802 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3803 Self {
3804 target: tuple.0,
3805 value: tuple.1,
3806 payload: tuple.2,
3807 predecessor: tuple.3,
3808 salt: tuple.4,
3809 }
3810 }
3811 }
3812 }
3813 {
3814 #[doc(hidden)]
3815 type UnderlyingSolTuple<'a> = ();
3816 #[doc(hidden)]
3817 type UnderlyingRustTuple<'a> = ();
3818 #[cfg(test)]
3819 #[allow(dead_code, unreachable_patterns)]
3820 fn _type_assertion(
3821 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3822 ) {
3823 match _t {
3824 alloy_sol_types::private::AssertTypeEq::<
3825 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3826 >(_) => {}
3827 }
3828 }
3829 #[automatically_derived]
3830 #[doc(hidden)]
3831 impl ::core::convert::From<executeReturn> for UnderlyingRustTuple<'_> {
3832 fn from(value: executeReturn) -> Self {
3833 ()
3834 }
3835 }
3836 #[automatically_derived]
3837 #[doc(hidden)]
3838 impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeReturn {
3839 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3840 Self {}
3841 }
3842 }
3843 }
3844 #[automatically_derived]
3845 impl alloy_sol_types::SolCall for executeCall {
3846 type Parameters<'a> = (
3847 alloy::sol_types::sol_data::Address,
3848 alloy::sol_types::sol_data::Uint<256>,
3849 alloy::sol_types::sol_data::Bytes,
3850 alloy::sol_types::sol_data::FixedBytes<32>,
3851 alloy::sol_types::sol_data::FixedBytes<32>,
3852 );
3853 type Token<'a> = <Self::Parameters<
3854 'a,
3855 > as alloy_sol_types::SolType>::Token<'a>;
3856 type Return = executeReturn;
3857 type ReturnTuple<'a> = ();
3858 type ReturnToken<'a> = <Self::ReturnTuple<
3859 'a,
3860 > as alloy_sol_types::SolType>::Token<'a>;
3861 const SIGNATURE: &'static str = "execute(address,uint256,bytes,bytes32,bytes32)";
3862 const SELECTOR: [u8; 4] = [19u8, 64u8, 8u8, 211u8];
3863 #[inline]
3864 fn new<'a>(
3865 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3866 ) -> Self {
3867 tuple.into()
3868 }
3869 #[inline]
3870 fn tokenize(&self) -> Self::Token<'_> {
3871 (
3872 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3873 &self.target,
3874 ),
3875 <alloy::sol_types::sol_data::Uint<
3876 256,
3877 > as alloy_sol_types::SolType>::tokenize(&self.value),
3878 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
3879 &self.payload,
3880 ),
3881 <alloy::sol_types::sol_data::FixedBytes<
3882 32,
3883 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
3884 <alloy::sol_types::sol_data::FixedBytes<
3885 32,
3886 > as alloy_sol_types::SolType>::tokenize(&self.salt),
3887 )
3888 }
3889 #[inline]
3890 fn abi_decode_returns(
3891 data: &[u8],
3892 validate: bool,
3893 ) -> alloy_sol_types::Result<Self::Return> {
3894 <Self::ReturnTuple<
3895 '_,
3896 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3897 .map(Into::into)
3898 }
3899 }
3900 };
3901 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3902 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3907 #[derive(Clone)]
3908 pub struct executeBatchCall {
3909 #[allow(missing_docs)]
3910 pub targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3911 #[allow(missing_docs)]
3912 pub values: alloy::sol_types::private::Vec<
3913 alloy::sol_types::private::primitives::aliases::U256,
3914 >,
3915 #[allow(missing_docs)]
3916 pub payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
3917 #[allow(missing_docs)]
3918 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
3919 #[allow(missing_docs)]
3920 pub salt: alloy::sol_types::private::FixedBytes<32>,
3921 }
3922 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3924 #[derive(Clone)]
3925 pub struct executeBatchReturn {}
3926 #[allow(
3927 non_camel_case_types,
3928 non_snake_case,
3929 clippy::pub_underscore_fields,
3930 clippy::style
3931 )]
3932 const _: () = {
3933 use alloy::sol_types as alloy_sol_types;
3934 {
3935 #[doc(hidden)]
3936 type UnderlyingSolTuple<'a> = (
3937 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3938 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
3939 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
3940 alloy::sol_types::sol_data::FixedBytes<32>,
3941 alloy::sol_types::sol_data::FixedBytes<32>,
3942 );
3943 #[doc(hidden)]
3944 type UnderlyingRustTuple<'a> = (
3945 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3946 alloy::sol_types::private::Vec<
3947 alloy::sol_types::private::primitives::aliases::U256,
3948 >,
3949 alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
3950 alloy::sol_types::private::FixedBytes<32>,
3951 alloy::sol_types::private::FixedBytes<32>,
3952 );
3953 #[cfg(test)]
3954 #[allow(dead_code, unreachable_patterns)]
3955 fn _type_assertion(
3956 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3957 ) {
3958 match _t {
3959 alloy_sol_types::private::AssertTypeEq::<
3960 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3961 >(_) => {}
3962 }
3963 }
3964 #[automatically_derived]
3965 #[doc(hidden)]
3966 impl ::core::convert::From<executeBatchCall> for UnderlyingRustTuple<'_> {
3967 fn from(value: executeBatchCall) -> Self {
3968 (
3969 value.targets,
3970 value.values,
3971 value.payloads,
3972 value.predecessor,
3973 value.salt,
3974 )
3975 }
3976 }
3977 #[automatically_derived]
3978 #[doc(hidden)]
3979 impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeBatchCall {
3980 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3981 Self {
3982 targets: tuple.0,
3983 values: tuple.1,
3984 payloads: tuple.2,
3985 predecessor: tuple.3,
3986 salt: tuple.4,
3987 }
3988 }
3989 }
3990 }
3991 {
3992 #[doc(hidden)]
3993 type UnderlyingSolTuple<'a> = ();
3994 #[doc(hidden)]
3995 type UnderlyingRustTuple<'a> = ();
3996 #[cfg(test)]
3997 #[allow(dead_code, unreachable_patterns)]
3998 fn _type_assertion(
3999 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4000 ) {
4001 match _t {
4002 alloy_sol_types::private::AssertTypeEq::<
4003 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4004 >(_) => {}
4005 }
4006 }
4007 #[automatically_derived]
4008 #[doc(hidden)]
4009 impl ::core::convert::From<executeBatchReturn> for UnderlyingRustTuple<'_> {
4010 fn from(value: executeBatchReturn) -> Self {
4011 ()
4012 }
4013 }
4014 #[automatically_derived]
4015 #[doc(hidden)]
4016 impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeBatchReturn {
4017 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4018 Self {}
4019 }
4020 }
4021 }
4022 #[automatically_derived]
4023 impl alloy_sol_types::SolCall for executeBatchCall {
4024 type Parameters<'a> = (
4025 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
4026 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
4027 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
4028 alloy::sol_types::sol_data::FixedBytes<32>,
4029 alloy::sol_types::sol_data::FixedBytes<32>,
4030 );
4031 type Token<'a> = <Self::Parameters<
4032 'a,
4033 > as alloy_sol_types::SolType>::Token<'a>;
4034 type Return = executeBatchReturn;
4035 type ReturnTuple<'a> = ();
4036 type ReturnToken<'a> = <Self::ReturnTuple<
4037 'a,
4038 > as alloy_sol_types::SolType>::Token<'a>;
4039 const SIGNATURE: &'static str = "executeBatch(address[],uint256[],bytes[],bytes32,bytes32)";
4040 const SELECTOR: [u8; 4] = [227u8, 131u8, 53u8, 229u8];
4041 #[inline]
4042 fn new<'a>(
4043 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4044 ) -> Self {
4045 tuple.into()
4046 }
4047 #[inline]
4048 fn tokenize(&self) -> Self::Token<'_> {
4049 (
4050 <alloy::sol_types::sol_data::Array<
4051 alloy::sol_types::sol_data::Address,
4052 > as alloy_sol_types::SolType>::tokenize(&self.targets),
4053 <alloy::sol_types::sol_data::Array<
4054 alloy::sol_types::sol_data::Uint<256>,
4055 > as alloy_sol_types::SolType>::tokenize(&self.values),
4056 <alloy::sol_types::sol_data::Array<
4057 alloy::sol_types::sol_data::Bytes,
4058 > as alloy_sol_types::SolType>::tokenize(&self.payloads),
4059 <alloy::sol_types::sol_data::FixedBytes<
4060 32,
4061 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
4062 <alloy::sol_types::sol_data::FixedBytes<
4063 32,
4064 > as alloy_sol_types::SolType>::tokenize(&self.salt),
4065 )
4066 }
4067 #[inline]
4068 fn abi_decode_returns(
4069 data: &[u8],
4070 validate: bool,
4071 ) -> alloy_sol_types::Result<Self::Return> {
4072 <Self::ReturnTuple<
4073 '_,
4074 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4075 .map(Into::into)
4076 }
4077 }
4078 };
4079 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4080 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4085 #[derive(Clone)]
4086 pub struct getMinDelayCall {}
4087 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4088 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4090 #[derive(Clone)]
4091 pub struct getMinDelayReturn {
4092 #[allow(missing_docs)]
4093 pub _0: alloy::sol_types::private::primitives::aliases::U256,
4094 }
4095 #[allow(
4096 non_camel_case_types,
4097 non_snake_case,
4098 clippy::pub_underscore_fields,
4099 clippy::style
4100 )]
4101 const _: () = {
4102 use alloy::sol_types as alloy_sol_types;
4103 {
4104 #[doc(hidden)]
4105 type UnderlyingSolTuple<'a> = ();
4106 #[doc(hidden)]
4107 type UnderlyingRustTuple<'a> = ();
4108 #[cfg(test)]
4109 #[allow(dead_code, unreachable_patterns)]
4110 fn _type_assertion(
4111 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4112 ) {
4113 match _t {
4114 alloy_sol_types::private::AssertTypeEq::<
4115 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4116 >(_) => {}
4117 }
4118 }
4119 #[automatically_derived]
4120 #[doc(hidden)]
4121 impl ::core::convert::From<getMinDelayCall> for UnderlyingRustTuple<'_> {
4122 fn from(value: getMinDelayCall) -> Self {
4123 ()
4124 }
4125 }
4126 #[automatically_derived]
4127 #[doc(hidden)]
4128 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMinDelayCall {
4129 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4130 Self {}
4131 }
4132 }
4133 }
4134 {
4135 #[doc(hidden)]
4136 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4137 #[doc(hidden)]
4138 type UnderlyingRustTuple<'a> = (
4139 alloy::sol_types::private::primitives::aliases::U256,
4140 );
4141 #[cfg(test)]
4142 #[allow(dead_code, unreachable_patterns)]
4143 fn _type_assertion(
4144 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4145 ) {
4146 match _t {
4147 alloy_sol_types::private::AssertTypeEq::<
4148 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4149 >(_) => {}
4150 }
4151 }
4152 #[automatically_derived]
4153 #[doc(hidden)]
4154 impl ::core::convert::From<getMinDelayReturn> for UnderlyingRustTuple<'_> {
4155 fn from(value: getMinDelayReturn) -> Self {
4156 (value._0,)
4157 }
4158 }
4159 #[automatically_derived]
4160 #[doc(hidden)]
4161 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMinDelayReturn {
4162 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4163 Self { _0: tuple.0 }
4164 }
4165 }
4166 }
4167 #[automatically_derived]
4168 impl alloy_sol_types::SolCall for getMinDelayCall {
4169 type Parameters<'a> = ();
4170 type Token<'a> = <Self::Parameters<
4171 'a,
4172 > as alloy_sol_types::SolType>::Token<'a>;
4173 type Return = getMinDelayReturn;
4174 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4175 type ReturnToken<'a> = <Self::ReturnTuple<
4176 'a,
4177 > as alloy_sol_types::SolType>::Token<'a>;
4178 const SIGNATURE: &'static str = "getMinDelay()";
4179 const SELECTOR: [u8; 4] = [242u8, 122u8, 12u8, 146u8];
4180 #[inline]
4181 fn new<'a>(
4182 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4183 ) -> Self {
4184 tuple.into()
4185 }
4186 #[inline]
4187 fn tokenize(&self) -> Self::Token<'_> {
4188 ()
4189 }
4190 #[inline]
4191 fn abi_decode_returns(
4192 data: &[u8],
4193 validate: bool,
4194 ) -> alloy_sol_types::Result<Self::Return> {
4195 <Self::ReturnTuple<
4196 '_,
4197 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4198 .map(Into::into)
4199 }
4200 }
4201 };
4202 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4203 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4208 #[derive(Clone)]
4209 pub struct getOperationStateCall {
4210 #[allow(missing_docs)]
4211 pub id: alloy::sol_types::private::FixedBytes<32>,
4212 }
4213 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4214 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4216 #[derive(Clone)]
4217 pub struct getOperationStateReturn {
4218 #[allow(missing_docs)]
4219 pub _0: <TimelockController::OperationState as alloy::sol_types::SolType>::RustType,
4220 }
4221 #[allow(
4222 non_camel_case_types,
4223 non_snake_case,
4224 clippy::pub_underscore_fields,
4225 clippy::style
4226 )]
4227 const _: () = {
4228 use alloy::sol_types as alloy_sol_types;
4229 {
4230 #[doc(hidden)]
4231 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4232 #[doc(hidden)]
4233 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
4234 #[cfg(test)]
4235 #[allow(dead_code, unreachable_patterns)]
4236 fn _type_assertion(
4237 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4238 ) {
4239 match _t {
4240 alloy_sol_types::private::AssertTypeEq::<
4241 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4242 >(_) => {}
4243 }
4244 }
4245 #[automatically_derived]
4246 #[doc(hidden)]
4247 impl ::core::convert::From<getOperationStateCall>
4248 for UnderlyingRustTuple<'_> {
4249 fn from(value: getOperationStateCall) -> Self {
4250 (value.id,)
4251 }
4252 }
4253 #[automatically_derived]
4254 #[doc(hidden)]
4255 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4256 for getOperationStateCall {
4257 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4258 Self { id: tuple.0 }
4259 }
4260 }
4261 }
4262 {
4263 #[doc(hidden)]
4264 type UnderlyingSolTuple<'a> = (TimelockController::OperationState,);
4265 #[doc(hidden)]
4266 type UnderlyingRustTuple<'a> = (
4267 <TimelockController::OperationState as alloy::sol_types::SolType>::RustType,
4268 );
4269 #[cfg(test)]
4270 #[allow(dead_code, unreachable_patterns)]
4271 fn _type_assertion(
4272 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4273 ) {
4274 match _t {
4275 alloy_sol_types::private::AssertTypeEq::<
4276 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4277 >(_) => {}
4278 }
4279 }
4280 #[automatically_derived]
4281 #[doc(hidden)]
4282 impl ::core::convert::From<getOperationStateReturn>
4283 for UnderlyingRustTuple<'_> {
4284 fn from(value: getOperationStateReturn) -> Self {
4285 (value._0,)
4286 }
4287 }
4288 #[automatically_derived]
4289 #[doc(hidden)]
4290 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4291 for getOperationStateReturn {
4292 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4293 Self { _0: tuple.0 }
4294 }
4295 }
4296 }
4297 #[automatically_derived]
4298 impl alloy_sol_types::SolCall for getOperationStateCall {
4299 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4300 type Token<'a> = <Self::Parameters<
4301 'a,
4302 > as alloy_sol_types::SolType>::Token<'a>;
4303 type Return = getOperationStateReturn;
4304 type ReturnTuple<'a> = (TimelockController::OperationState,);
4305 type ReturnToken<'a> = <Self::ReturnTuple<
4306 'a,
4307 > as alloy_sol_types::SolType>::Token<'a>;
4308 const SIGNATURE: &'static str = "getOperationState(bytes32)";
4309 const SELECTOR: [u8; 4] = [121u8, 88u8, 0u8, 76u8];
4310 #[inline]
4311 fn new<'a>(
4312 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4313 ) -> Self {
4314 tuple.into()
4315 }
4316 #[inline]
4317 fn tokenize(&self) -> Self::Token<'_> {
4318 (
4319 <alloy::sol_types::sol_data::FixedBytes<
4320 32,
4321 > as alloy_sol_types::SolType>::tokenize(&self.id),
4322 )
4323 }
4324 #[inline]
4325 fn abi_decode_returns(
4326 data: &[u8],
4327 validate: bool,
4328 ) -> alloy_sol_types::Result<Self::Return> {
4329 <Self::ReturnTuple<
4330 '_,
4331 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4332 .map(Into::into)
4333 }
4334 }
4335 };
4336 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4337 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4342 #[derive(Clone)]
4343 pub struct getRoleAdminCall {
4344 #[allow(missing_docs)]
4345 pub role: alloy::sol_types::private::FixedBytes<32>,
4346 }
4347 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4348 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4350 #[derive(Clone)]
4351 pub struct getRoleAdminReturn {
4352 #[allow(missing_docs)]
4353 pub _0: alloy::sol_types::private::FixedBytes<32>,
4354 }
4355 #[allow(
4356 non_camel_case_types,
4357 non_snake_case,
4358 clippy::pub_underscore_fields,
4359 clippy::style
4360 )]
4361 const _: () = {
4362 use alloy::sol_types as alloy_sol_types;
4363 {
4364 #[doc(hidden)]
4365 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4366 #[doc(hidden)]
4367 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
4368 #[cfg(test)]
4369 #[allow(dead_code, unreachable_patterns)]
4370 fn _type_assertion(
4371 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4372 ) {
4373 match _t {
4374 alloy_sol_types::private::AssertTypeEq::<
4375 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4376 >(_) => {}
4377 }
4378 }
4379 #[automatically_derived]
4380 #[doc(hidden)]
4381 impl ::core::convert::From<getRoleAdminCall> for UnderlyingRustTuple<'_> {
4382 fn from(value: getRoleAdminCall) -> Self {
4383 (value.role,)
4384 }
4385 }
4386 #[automatically_derived]
4387 #[doc(hidden)]
4388 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminCall {
4389 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4390 Self { role: tuple.0 }
4391 }
4392 }
4393 }
4394 {
4395 #[doc(hidden)]
4396 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4397 #[doc(hidden)]
4398 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
4399 #[cfg(test)]
4400 #[allow(dead_code, unreachable_patterns)]
4401 fn _type_assertion(
4402 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4403 ) {
4404 match _t {
4405 alloy_sol_types::private::AssertTypeEq::<
4406 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4407 >(_) => {}
4408 }
4409 }
4410 #[automatically_derived]
4411 #[doc(hidden)]
4412 impl ::core::convert::From<getRoleAdminReturn> for UnderlyingRustTuple<'_> {
4413 fn from(value: getRoleAdminReturn) -> Self {
4414 (value._0,)
4415 }
4416 }
4417 #[automatically_derived]
4418 #[doc(hidden)]
4419 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRoleAdminReturn {
4420 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4421 Self { _0: tuple.0 }
4422 }
4423 }
4424 }
4425 #[automatically_derived]
4426 impl alloy_sol_types::SolCall for getRoleAdminCall {
4427 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4428 type Token<'a> = <Self::Parameters<
4429 'a,
4430 > as alloy_sol_types::SolType>::Token<'a>;
4431 type Return = getRoleAdminReturn;
4432 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4433 type ReturnToken<'a> = <Self::ReturnTuple<
4434 'a,
4435 > as alloy_sol_types::SolType>::Token<'a>;
4436 const SIGNATURE: &'static str = "getRoleAdmin(bytes32)";
4437 const SELECTOR: [u8; 4] = [36u8, 138u8, 156u8, 163u8];
4438 #[inline]
4439 fn new<'a>(
4440 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4441 ) -> Self {
4442 tuple.into()
4443 }
4444 #[inline]
4445 fn tokenize(&self) -> Self::Token<'_> {
4446 (
4447 <alloy::sol_types::sol_data::FixedBytes<
4448 32,
4449 > as alloy_sol_types::SolType>::tokenize(&self.role),
4450 )
4451 }
4452 #[inline]
4453 fn abi_decode_returns(
4454 data: &[u8],
4455 validate: bool,
4456 ) -> alloy_sol_types::Result<Self::Return> {
4457 <Self::ReturnTuple<
4458 '_,
4459 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4460 .map(Into::into)
4461 }
4462 }
4463 };
4464 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4465 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4470 #[derive(Clone)]
4471 pub struct getTimestampCall {
4472 #[allow(missing_docs)]
4473 pub id: alloy::sol_types::private::FixedBytes<32>,
4474 }
4475 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4476 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4478 #[derive(Clone)]
4479 pub struct getTimestampReturn {
4480 #[allow(missing_docs)]
4481 pub _0: alloy::sol_types::private::primitives::aliases::U256,
4482 }
4483 #[allow(
4484 non_camel_case_types,
4485 non_snake_case,
4486 clippy::pub_underscore_fields,
4487 clippy::style
4488 )]
4489 const _: () = {
4490 use alloy::sol_types as alloy_sol_types;
4491 {
4492 #[doc(hidden)]
4493 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4494 #[doc(hidden)]
4495 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
4496 #[cfg(test)]
4497 #[allow(dead_code, unreachable_patterns)]
4498 fn _type_assertion(
4499 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4500 ) {
4501 match _t {
4502 alloy_sol_types::private::AssertTypeEq::<
4503 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4504 >(_) => {}
4505 }
4506 }
4507 #[automatically_derived]
4508 #[doc(hidden)]
4509 impl ::core::convert::From<getTimestampCall> for UnderlyingRustTuple<'_> {
4510 fn from(value: getTimestampCall) -> Self {
4511 (value.id,)
4512 }
4513 }
4514 #[automatically_derived]
4515 #[doc(hidden)]
4516 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTimestampCall {
4517 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4518 Self { id: tuple.0 }
4519 }
4520 }
4521 }
4522 {
4523 #[doc(hidden)]
4524 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4525 #[doc(hidden)]
4526 type UnderlyingRustTuple<'a> = (
4527 alloy::sol_types::private::primitives::aliases::U256,
4528 );
4529 #[cfg(test)]
4530 #[allow(dead_code, unreachable_patterns)]
4531 fn _type_assertion(
4532 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4533 ) {
4534 match _t {
4535 alloy_sol_types::private::AssertTypeEq::<
4536 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4537 >(_) => {}
4538 }
4539 }
4540 #[automatically_derived]
4541 #[doc(hidden)]
4542 impl ::core::convert::From<getTimestampReturn> for UnderlyingRustTuple<'_> {
4543 fn from(value: getTimestampReturn) -> Self {
4544 (value._0,)
4545 }
4546 }
4547 #[automatically_derived]
4548 #[doc(hidden)]
4549 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTimestampReturn {
4550 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4551 Self { _0: tuple.0 }
4552 }
4553 }
4554 }
4555 #[automatically_derived]
4556 impl alloy_sol_types::SolCall for getTimestampCall {
4557 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4558 type Token<'a> = <Self::Parameters<
4559 'a,
4560 > as alloy_sol_types::SolType>::Token<'a>;
4561 type Return = getTimestampReturn;
4562 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4563 type ReturnToken<'a> = <Self::ReturnTuple<
4564 'a,
4565 > as alloy_sol_types::SolType>::Token<'a>;
4566 const SIGNATURE: &'static str = "getTimestamp(bytes32)";
4567 const SELECTOR: [u8; 4] = [212u8, 92u8, 68u8, 53u8];
4568 #[inline]
4569 fn new<'a>(
4570 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4571 ) -> Self {
4572 tuple.into()
4573 }
4574 #[inline]
4575 fn tokenize(&self) -> Self::Token<'_> {
4576 (
4577 <alloy::sol_types::sol_data::FixedBytes<
4578 32,
4579 > as alloy_sol_types::SolType>::tokenize(&self.id),
4580 )
4581 }
4582 #[inline]
4583 fn abi_decode_returns(
4584 data: &[u8],
4585 validate: bool,
4586 ) -> alloy_sol_types::Result<Self::Return> {
4587 <Self::ReturnTuple<
4588 '_,
4589 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4590 .map(Into::into)
4591 }
4592 }
4593 };
4594 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4595 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4600 #[derive(Clone)]
4601 pub struct grantRoleCall {
4602 #[allow(missing_docs)]
4603 pub role: alloy::sol_types::private::FixedBytes<32>,
4604 #[allow(missing_docs)]
4605 pub account: alloy::sol_types::private::Address,
4606 }
4607 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4609 #[derive(Clone)]
4610 pub struct grantRoleReturn {}
4611 #[allow(
4612 non_camel_case_types,
4613 non_snake_case,
4614 clippy::pub_underscore_fields,
4615 clippy::style
4616 )]
4617 const _: () = {
4618 use alloy::sol_types as alloy_sol_types;
4619 {
4620 #[doc(hidden)]
4621 type UnderlyingSolTuple<'a> = (
4622 alloy::sol_types::sol_data::FixedBytes<32>,
4623 alloy::sol_types::sol_data::Address,
4624 );
4625 #[doc(hidden)]
4626 type UnderlyingRustTuple<'a> = (
4627 alloy::sol_types::private::FixedBytes<32>,
4628 alloy::sol_types::private::Address,
4629 );
4630 #[cfg(test)]
4631 #[allow(dead_code, unreachable_patterns)]
4632 fn _type_assertion(
4633 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4634 ) {
4635 match _t {
4636 alloy_sol_types::private::AssertTypeEq::<
4637 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4638 >(_) => {}
4639 }
4640 }
4641 #[automatically_derived]
4642 #[doc(hidden)]
4643 impl ::core::convert::From<grantRoleCall> for UnderlyingRustTuple<'_> {
4644 fn from(value: grantRoleCall) -> Self {
4645 (value.role, value.account)
4646 }
4647 }
4648 #[automatically_derived]
4649 #[doc(hidden)]
4650 impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleCall {
4651 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4652 Self {
4653 role: tuple.0,
4654 account: tuple.1,
4655 }
4656 }
4657 }
4658 }
4659 {
4660 #[doc(hidden)]
4661 type UnderlyingSolTuple<'a> = ();
4662 #[doc(hidden)]
4663 type UnderlyingRustTuple<'a> = ();
4664 #[cfg(test)]
4665 #[allow(dead_code, unreachable_patterns)]
4666 fn _type_assertion(
4667 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4668 ) {
4669 match _t {
4670 alloy_sol_types::private::AssertTypeEq::<
4671 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4672 >(_) => {}
4673 }
4674 }
4675 #[automatically_derived]
4676 #[doc(hidden)]
4677 impl ::core::convert::From<grantRoleReturn> for UnderlyingRustTuple<'_> {
4678 fn from(value: grantRoleReturn) -> Self {
4679 ()
4680 }
4681 }
4682 #[automatically_derived]
4683 #[doc(hidden)]
4684 impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleReturn {
4685 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4686 Self {}
4687 }
4688 }
4689 }
4690 #[automatically_derived]
4691 impl alloy_sol_types::SolCall for grantRoleCall {
4692 type Parameters<'a> = (
4693 alloy::sol_types::sol_data::FixedBytes<32>,
4694 alloy::sol_types::sol_data::Address,
4695 );
4696 type Token<'a> = <Self::Parameters<
4697 'a,
4698 > as alloy_sol_types::SolType>::Token<'a>;
4699 type Return = grantRoleReturn;
4700 type ReturnTuple<'a> = ();
4701 type ReturnToken<'a> = <Self::ReturnTuple<
4702 'a,
4703 > as alloy_sol_types::SolType>::Token<'a>;
4704 const SIGNATURE: &'static str = "grantRole(bytes32,address)";
4705 const SELECTOR: [u8; 4] = [47u8, 47u8, 241u8, 93u8];
4706 #[inline]
4707 fn new<'a>(
4708 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4709 ) -> Self {
4710 tuple.into()
4711 }
4712 #[inline]
4713 fn tokenize(&self) -> Self::Token<'_> {
4714 (
4715 <alloy::sol_types::sol_data::FixedBytes<
4716 32,
4717 > as alloy_sol_types::SolType>::tokenize(&self.role),
4718 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4719 &self.account,
4720 ),
4721 )
4722 }
4723 #[inline]
4724 fn abi_decode_returns(
4725 data: &[u8],
4726 validate: bool,
4727 ) -> alloy_sol_types::Result<Self::Return> {
4728 <Self::ReturnTuple<
4729 '_,
4730 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4731 .map(Into::into)
4732 }
4733 }
4734 };
4735 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4736 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4741 #[derive(Clone)]
4742 pub struct hasRoleCall {
4743 #[allow(missing_docs)]
4744 pub role: alloy::sol_types::private::FixedBytes<32>,
4745 #[allow(missing_docs)]
4746 pub account: alloy::sol_types::private::Address,
4747 }
4748 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4749 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4751 #[derive(Clone)]
4752 pub struct hasRoleReturn {
4753 #[allow(missing_docs)]
4754 pub _0: bool,
4755 }
4756 #[allow(
4757 non_camel_case_types,
4758 non_snake_case,
4759 clippy::pub_underscore_fields,
4760 clippy::style
4761 )]
4762 const _: () = {
4763 use alloy::sol_types as alloy_sol_types;
4764 {
4765 #[doc(hidden)]
4766 type UnderlyingSolTuple<'a> = (
4767 alloy::sol_types::sol_data::FixedBytes<32>,
4768 alloy::sol_types::sol_data::Address,
4769 );
4770 #[doc(hidden)]
4771 type UnderlyingRustTuple<'a> = (
4772 alloy::sol_types::private::FixedBytes<32>,
4773 alloy::sol_types::private::Address,
4774 );
4775 #[cfg(test)]
4776 #[allow(dead_code, unreachable_patterns)]
4777 fn _type_assertion(
4778 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4779 ) {
4780 match _t {
4781 alloy_sol_types::private::AssertTypeEq::<
4782 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4783 >(_) => {}
4784 }
4785 }
4786 #[automatically_derived]
4787 #[doc(hidden)]
4788 impl ::core::convert::From<hasRoleCall> for UnderlyingRustTuple<'_> {
4789 fn from(value: hasRoleCall) -> Self {
4790 (value.role, value.account)
4791 }
4792 }
4793 #[automatically_derived]
4794 #[doc(hidden)]
4795 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleCall {
4796 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4797 Self {
4798 role: tuple.0,
4799 account: tuple.1,
4800 }
4801 }
4802 }
4803 }
4804 {
4805 #[doc(hidden)]
4806 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4807 #[doc(hidden)]
4808 type UnderlyingRustTuple<'a> = (bool,);
4809 #[cfg(test)]
4810 #[allow(dead_code, unreachable_patterns)]
4811 fn _type_assertion(
4812 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4813 ) {
4814 match _t {
4815 alloy_sol_types::private::AssertTypeEq::<
4816 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4817 >(_) => {}
4818 }
4819 }
4820 #[automatically_derived]
4821 #[doc(hidden)]
4822 impl ::core::convert::From<hasRoleReturn> for UnderlyingRustTuple<'_> {
4823 fn from(value: hasRoleReturn) -> Self {
4824 (value._0,)
4825 }
4826 }
4827 #[automatically_derived]
4828 #[doc(hidden)]
4829 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleReturn {
4830 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4831 Self { _0: tuple.0 }
4832 }
4833 }
4834 }
4835 #[automatically_derived]
4836 impl alloy_sol_types::SolCall for hasRoleCall {
4837 type Parameters<'a> = (
4838 alloy::sol_types::sol_data::FixedBytes<32>,
4839 alloy::sol_types::sol_data::Address,
4840 );
4841 type Token<'a> = <Self::Parameters<
4842 'a,
4843 > as alloy_sol_types::SolType>::Token<'a>;
4844 type Return = hasRoleReturn;
4845 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4846 type ReturnToken<'a> = <Self::ReturnTuple<
4847 'a,
4848 > as alloy_sol_types::SolType>::Token<'a>;
4849 const SIGNATURE: &'static str = "hasRole(bytes32,address)";
4850 const SELECTOR: [u8; 4] = [145u8, 209u8, 72u8, 84u8];
4851 #[inline]
4852 fn new<'a>(
4853 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4854 ) -> Self {
4855 tuple.into()
4856 }
4857 #[inline]
4858 fn tokenize(&self) -> Self::Token<'_> {
4859 (
4860 <alloy::sol_types::sol_data::FixedBytes<
4861 32,
4862 > as alloy_sol_types::SolType>::tokenize(&self.role),
4863 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4864 &self.account,
4865 ),
4866 )
4867 }
4868 #[inline]
4869 fn abi_decode_returns(
4870 data: &[u8],
4871 validate: bool,
4872 ) -> alloy_sol_types::Result<Self::Return> {
4873 <Self::ReturnTuple<
4874 '_,
4875 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4876 .map(Into::into)
4877 }
4878 }
4879 };
4880 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4881 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4886 #[derive(Clone)]
4887 pub struct hashOperationCall {
4888 #[allow(missing_docs)]
4889 pub target: alloy::sol_types::private::Address,
4890 #[allow(missing_docs)]
4891 pub value: alloy::sol_types::private::primitives::aliases::U256,
4892 #[allow(missing_docs)]
4893 pub data: alloy::sol_types::private::Bytes,
4894 #[allow(missing_docs)]
4895 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
4896 #[allow(missing_docs)]
4897 pub salt: alloy::sol_types::private::FixedBytes<32>,
4898 }
4899 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4900 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4902 #[derive(Clone)]
4903 pub struct hashOperationReturn {
4904 #[allow(missing_docs)]
4905 pub _0: alloy::sol_types::private::FixedBytes<32>,
4906 }
4907 #[allow(
4908 non_camel_case_types,
4909 non_snake_case,
4910 clippy::pub_underscore_fields,
4911 clippy::style
4912 )]
4913 const _: () = {
4914 use alloy::sol_types as alloy_sol_types;
4915 {
4916 #[doc(hidden)]
4917 type UnderlyingSolTuple<'a> = (
4918 alloy::sol_types::sol_data::Address,
4919 alloy::sol_types::sol_data::Uint<256>,
4920 alloy::sol_types::sol_data::Bytes,
4921 alloy::sol_types::sol_data::FixedBytes<32>,
4922 alloy::sol_types::sol_data::FixedBytes<32>,
4923 );
4924 #[doc(hidden)]
4925 type UnderlyingRustTuple<'a> = (
4926 alloy::sol_types::private::Address,
4927 alloy::sol_types::private::primitives::aliases::U256,
4928 alloy::sol_types::private::Bytes,
4929 alloy::sol_types::private::FixedBytes<32>,
4930 alloy::sol_types::private::FixedBytes<32>,
4931 );
4932 #[cfg(test)]
4933 #[allow(dead_code, unreachable_patterns)]
4934 fn _type_assertion(
4935 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4936 ) {
4937 match _t {
4938 alloy_sol_types::private::AssertTypeEq::<
4939 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4940 >(_) => {}
4941 }
4942 }
4943 #[automatically_derived]
4944 #[doc(hidden)]
4945 impl ::core::convert::From<hashOperationCall> for UnderlyingRustTuple<'_> {
4946 fn from(value: hashOperationCall) -> Self {
4947 (
4948 value.target,
4949 value.value,
4950 value.data,
4951 value.predecessor,
4952 value.salt,
4953 )
4954 }
4955 }
4956 #[automatically_derived]
4957 #[doc(hidden)]
4958 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashOperationCall {
4959 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4960 Self {
4961 target: tuple.0,
4962 value: tuple.1,
4963 data: tuple.2,
4964 predecessor: tuple.3,
4965 salt: tuple.4,
4966 }
4967 }
4968 }
4969 }
4970 {
4971 #[doc(hidden)]
4972 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
4973 #[doc(hidden)]
4974 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
4975 #[cfg(test)]
4976 #[allow(dead_code, unreachable_patterns)]
4977 fn _type_assertion(
4978 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4979 ) {
4980 match _t {
4981 alloy_sol_types::private::AssertTypeEq::<
4982 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4983 >(_) => {}
4984 }
4985 }
4986 #[automatically_derived]
4987 #[doc(hidden)]
4988 impl ::core::convert::From<hashOperationReturn> for UnderlyingRustTuple<'_> {
4989 fn from(value: hashOperationReturn) -> Self {
4990 (value._0,)
4991 }
4992 }
4993 #[automatically_derived]
4994 #[doc(hidden)]
4995 impl ::core::convert::From<UnderlyingRustTuple<'_>> for hashOperationReturn {
4996 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4997 Self { _0: tuple.0 }
4998 }
4999 }
5000 }
5001 #[automatically_derived]
5002 impl alloy_sol_types::SolCall for hashOperationCall {
5003 type Parameters<'a> = (
5004 alloy::sol_types::sol_data::Address,
5005 alloy::sol_types::sol_data::Uint<256>,
5006 alloy::sol_types::sol_data::Bytes,
5007 alloy::sol_types::sol_data::FixedBytes<32>,
5008 alloy::sol_types::sol_data::FixedBytes<32>,
5009 );
5010 type Token<'a> = <Self::Parameters<
5011 'a,
5012 > as alloy_sol_types::SolType>::Token<'a>;
5013 type Return = hashOperationReturn;
5014 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5015 type ReturnToken<'a> = <Self::ReturnTuple<
5016 'a,
5017 > as alloy_sol_types::SolType>::Token<'a>;
5018 const SIGNATURE: &'static str = "hashOperation(address,uint256,bytes,bytes32,bytes32)";
5019 const SELECTOR: [u8; 4] = [128u8, 101u8, 101u8, 127u8];
5020 #[inline]
5021 fn new<'a>(
5022 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5023 ) -> Self {
5024 tuple.into()
5025 }
5026 #[inline]
5027 fn tokenize(&self) -> Self::Token<'_> {
5028 (
5029 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5030 &self.target,
5031 ),
5032 <alloy::sol_types::sol_data::Uint<
5033 256,
5034 > as alloy_sol_types::SolType>::tokenize(&self.value),
5035 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
5036 &self.data,
5037 ),
5038 <alloy::sol_types::sol_data::FixedBytes<
5039 32,
5040 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
5041 <alloy::sol_types::sol_data::FixedBytes<
5042 32,
5043 > as alloy_sol_types::SolType>::tokenize(&self.salt),
5044 )
5045 }
5046 #[inline]
5047 fn abi_decode_returns(
5048 data: &[u8],
5049 validate: bool,
5050 ) -> alloy_sol_types::Result<Self::Return> {
5051 <Self::ReturnTuple<
5052 '_,
5053 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5054 .map(Into::into)
5055 }
5056 }
5057 };
5058 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5059 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5064 #[derive(Clone)]
5065 pub struct hashOperationBatchCall {
5066 #[allow(missing_docs)]
5067 pub targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
5068 #[allow(missing_docs)]
5069 pub values: alloy::sol_types::private::Vec<
5070 alloy::sol_types::private::primitives::aliases::U256,
5071 >,
5072 #[allow(missing_docs)]
5073 pub payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
5074 #[allow(missing_docs)]
5075 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
5076 #[allow(missing_docs)]
5077 pub salt: alloy::sol_types::private::FixedBytes<32>,
5078 }
5079 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5080 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5082 #[derive(Clone)]
5083 pub struct hashOperationBatchReturn {
5084 #[allow(missing_docs)]
5085 pub _0: alloy::sol_types::private::FixedBytes<32>,
5086 }
5087 #[allow(
5088 non_camel_case_types,
5089 non_snake_case,
5090 clippy::pub_underscore_fields,
5091 clippy::style
5092 )]
5093 const _: () = {
5094 use alloy::sol_types as alloy_sol_types;
5095 {
5096 #[doc(hidden)]
5097 type UnderlyingSolTuple<'a> = (
5098 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5099 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
5100 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
5101 alloy::sol_types::sol_data::FixedBytes<32>,
5102 alloy::sol_types::sol_data::FixedBytes<32>,
5103 );
5104 #[doc(hidden)]
5105 type UnderlyingRustTuple<'a> = (
5106 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
5107 alloy::sol_types::private::Vec<
5108 alloy::sol_types::private::primitives::aliases::U256,
5109 >,
5110 alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
5111 alloy::sol_types::private::FixedBytes<32>,
5112 alloy::sol_types::private::FixedBytes<32>,
5113 );
5114 #[cfg(test)]
5115 #[allow(dead_code, unreachable_patterns)]
5116 fn _type_assertion(
5117 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5118 ) {
5119 match _t {
5120 alloy_sol_types::private::AssertTypeEq::<
5121 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5122 >(_) => {}
5123 }
5124 }
5125 #[automatically_derived]
5126 #[doc(hidden)]
5127 impl ::core::convert::From<hashOperationBatchCall>
5128 for UnderlyingRustTuple<'_> {
5129 fn from(value: hashOperationBatchCall) -> Self {
5130 (
5131 value.targets,
5132 value.values,
5133 value.payloads,
5134 value.predecessor,
5135 value.salt,
5136 )
5137 }
5138 }
5139 #[automatically_derived]
5140 #[doc(hidden)]
5141 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5142 for hashOperationBatchCall {
5143 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5144 Self {
5145 targets: tuple.0,
5146 values: tuple.1,
5147 payloads: tuple.2,
5148 predecessor: tuple.3,
5149 salt: tuple.4,
5150 }
5151 }
5152 }
5153 }
5154 {
5155 #[doc(hidden)]
5156 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5157 #[doc(hidden)]
5158 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
5159 #[cfg(test)]
5160 #[allow(dead_code, unreachable_patterns)]
5161 fn _type_assertion(
5162 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5163 ) {
5164 match _t {
5165 alloy_sol_types::private::AssertTypeEq::<
5166 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5167 >(_) => {}
5168 }
5169 }
5170 #[automatically_derived]
5171 #[doc(hidden)]
5172 impl ::core::convert::From<hashOperationBatchReturn>
5173 for UnderlyingRustTuple<'_> {
5174 fn from(value: hashOperationBatchReturn) -> Self {
5175 (value._0,)
5176 }
5177 }
5178 #[automatically_derived]
5179 #[doc(hidden)]
5180 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5181 for hashOperationBatchReturn {
5182 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5183 Self { _0: tuple.0 }
5184 }
5185 }
5186 }
5187 #[automatically_derived]
5188 impl alloy_sol_types::SolCall for hashOperationBatchCall {
5189 type Parameters<'a> = (
5190 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5191 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
5192 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
5193 alloy::sol_types::sol_data::FixedBytes<32>,
5194 alloy::sol_types::sol_data::FixedBytes<32>,
5195 );
5196 type Token<'a> = <Self::Parameters<
5197 'a,
5198 > as alloy_sol_types::SolType>::Token<'a>;
5199 type Return = hashOperationBatchReturn;
5200 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5201 type ReturnToken<'a> = <Self::ReturnTuple<
5202 'a,
5203 > as alloy_sol_types::SolType>::Token<'a>;
5204 const SIGNATURE: &'static str = "hashOperationBatch(address[],uint256[],bytes[],bytes32,bytes32)";
5205 const SELECTOR: [u8; 4] = [177u8, 197u8, 244u8, 39u8];
5206 #[inline]
5207 fn new<'a>(
5208 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5209 ) -> Self {
5210 tuple.into()
5211 }
5212 #[inline]
5213 fn tokenize(&self) -> Self::Token<'_> {
5214 (
5215 <alloy::sol_types::sol_data::Array<
5216 alloy::sol_types::sol_data::Address,
5217 > as alloy_sol_types::SolType>::tokenize(&self.targets),
5218 <alloy::sol_types::sol_data::Array<
5219 alloy::sol_types::sol_data::Uint<256>,
5220 > as alloy_sol_types::SolType>::tokenize(&self.values),
5221 <alloy::sol_types::sol_data::Array<
5222 alloy::sol_types::sol_data::Bytes,
5223 > as alloy_sol_types::SolType>::tokenize(&self.payloads),
5224 <alloy::sol_types::sol_data::FixedBytes<
5225 32,
5226 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
5227 <alloy::sol_types::sol_data::FixedBytes<
5228 32,
5229 > as alloy_sol_types::SolType>::tokenize(&self.salt),
5230 )
5231 }
5232 #[inline]
5233 fn abi_decode_returns(
5234 data: &[u8],
5235 validate: bool,
5236 ) -> alloy_sol_types::Result<Self::Return> {
5237 <Self::ReturnTuple<
5238 '_,
5239 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5240 .map(Into::into)
5241 }
5242 }
5243 };
5244 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5245 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5250 #[derive(Clone)]
5251 pub struct isOperationCall {
5252 #[allow(missing_docs)]
5253 pub id: alloy::sol_types::private::FixedBytes<32>,
5254 }
5255 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5256 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5258 #[derive(Clone)]
5259 pub struct isOperationReturn {
5260 #[allow(missing_docs)]
5261 pub _0: bool,
5262 }
5263 #[allow(
5264 non_camel_case_types,
5265 non_snake_case,
5266 clippy::pub_underscore_fields,
5267 clippy::style
5268 )]
5269 const _: () = {
5270 use alloy::sol_types as alloy_sol_types;
5271 {
5272 #[doc(hidden)]
5273 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5274 #[doc(hidden)]
5275 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
5276 #[cfg(test)]
5277 #[allow(dead_code, unreachable_patterns)]
5278 fn _type_assertion(
5279 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5280 ) {
5281 match _t {
5282 alloy_sol_types::private::AssertTypeEq::<
5283 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5284 >(_) => {}
5285 }
5286 }
5287 #[automatically_derived]
5288 #[doc(hidden)]
5289 impl ::core::convert::From<isOperationCall> for UnderlyingRustTuple<'_> {
5290 fn from(value: isOperationCall) -> Self {
5291 (value.id,)
5292 }
5293 }
5294 #[automatically_derived]
5295 #[doc(hidden)]
5296 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOperationCall {
5297 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5298 Self { id: tuple.0 }
5299 }
5300 }
5301 }
5302 {
5303 #[doc(hidden)]
5304 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5305 #[doc(hidden)]
5306 type UnderlyingRustTuple<'a> = (bool,);
5307 #[cfg(test)]
5308 #[allow(dead_code, unreachable_patterns)]
5309 fn _type_assertion(
5310 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5311 ) {
5312 match _t {
5313 alloy_sol_types::private::AssertTypeEq::<
5314 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5315 >(_) => {}
5316 }
5317 }
5318 #[automatically_derived]
5319 #[doc(hidden)]
5320 impl ::core::convert::From<isOperationReturn> for UnderlyingRustTuple<'_> {
5321 fn from(value: isOperationReturn) -> Self {
5322 (value._0,)
5323 }
5324 }
5325 #[automatically_derived]
5326 #[doc(hidden)]
5327 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOperationReturn {
5328 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5329 Self { _0: tuple.0 }
5330 }
5331 }
5332 }
5333 #[automatically_derived]
5334 impl alloy_sol_types::SolCall for isOperationCall {
5335 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5336 type Token<'a> = <Self::Parameters<
5337 'a,
5338 > as alloy_sol_types::SolType>::Token<'a>;
5339 type Return = isOperationReturn;
5340 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5341 type ReturnToken<'a> = <Self::ReturnTuple<
5342 'a,
5343 > as alloy_sol_types::SolType>::Token<'a>;
5344 const SIGNATURE: &'static str = "isOperation(bytes32)";
5345 const SELECTOR: [u8; 4] = [49u8, 213u8, 7u8, 80u8];
5346 #[inline]
5347 fn new<'a>(
5348 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5349 ) -> Self {
5350 tuple.into()
5351 }
5352 #[inline]
5353 fn tokenize(&self) -> Self::Token<'_> {
5354 (
5355 <alloy::sol_types::sol_data::FixedBytes<
5356 32,
5357 > as alloy_sol_types::SolType>::tokenize(&self.id),
5358 )
5359 }
5360 #[inline]
5361 fn abi_decode_returns(
5362 data: &[u8],
5363 validate: bool,
5364 ) -> alloy_sol_types::Result<Self::Return> {
5365 <Self::ReturnTuple<
5366 '_,
5367 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5368 .map(Into::into)
5369 }
5370 }
5371 };
5372 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5373 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5378 #[derive(Clone)]
5379 pub struct isOperationDoneCall {
5380 #[allow(missing_docs)]
5381 pub id: alloy::sol_types::private::FixedBytes<32>,
5382 }
5383 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5384 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5386 #[derive(Clone)]
5387 pub struct isOperationDoneReturn {
5388 #[allow(missing_docs)]
5389 pub _0: bool,
5390 }
5391 #[allow(
5392 non_camel_case_types,
5393 non_snake_case,
5394 clippy::pub_underscore_fields,
5395 clippy::style
5396 )]
5397 const _: () = {
5398 use alloy::sol_types as alloy_sol_types;
5399 {
5400 #[doc(hidden)]
5401 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5402 #[doc(hidden)]
5403 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
5404 #[cfg(test)]
5405 #[allow(dead_code, unreachable_patterns)]
5406 fn _type_assertion(
5407 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5408 ) {
5409 match _t {
5410 alloy_sol_types::private::AssertTypeEq::<
5411 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5412 >(_) => {}
5413 }
5414 }
5415 #[automatically_derived]
5416 #[doc(hidden)]
5417 impl ::core::convert::From<isOperationDoneCall> for UnderlyingRustTuple<'_> {
5418 fn from(value: isOperationDoneCall) -> Self {
5419 (value.id,)
5420 }
5421 }
5422 #[automatically_derived]
5423 #[doc(hidden)]
5424 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOperationDoneCall {
5425 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5426 Self { id: tuple.0 }
5427 }
5428 }
5429 }
5430 {
5431 #[doc(hidden)]
5432 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5433 #[doc(hidden)]
5434 type UnderlyingRustTuple<'a> = (bool,);
5435 #[cfg(test)]
5436 #[allow(dead_code, unreachable_patterns)]
5437 fn _type_assertion(
5438 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5439 ) {
5440 match _t {
5441 alloy_sol_types::private::AssertTypeEq::<
5442 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5443 >(_) => {}
5444 }
5445 }
5446 #[automatically_derived]
5447 #[doc(hidden)]
5448 impl ::core::convert::From<isOperationDoneReturn>
5449 for UnderlyingRustTuple<'_> {
5450 fn from(value: isOperationDoneReturn) -> Self {
5451 (value._0,)
5452 }
5453 }
5454 #[automatically_derived]
5455 #[doc(hidden)]
5456 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5457 for isOperationDoneReturn {
5458 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5459 Self { _0: tuple.0 }
5460 }
5461 }
5462 }
5463 #[automatically_derived]
5464 impl alloy_sol_types::SolCall for isOperationDoneCall {
5465 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5466 type Token<'a> = <Self::Parameters<
5467 'a,
5468 > as alloy_sol_types::SolType>::Token<'a>;
5469 type Return = isOperationDoneReturn;
5470 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5471 type ReturnToken<'a> = <Self::ReturnTuple<
5472 'a,
5473 > as alloy_sol_types::SolType>::Token<'a>;
5474 const SIGNATURE: &'static str = "isOperationDone(bytes32)";
5475 const SELECTOR: [u8; 4] = [42u8, 176u8, 245u8, 41u8];
5476 #[inline]
5477 fn new<'a>(
5478 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5479 ) -> Self {
5480 tuple.into()
5481 }
5482 #[inline]
5483 fn tokenize(&self) -> Self::Token<'_> {
5484 (
5485 <alloy::sol_types::sol_data::FixedBytes<
5486 32,
5487 > as alloy_sol_types::SolType>::tokenize(&self.id),
5488 )
5489 }
5490 #[inline]
5491 fn abi_decode_returns(
5492 data: &[u8],
5493 validate: bool,
5494 ) -> alloy_sol_types::Result<Self::Return> {
5495 <Self::ReturnTuple<
5496 '_,
5497 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5498 .map(Into::into)
5499 }
5500 }
5501 };
5502 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5503 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5508 #[derive(Clone)]
5509 pub struct isOperationPendingCall {
5510 #[allow(missing_docs)]
5511 pub id: alloy::sol_types::private::FixedBytes<32>,
5512 }
5513 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5514 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5516 #[derive(Clone)]
5517 pub struct isOperationPendingReturn {
5518 #[allow(missing_docs)]
5519 pub _0: bool,
5520 }
5521 #[allow(
5522 non_camel_case_types,
5523 non_snake_case,
5524 clippy::pub_underscore_fields,
5525 clippy::style
5526 )]
5527 const _: () = {
5528 use alloy::sol_types as alloy_sol_types;
5529 {
5530 #[doc(hidden)]
5531 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5532 #[doc(hidden)]
5533 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
5534 #[cfg(test)]
5535 #[allow(dead_code, unreachable_patterns)]
5536 fn _type_assertion(
5537 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5538 ) {
5539 match _t {
5540 alloy_sol_types::private::AssertTypeEq::<
5541 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5542 >(_) => {}
5543 }
5544 }
5545 #[automatically_derived]
5546 #[doc(hidden)]
5547 impl ::core::convert::From<isOperationPendingCall>
5548 for UnderlyingRustTuple<'_> {
5549 fn from(value: isOperationPendingCall) -> Self {
5550 (value.id,)
5551 }
5552 }
5553 #[automatically_derived]
5554 #[doc(hidden)]
5555 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5556 for isOperationPendingCall {
5557 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5558 Self { id: tuple.0 }
5559 }
5560 }
5561 }
5562 {
5563 #[doc(hidden)]
5564 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5565 #[doc(hidden)]
5566 type UnderlyingRustTuple<'a> = (bool,);
5567 #[cfg(test)]
5568 #[allow(dead_code, unreachable_patterns)]
5569 fn _type_assertion(
5570 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5571 ) {
5572 match _t {
5573 alloy_sol_types::private::AssertTypeEq::<
5574 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5575 >(_) => {}
5576 }
5577 }
5578 #[automatically_derived]
5579 #[doc(hidden)]
5580 impl ::core::convert::From<isOperationPendingReturn>
5581 for UnderlyingRustTuple<'_> {
5582 fn from(value: isOperationPendingReturn) -> Self {
5583 (value._0,)
5584 }
5585 }
5586 #[automatically_derived]
5587 #[doc(hidden)]
5588 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5589 for isOperationPendingReturn {
5590 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5591 Self { _0: tuple.0 }
5592 }
5593 }
5594 }
5595 #[automatically_derived]
5596 impl alloy_sol_types::SolCall for isOperationPendingCall {
5597 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5598 type Token<'a> = <Self::Parameters<
5599 'a,
5600 > as alloy_sol_types::SolType>::Token<'a>;
5601 type Return = isOperationPendingReturn;
5602 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5603 type ReturnToken<'a> = <Self::ReturnTuple<
5604 'a,
5605 > as alloy_sol_types::SolType>::Token<'a>;
5606 const SIGNATURE: &'static str = "isOperationPending(bytes32)";
5607 const SELECTOR: [u8; 4] = [88u8, 75u8, 21u8, 62u8];
5608 #[inline]
5609 fn new<'a>(
5610 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5611 ) -> Self {
5612 tuple.into()
5613 }
5614 #[inline]
5615 fn tokenize(&self) -> Self::Token<'_> {
5616 (
5617 <alloy::sol_types::sol_data::FixedBytes<
5618 32,
5619 > as alloy_sol_types::SolType>::tokenize(&self.id),
5620 )
5621 }
5622 #[inline]
5623 fn abi_decode_returns(
5624 data: &[u8],
5625 validate: bool,
5626 ) -> alloy_sol_types::Result<Self::Return> {
5627 <Self::ReturnTuple<
5628 '_,
5629 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5630 .map(Into::into)
5631 }
5632 }
5633 };
5634 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5635 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5640 #[derive(Clone)]
5641 pub struct isOperationReadyCall {
5642 #[allow(missing_docs)]
5643 pub id: alloy::sol_types::private::FixedBytes<32>,
5644 }
5645 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5646 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5648 #[derive(Clone)]
5649 pub struct isOperationReadyReturn {
5650 #[allow(missing_docs)]
5651 pub _0: bool,
5652 }
5653 #[allow(
5654 non_camel_case_types,
5655 non_snake_case,
5656 clippy::pub_underscore_fields,
5657 clippy::style
5658 )]
5659 const _: () = {
5660 use alloy::sol_types as alloy_sol_types;
5661 {
5662 #[doc(hidden)]
5663 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5664 #[doc(hidden)]
5665 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
5666 #[cfg(test)]
5667 #[allow(dead_code, unreachable_patterns)]
5668 fn _type_assertion(
5669 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5670 ) {
5671 match _t {
5672 alloy_sol_types::private::AssertTypeEq::<
5673 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5674 >(_) => {}
5675 }
5676 }
5677 #[automatically_derived]
5678 #[doc(hidden)]
5679 impl ::core::convert::From<isOperationReadyCall>
5680 for UnderlyingRustTuple<'_> {
5681 fn from(value: isOperationReadyCall) -> Self {
5682 (value.id,)
5683 }
5684 }
5685 #[automatically_derived]
5686 #[doc(hidden)]
5687 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5688 for isOperationReadyCall {
5689 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5690 Self { id: tuple.0 }
5691 }
5692 }
5693 }
5694 {
5695 #[doc(hidden)]
5696 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5697 #[doc(hidden)]
5698 type UnderlyingRustTuple<'a> = (bool,);
5699 #[cfg(test)]
5700 #[allow(dead_code, unreachable_patterns)]
5701 fn _type_assertion(
5702 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5703 ) {
5704 match _t {
5705 alloy_sol_types::private::AssertTypeEq::<
5706 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5707 >(_) => {}
5708 }
5709 }
5710 #[automatically_derived]
5711 #[doc(hidden)]
5712 impl ::core::convert::From<isOperationReadyReturn>
5713 for UnderlyingRustTuple<'_> {
5714 fn from(value: isOperationReadyReturn) -> Self {
5715 (value._0,)
5716 }
5717 }
5718 #[automatically_derived]
5719 #[doc(hidden)]
5720 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5721 for isOperationReadyReturn {
5722 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5723 Self { _0: tuple.0 }
5724 }
5725 }
5726 }
5727 #[automatically_derived]
5728 impl alloy_sol_types::SolCall for isOperationReadyCall {
5729 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
5730 type Token<'a> = <Self::Parameters<
5731 'a,
5732 > as alloy_sol_types::SolType>::Token<'a>;
5733 type Return = isOperationReadyReturn;
5734 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
5735 type ReturnToken<'a> = <Self::ReturnTuple<
5736 'a,
5737 > as alloy_sol_types::SolType>::Token<'a>;
5738 const SIGNATURE: &'static str = "isOperationReady(bytes32)";
5739 const SELECTOR: [u8; 4] = [19u8, 188u8, 159u8, 32u8];
5740 #[inline]
5741 fn new<'a>(
5742 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5743 ) -> Self {
5744 tuple.into()
5745 }
5746 #[inline]
5747 fn tokenize(&self) -> Self::Token<'_> {
5748 (
5749 <alloy::sol_types::sol_data::FixedBytes<
5750 32,
5751 > as alloy_sol_types::SolType>::tokenize(&self.id),
5752 )
5753 }
5754 #[inline]
5755 fn abi_decode_returns(
5756 data: &[u8],
5757 validate: bool,
5758 ) -> alloy_sol_types::Result<Self::Return> {
5759 <Self::ReturnTuple<
5760 '_,
5761 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5762 .map(Into::into)
5763 }
5764 }
5765 };
5766 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5767 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5772 #[derive(Clone)]
5773 pub struct onERC1155BatchReceivedCall {
5774 #[allow(missing_docs)]
5775 pub _0: alloy::sol_types::private::Address,
5776 #[allow(missing_docs)]
5777 pub _1: alloy::sol_types::private::Address,
5778 #[allow(missing_docs)]
5779 pub _2: alloy::sol_types::private::Vec<
5780 alloy::sol_types::private::primitives::aliases::U256,
5781 >,
5782 #[allow(missing_docs)]
5783 pub _3: alloy::sol_types::private::Vec<
5784 alloy::sol_types::private::primitives::aliases::U256,
5785 >,
5786 #[allow(missing_docs)]
5787 pub _4: alloy::sol_types::private::Bytes,
5788 }
5789 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5790 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5792 #[derive(Clone)]
5793 pub struct onERC1155BatchReceivedReturn {
5794 #[allow(missing_docs)]
5795 pub _0: alloy::sol_types::private::FixedBytes<4>,
5796 }
5797 #[allow(
5798 non_camel_case_types,
5799 non_snake_case,
5800 clippy::pub_underscore_fields,
5801 clippy::style
5802 )]
5803 const _: () = {
5804 use alloy::sol_types as alloy_sol_types;
5805 {
5806 #[doc(hidden)]
5807 type UnderlyingSolTuple<'a> = (
5808 alloy::sol_types::sol_data::Address,
5809 alloy::sol_types::sol_data::Address,
5810 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
5811 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
5812 alloy::sol_types::sol_data::Bytes,
5813 );
5814 #[doc(hidden)]
5815 type UnderlyingRustTuple<'a> = (
5816 alloy::sol_types::private::Address,
5817 alloy::sol_types::private::Address,
5818 alloy::sol_types::private::Vec<
5819 alloy::sol_types::private::primitives::aliases::U256,
5820 >,
5821 alloy::sol_types::private::Vec<
5822 alloy::sol_types::private::primitives::aliases::U256,
5823 >,
5824 alloy::sol_types::private::Bytes,
5825 );
5826 #[cfg(test)]
5827 #[allow(dead_code, unreachable_patterns)]
5828 fn _type_assertion(
5829 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
5830 ) {
5831 match _t {
5832 alloy_sol_types::private::AssertTypeEq::<
5833 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5834 >(_) => {}
5835 }
5836 }
5837 #[automatically_derived]
5838 #[doc(hidden)]
5839 impl ::core::convert::From<onERC1155BatchReceivedCall>
5840 for UnderlyingRustTuple<'_> {
5841 fn from(value: onERC1155BatchReceivedCall) -> Self {
5842 (value._0, value._1, value._2, value._3, value._4)
5843 }
5844 }
5845 #[automatically_derived]
5846 #[doc(hidden)]
5847 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5848 for onERC1155BatchReceivedCall {
5849 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5850 Self {
5851 _0: tuple.0,
5852 _1: tuple.1,
5853 _2: tuple.2,
5854 _3: tuple.3,
5855 _4: tuple.4,
5856 }
5857 }
5858 }
5859 }
5860 {
5861 #[doc(hidden)]
5862 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
5863 #[doc(hidden)]
5864 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
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<onERC1155BatchReceivedReturn>
5879 for UnderlyingRustTuple<'_> {
5880 fn from(value: onERC1155BatchReceivedReturn) -> Self {
5881 (value._0,)
5882 }
5883 }
5884 #[automatically_derived]
5885 #[doc(hidden)]
5886 impl ::core::convert::From<UnderlyingRustTuple<'_>>
5887 for onERC1155BatchReceivedReturn {
5888 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5889 Self { _0: tuple.0 }
5890 }
5891 }
5892 }
5893 #[automatically_derived]
5894 impl alloy_sol_types::SolCall for onERC1155BatchReceivedCall {
5895 type Parameters<'a> = (
5896 alloy::sol_types::sol_data::Address,
5897 alloy::sol_types::sol_data::Address,
5898 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
5899 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
5900 alloy::sol_types::sol_data::Bytes,
5901 );
5902 type Token<'a> = <Self::Parameters<
5903 'a,
5904 > as alloy_sol_types::SolType>::Token<'a>;
5905 type Return = onERC1155BatchReceivedReturn;
5906 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
5907 type ReturnToken<'a> = <Self::ReturnTuple<
5908 'a,
5909 > as alloy_sol_types::SolType>::Token<'a>;
5910 const SIGNATURE: &'static str = "onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)";
5911 const SELECTOR: [u8; 4] = [188u8, 25u8, 124u8, 129u8];
5912 #[inline]
5913 fn new<'a>(
5914 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5915 ) -> Self {
5916 tuple.into()
5917 }
5918 #[inline]
5919 fn tokenize(&self) -> Self::Token<'_> {
5920 (
5921 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5922 &self._0,
5923 ),
5924 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5925 &self._1,
5926 ),
5927 <alloy::sol_types::sol_data::Array<
5928 alloy::sol_types::sol_data::Uint<256>,
5929 > as alloy_sol_types::SolType>::tokenize(&self._2),
5930 <alloy::sol_types::sol_data::Array<
5931 alloy::sol_types::sol_data::Uint<256>,
5932 > as alloy_sol_types::SolType>::tokenize(&self._3),
5933 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
5934 &self._4,
5935 ),
5936 )
5937 }
5938 #[inline]
5939 fn abi_decode_returns(
5940 data: &[u8],
5941 validate: bool,
5942 ) -> alloy_sol_types::Result<Self::Return> {
5943 <Self::ReturnTuple<
5944 '_,
5945 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
5946 .map(Into::into)
5947 }
5948 }
5949 };
5950 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5951 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5956 #[derive(Clone)]
5957 pub struct onERC1155ReceivedCall {
5958 #[allow(missing_docs)]
5959 pub _0: alloy::sol_types::private::Address,
5960 #[allow(missing_docs)]
5961 pub _1: alloy::sol_types::private::Address,
5962 #[allow(missing_docs)]
5963 pub _2: alloy::sol_types::private::primitives::aliases::U256,
5964 #[allow(missing_docs)]
5965 pub _3: alloy::sol_types::private::primitives::aliases::U256,
5966 #[allow(missing_docs)]
5967 pub _4: alloy::sol_types::private::Bytes,
5968 }
5969 #[derive(Default, Debug, PartialEq, Eq, Hash)]
5970 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5972 #[derive(Clone)]
5973 pub struct onERC1155ReceivedReturn {
5974 #[allow(missing_docs)]
5975 pub _0: alloy::sol_types::private::FixedBytes<4>,
5976 }
5977 #[allow(
5978 non_camel_case_types,
5979 non_snake_case,
5980 clippy::pub_underscore_fields,
5981 clippy::style
5982 )]
5983 const _: () = {
5984 use alloy::sol_types as alloy_sol_types;
5985 {
5986 #[doc(hidden)]
5987 type UnderlyingSolTuple<'a> = (
5988 alloy::sol_types::sol_data::Address,
5989 alloy::sol_types::sol_data::Address,
5990 alloy::sol_types::sol_data::Uint<256>,
5991 alloy::sol_types::sol_data::Uint<256>,
5992 alloy::sol_types::sol_data::Bytes,
5993 );
5994 #[doc(hidden)]
5995 type UnderlyingRustTuple<'a> = (
5996 alloy::sol_types::private::Address,
5997 alloy::sol_types::private::Address,
5998 alloy::sol_types::private::primitives::aliases::U256,
5999 alloy::sol_types::private::primitives::aliases::U256,
6000 alloy::sol_types::private::Bytes,
6001 );
6002 #[cfg(test)]
6003 #[allow(dead_code, unreachable_patterns)]
6004 fn _type_assertion(
6005 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6006 ) {
6007 match _t {
6008 alloy_sol_types::private::AssertTypeEq::<
6009 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6010 >(_) => {}
6011 }
6012 }
6013 #[automatically_derived]
6014 #[doc(hidden)]
6015 impl ::core::convert::From<onERC1155ReceivedCall>
6016 for UnderlyingRustTuple<'_> {
6017 fn from(value: onERC1155ReceivedCall) -> Self {
6018 (value._0, value._1, value._2, value._3, value._4)
6019 }
6020 }
6021 #[automatically_derived]
6022 #[doc(hidden)]
6023 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6024 for onERC1155ReceivedCall {
6025 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6026 Self {
6027 _0: tuple.0,
6028 _1: tuple.1,
6029 _2: tuple.2,
6030 _3: tuple.3,
6031 _4: tuple.4,
6032 }
6033 }
6034 }
6035 }
6036 {
6037 #[doc(hidden)]
6038 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6039 #[doc(hidden)]
6040 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
6041 #[cfg(test)]
6042 #[allow(dead_code, unreachable_patterns)]
6043 fn _type_assertion(
6044 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6045 ) {
6046 match _t {
6047 alloy_sol_types::private::AssertTypeEq::<
6048 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6049 >(_) => {}
6050 }
6051 }
6052 #[automatically_derived]
6053 #[doc(hidden)]
6054 impl ::core::convert::From<onERC1155ReceivedReturn>
6055 for UnderlyingRustTuple<'_> {
6056 fn from(value: onERC1155ReceivedReturn) -> Self {
6057 (value._0,)
6058 }
6059 }
6060 #[automatically_derived]
6061 #[doc(hidden)]
6062 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6063 for onERC1155ReceivedReturn {
6064 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6065 Self { _0: tuple.0 }
6066 }
6067 }
6068 }
6069 #[automatically_derived]
6070 impl alloy_sol_types::SolCall for onERC1155ReceivedCall {
6071 type Parameters<'a> = (
6072 alloy::sol_types::sol_data::Address,
6073 alloy::sol_types::sol_data::Address,
6074 alloy::sol_types::sol_data::Uint<256>,
6075 alloy::sol_types::sol_data::Uint<256>,
6076 alloy::sol_types::sol_data::Bytes,
6077 );
6078 type Token<'a> = <Self::Parameters<
6079 'a,
6080 > as alloy_sol_types::SolType>::Token<'a>;
6081 type Return = onERC1155ReceivedReturn;
6082 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6083 type ReturnToken<'a> = <Self::ReturnTuple<
6084 'a,
6085 > as alloy_sol_types::SolType>::Token<'a>;
6086 const SIGNATURE: &'static str = "onERC1155Received(address,address,uint256,uint256,bytes)";
6087 const SELECTOR: [u8; 4] = [242u8, 58u8, 110u8, 97u8];
6088 #[inline]
6089 fn new<'a>(
6090 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6091 ) -> Self {
6092 tuple.into()
6093 }
6094 #[inline]
6095 fn tokenize(&self) -> Self::Token<'_> {
6096 (
6097 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6098 &self._0,
6099 ),
6100 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6101 &self._1,
6102 ),
6103 <alloy::sol_types::sol_data::Uint<
6104 256,
6105 > as alloy_sol_types::SolType>::tokenize(&self._2),
6106 <alloy::sol_types::sol_data::Uint<
6107 256,
6108 > as alloy_sol_types::SolType>::tokenize(&self._3),
6109 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
6110 &self._4,
6111 ),
6112 )
6113 }
6114 #[inline]
6115 fn abi_decode_returns(
6116 data: &[u8],
6117 validate: bool,
6118 ) -> alloy_sol_types::Result<Self::Return> {
6119 <Self::ReturnTuple<
6120 '_,
6121 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6122 .map(Into::into)
6123 }
6124 }
6125 };
6126 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6127 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6132 #[derive(Clone)]
6133 pub struct onERC721ReceivedCall {
6134 #[allow(missing_docs)]
6135 pub _0: alloy::sol_types::private::Address,
6136 #[allow(missing_docs)]
6137 pub _1: alloy::sol_types::private::Address,
6138 #[allow(missing_docs)]
6139 pub _2: alloy::sol_types::private::primitives::aliases::U256,
6140 #[allow(missing_docs)]
6141 pub _3: alloy::sol_types::private::Bytes,
6142 }
6143 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6144 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6146 #[derive(Clone)]
6147 pub struct onERC721ReceivedReturn {
6148 #[allow(missing_docs)]
6149 pub _0: alloy::sol_types::private::FixedBytes<4>,
6150 }
6151 #[allow(
6152 non_camel_case_types,
6153 non_snake_case,
6154 clippy::pub_underscore_fields,
6155 clippy::style
6156 )]
6157 const _: () = {
6158 use alloy::sol_types as alloy_sol_types;
6159 {
6160 #[doc(hidden)]
6161 type UnderlyingSolTuple<'a> = (
6162 alloy::sol_types::sol_data::Address,
6163 alloy::sol_types::sol_data::Address,
6164 alloy::sol_types::sol_data::Uint<256>,
6165 alloy::sol_types::sol_data::Bytes,
6166 );
6167 #[doc(hidden)]
6168 type UnderlyingRustTuple<'a> = (
6169 alloy::sol_types::private::Address,
6170 alloy::sol_types::private::Address,
6171 alloy::sol_types::private::primitives::aliases::U256,
6172 alloy::sol_types::private::Bytes,
6173 );
6174 #[cfg(test)]
6175 #[allow(dead_code, unreachable_patterns)]
6176 fn _type_assertion(
6177 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6178 ) {
6179 match _t {
6180 alloy_sol_types::private::AssertTypeEq::<
6181 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6182 >(_) => {}
6183 }
6184 }
6185 #[automatically_derived]
6186 #[doc(hidden)]
6187 impl ::core::convert::From<onERC721ReceivedCall>
6188 for UnderlyingRustTuple<'_> {
6189 fn from(value: onERC721ReceivedCall) -> Self {
6190 (value._0, value._1, value._2, value._3)
6191 }
6192 }
6193 #[automatically_derived]
6194 #[doc(hidden)]
6195 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6196 for onERC721ReceivedCall {
6197 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6198 Self {
6199 _0: tuple.0,
6200 _1: tuple.1,
6201 _2: tuple.2,
6202 _3: tuple.3,
6203 }
6204 }
6205 }
6206 }
6207 {
6208 #[doc(hidden)]
6209 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6210 #[doc(hidden)]
6211 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
6212 #[cfg(test)]
6213 #[allow(dead_code, unreachable_patterns)]
6214 fn _type_assertion(
6215 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6216 ) {
6217 match _t {
6218 alloy_sol_types::private::AssertTypeEq::<
6219 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6220 >(_) => {}
6221 }
6222 }
6223 #[automatically_derived]
6224 #[doc(hidden)]
6225 impl ::core::convert::From<onERC721ReceivedReturn>
6226 for UnderlyingRustTuple<'_> {
6227 fn from(value: onERC721ReceivedReturn) -> Self {
6228 (value._0,)
6229 }
6230 }
6231 #[automatically_derived]
6232 #[doc(hidden)]
6233 impl ::core::convert::From<UnderlyingRustTuple<'_>>
6234 for onERC721ReceivedReturn {
6235 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6236 Self { _0: tuple.0 }
6237 }
6238 }
6239 }
6240 #[automatically_derived]
6241 impl alloy_sol_types::SolCall for onERC721ReceivedCall {
6242 type Parameters<'a> = (
6243 alloy::sol_types::sol_data::Address,
6244 alloy::sol_types::sol_data::Address,
6245 alloy::sol_types::sol_data::Uint<256>,
6246 alloy::sol_types::sol_data::Bytes,
6247 );
6248 type Token<'a> = <Self::Parameters<
6249 'a,
6250 > as alloy_sol_types::SolType>::Token<'a>;
6251 type Return = onERC721ReceivedReturn;
6252 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6253 type ReturnToken<'a> = <Self::ReturnTuple<
6254 'a,
6255 > as alloy_sol_types::SolType>::Token<'a>;
6256 const SIGNATURE: &'static str = "onERC721Received(address,address,uint256,bytes)";
6257 const SELECTOR: [u8; 4] = [21u8, 11u8, 122u8, 2u8];
6258 #[inline]
6259 fn new<'a>(
6260 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6261 ) -> Self {
6262 tuple.into()
6263 }
6264 #[inline]
6265 fn tokenize(&self) -> Self::Token<'_> {
6266 (
6267 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6268 &self._0,
6269 ),
6270 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6271 &self._1,
6272 ),
6273 <alloy::sol_types::sol_data::Uint<
6274 256,
6275 > as alloy_sol_types::SolType>::tokenize(&self._2),
6276 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
6277 &self._3,
6278 ),
6279 )
6280 }
6281 #[inline]
6282 fn abi_decode_returns(
6283 data: &[u8],
6284 validate: bool,
6285 ) -> alloy_sol_types::Result<Self::Return> {
6286 <Self::ReturnTuple<
6287 '_,
6288 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6289 .map(Into::into)
6290 }
6291 }
6292 };
6293 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6294 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6299 #[derive(Clone)]
6300 pub struct renounceRoleCall {
6301 #[allow(missing_docs)]
6302 pub role: alloy::sol_types::private::FixedBytes<32>,
6303 #[allow(missing_docs)]
6304 pub callerConfirmation: alloy::sol_types::private::Address,
6305 }
6306 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6308 #[derive(Clone)]
6309 pub struct renounceRoleReturn {}
6310 #[allow(
6311 non_camel_case_types,
6312 non_snake_case,
6313 clippy::pub_underscore_fields,
6314 clippy::style
6315 )]
6316 const _: () = {
6317 use alloy::sol_types as alloy_sol_types;
6318 {
6319 #[doc(hidden)]
6320 type UnderlyingSolTuple<'a> = (
6321 alloy::sol_types::sol_data::FixedBytes<32>,
6322 alloy::sol_types::sol_data::Address,
6323 );
6324 #[doc(hidden)]
6325 type UnderlyingRustTuple<'a> = (
6326 alloy::sol_types::private::FixedBytes<32>,
6327 alloy::sol_types::private::Address,
6328 );
6329 #[cfg(test)]
6330 #[allow(dead_code, unreachable_patterns)]
6331 fn _type_assertion(
6332 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6333 ) {
6334 match _t {
6335 alloy_sol_types::private::AssertTypeEq::<
6336 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6337 >(_) => {}
6338 }
6339 }
6340 #[automatically_derived]
6341 #[doc(hidden)]
6342 impl ::core::convert::From<renounceRoleCall> for UnderlyingRustTuple<'_> {
6343 fn from(value: renounceRoleCall) -> Self {
6344 (value.role, value.callerConfirmation)
6345 }
6346 }
6347 #[automatically_derived]
6348 #[doc(hidden)]
6349 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleCall {
6350 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6351 Self {
6352 role: tuple.0,
6353 callerConfirmation: tuple.1,
6354 }
6355 }
6356 }
6357 }
6358 {
6359 #[doc(hidden)]
6360 type UnderlyingSolTuple<'a> = ();
6361 #[doc(hidden)]
6362 type UnderlyingRustTuple<'a> = ();
6363 #[cfg(test)]
6364 #[allow(dead_code, unreachable_patterns)]
6365 fn _type_assertion(
6366 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6367 ) {
6368 match _t {
6369 alloy_sol_types::private::AssertTypeEq::<
6370 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6371 >(_) => {}
6372 }
6373 }
6374 #[automatically_derived]
6375 #[doc(hidden)]
6376 impl ::core::convert::From<renounceRoleReturn> for UnderlyingRustTuple<'_> {
6377 fn from(value: renounceRoleReturn) -> Self {
6378 ()
6379 }
6380 }
6381 #[automatically_derived]
6382 #[doc(hidden)]
6383 impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceRoleReturn {
6384 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6385 Self {}
6386 }
6387 }
6388 }
6389 #[automatically_derived]
6390 impl alloy_sol_types::SolCall for renounceRoleCall {
6391 type Parameters<'a> = (
6392 alloy::sol_types::sol_data::FixedBytes<32>,
6393 alloy::sol_types::sol_data::Address,
6394 );
6395 type Token<'a> = <Self::Parameters<
6396 'a,
6397 > as alloy_sol_types::SolType>::Token<'a>;
6398 type Return = renounceRoleReturn;
6399 type ReturnTuple<'a> = ();
6400 type ReturnToken<'a> = <Self::ReturnTuple<
6401 'a,
6402 > as alloy_sol_types::SolType>::Token<'a>;
6403 const SIGNATURE: &'static str = "renounceRole(bytes32,address)";
6404 const SELECTOR: [u8; 4] = [54u8, 86u8, 138u8, 190u8];
6405 #[inline]
6406 fn new<'a>(
6407 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6408 ) -> Self {
6409 tuple.into()
6410 }
6411 #[inline]
6412 fn tokenize(&self) -> Self::Token<'_> {
6413 (
6414 <alloy::sol_types::sol_data::FixedBytes<
6415 32,
6416 > as alloy_sol_types::SolType>::tokenize(&self.role),
6417 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6418 &self.callerConfirmation,
6419 ),
6420 )
6421 }
6422 #[inline]
6423 fn abi_decode_returns(
6424 data: &[u8],
6425 validate: bool,
6426 ) -> alloy_sol_types::Result<Self::Return> {
6427 <Self::ReturnTuple<
6428 '_,
6429 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6430 .map(Into::into)
6431 }
6432 }
6433 };
6434 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6435 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6440 #[derive(Clone)]
6441 pub struct revokeRoleCall {
6442 #[allow(missing_docs)]
6443 pub role: alloy::sol_types::private::FixedBytes<32>,
6444 #[allow(missing_docs)]
6445 pub account: alloy::sol_types::private::Address,
6446 }
6447 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6449 #[derive(Clone)]
6450 pub struct revokeRoleReturn {}
6451 #[allow(
6452 non_camel_case_types,
6453 non_snake_case,
6454 clippy::pub_underscore_fields,
6455 clippy::style
6456 )]
6457 const _: () = {
6458 use alloy::sol_types as alloy_sol_types;
6459 {
6460 #[doc(hidden)]
6461 type UnderlyingSolTuple<'a> = (
6462 alloy::sol_types::sol_data::FixedBytes<32>,
6463 alloy::sol_types::sol_data::Address,
6464 );
6465 #[doc(hidden)]
6466 type UnderlyingRustTuple<'a> = (
6467 alloy::sol_types::private::FixedBytes<32>,
6468 alloy::sol_types::private::Address,
6469 );
6470 #[cfg(test)]
6471 #[allow(dead_code, unreachable_patterns)]
6472 fn _type_assertion(
6473 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6474 ) {
6475 match _t {
6476 alloy_sol_types::private::AssertTypeEq::<
6477 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6478 >(_) => {}
6479 }
6480 }
6481 #[automatically_derived]
6482 #[doc(hidden)]
6483 impl ::core::convert::From<revokeRoleCall> for UnderlyingRustTuple<'_> {
6484 fn from(value: revokeRoleCall) -> Self {
6485 (value.role, value.account)
6486 }
6487 }
6488 #[automatically_derived]
6489 #[doc(hidden)]
6490 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleCall {
6491 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6492 Self {
6493 role: tuple.0,
6494 account: tuple.1,
6495 }
6496 }
6497 }
6498 }
6499 {
6500 #[doc(hidden)]
6501 type UnderlyingSolTuple<'a> = ();
6502 #[doc(hidden)]
6503 type UnderlyingRustTuple<'a> = ();
6504 #[cfg(test)]
6505 #[allow(dead_code, unreachable_patterns)]
6506 fn _type_assertion(
6507 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6508 ) {
6509 match _t {
6510 alloy_sol_types::private::AssertTypeEq::<
6511 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6512 >(_) => {}
6513 }
6514 }
6515 #[automatically_derived]
6516 #[doc(hidden)]
6517 impl ::core::convert::From<revokeRoleReturn> for UnderlyingRustTuple<'_> {
6518 fn from(value: revokeRoleReturn) -> Self {
6519 ()
6520 }
6521 }
6522 #[automatically_derived]
6523 #[doc(hidden)]
6524 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleReturn {
6525 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6526 Self {}
6527 }
6528 }
6529 }
6530 #[automatically_derived]
6531 impl alloy_sol_types::SolCall for revokeRoleCall {
6532 type Parameters<'a> = (
6533 alloy::sol_types::sol_data::FixedBytes<32>,
6534 alloy::sol_types::sol_data::Address,
6535 );
6536 type Token<'a> = <Self::Parameters<
6537 'a,
6538 > as alloy_sol_types::SolType>::Token<'a>;
6539 type Return = revokeRoleReturn;
6540 type ReturnTuple<'a> = ();
6541 type ReturnToken<'a> = <Self::ReturnTuple<
6542 'a,
6543 > as alloy_sol_types::SolType>::Token<'a>;
6544 const SIGNATURE: &'static str = "revokeRole(bytes32,address)";
6545 const SELECTOR: [u8; 4] = [213u8, 71u8, 116u8, 31u8];
6546 #[inline]
6547 fn new<'a>(
6548 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6549 ) -> Self {
6550 tuple.into()
6551 }
6552 #[inline]
6553 fn tokenize(&self) -> Self::Token<'_> {
6554 (
6555 <alloy::sol_types::sol_data::FixedBytes<
6556 32,
6557 > as alloy_sol_types::SolType>::tokenize(&self.role),
6558 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6559 &self.account,
6560 ),
6561 )
6562 }
6563 #[inline]
6564 fn abi_decode_returns(
6565 data: &[u8],
6566 validate: bool,
6567 ) -> alloy_sol_types::Result<Self::Return> {
6568 <Self::ReturnTuple<
6569 '_,
6570 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6571 .map(Into::into)
6572 }
6573 }
6574 };
6575 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6576 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6581 #[derive(Clone)]
6582 pub struct scheduleCall {
6583 #[allow(missing_docs)]
6584 pub target: alloy::sol_types::private::Address,
6585 #[allow(missing_docs)]
6586 pub value: alloy::sol_types::private::primitives::aliases::U256,
6587 #[allow(missing_docs)]
6588 pub data: alloy::sol_types::private::Bytes,
6589 #[allow(missing_docs)]
6590 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
6591 #[allow(missing_docs)]
6592 pub salt: alloy::sol_types::private::FixedBytes<32>,
6593 #[allow(missing_docs)]
6594 pub delay: alloy::sol_types::private::primitives::aliases::U256,
6595 }
6596 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6598 #[derive(Clone)]
6599 pub struct scheduleReturn {}
6600 #[allow(
6601 non_camel_case_types,
6602 non_snake_case,
6603 clippy::pub_underscore_fields,
6604 clippy::style
6605 )]
6606 const _: () = {
6607 use alloy::sol_types as alloy_sol_types;
6608 {
6609 #[doc(hidden)]
6610 type UnderlyingSolTuple<'a> = (
6611 alloy::sol_types::sol_data::Address,
6612 alloy::sol_types::sol_data::Uint<256>,
6613 alloy::sol_types::sol_data::Bytes,
6614 alloy::sol_types::sol_data::FixedBytes<32>,
6615 alloy::sol_types::sol_data::FixedBytes<32>,
6616 alloy::sol_types::sol_data::Uint<256>,
6617 );
6618 #[doc(hidden)]
6619 type UnderlyingRustTuple<'a> = (
6620 alloy::sol_types::private::Address,
6621 alloy::sol_types::private::primitives::aliases::U256,
6622 alloy::sol_types::private::Bytes,
6623 alloy::sol_types::private::FixedBytes<32>,
6624 alloy::sol_types::private::FixedBytes<32>,
6625 alloy::sol_types::private::primitives::aliases::U256,
6626 );
6627 #[cfg(test)]
6628 #[allow(dead_code, unreachable_patterns)]
6629 fn _type_assertion(
6630 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6631 ) {
6632 match _t {
6633 alloy_sol_types::private::AssertTypeEq::<
6634 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6635 >(_) => {}
6636 }
6637 }
6638 #[automatically_derived]
6639 #[doc(hidden)]
6640 impl ::core::convert::From<scheduleCall> for UnderlyingRustTuple<'_> {
6641 fn from(value: scheduleCall) -> Self {
6642 (
6643 value.target,
6644 value.value,
6645 value.data,
6646 value.predecessor,
6647 value.salt,
6648 value.delay,
6649 )
6650 }
6651 }
6652 #[automatically_derived]
6653 #[doc(hidden)]
6654 impl ::core::convert::From<UnderlyingRustTuple<'_>> for scheduleCall {
6655 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6656 Self {
6657 target: tuple.0,
6658 value: tuple.1,
6659 data: tuple.2,
6660 predecessor: tuple.3,
6661 salt: tuple.4,
6662 delay: tuple.5,
6663 }
6664 }
6665 }
6666 }
6667 {
6668 #[doc(hidden)]
6669 type UnderlyingSolTuple<'a> = ();
6670 #[doc(hidden)]
6671 type UnderlyingRustTuple<'a> = ();
6672 #[cfg(test)]
6673 #[allow(dead_code, unreachable_patterns)]
6674 fn _type_assertion(
6675 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6676 ) {
6677 match _t {
6678 alloy_sol_types::private::AssertTypeEq::<
6679 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6680 >(_) => {}
6681 }
6682 }
6683 #[automatically_derived]
6684 #[doc(hidden)]
6685 impl ::core::convert::From<scheduleReturn> for UnderlyingRustTuple<'_> {
6686 fn from(value: scheduleReturn) -> Self {
6687 ()
6688 }
6689 }
6690 #[automatically_derived]
6691 #[doc(hidden)]
6692 impl ::core::convert::From<UnderlyingRustTuple<'_>> for scheduleReturn {
6693 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6694 Self {}
6695 }
6696 }
6697 }
6698 #[automatically_derived]
6699 impl alloy_sol_types::SolCall for scheduleCall {
6700 type Parameters<'a> = (
6701 alloy::sol_types::sol_data::Address,
6702 alloy::sol_types::sol_data::Uint<256>,
6703 alloy::sol_types::sol_data::Bytes,
6704 alloy::sol_types::sol_data::FixedBytes<32>,
6705 alloy::sol_types::sol_data::FixedBytes<32>,
6706 alloy::sol_types::sol_data::Uint<256>,
6707 );
6708 type Token<'a> = <Self::Parameters<
6709 'a,
6710 > as alloy_sol_types::SolType>::Token<'a>;
6711 type Return = scheduleReturn;
6712 type ReturnTuple<'a> = ();
6713 type ReturnToken<'a> = <Self::ReturnTuple<
6714 'a,
6715 > as alloy_sol_types::SolType>::Token<'a>;
6716 const SIGNATURE: &'static str = "schedule(address,uint256,bytes,bytes32,bytes32,uint256)";
6717 const SELECTOR: [u8; 4] = [1u8, 213u8, 6u8, 42u8];
6718 #[inline]
6719 fn new<'a>(
6720 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6721 ) -> Self {
6722 tuple.into()
6723 }
6724 #[inline]
6725 fn tokenize(&self) -> Self::Token<'_> {
6726 (
6727 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6728 &self.target,
6729 ),
6730 <alloy::sol_types::sol_data::Uint<
6731 256,
6732 > as alloy_sol_types::SolType>::tokenize(&self.value),
6733 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
6734 &self.data,
6735 ),
6736 <alloy::sol_types::sol_data::FixedBytes<
6737 32,
6738 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
6739 <alloy::sol_types::sol_data::FixedBytes<
6740 32,
6741 > as alloy_sol_types::SolType>::tokenize(&self.salt),
6742 <alloy::sol_types::sol_data::Uint<
6743 256,
6744 > as alloy_sol_types::SolType>::tokenize(&self.delay),
6745 )
6746 }
6747 #[inline]
6748 fn abi_decode_returns(
6749 data: &[u8],
6750 validate: bool,
6751 ) -> alloy_sol_types::Result<Self::Return> {
6752 <Self::ReturnTuple<
6753 '_,
6754 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6755 .map(Into::into)
6756 }
6757 }
6758 };
6759 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6760 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6765 #[derive(Clone)]
6766 pub struct scheduleBatchCall {
6767 #[allow(missing_docs)]
6768 pub targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
6769 #[allow(missing_docs)]
6770 pub values: alloy::sol_types::private::Vec<
6771 alloy::sol_types::private::primitives::aliases::U256,
6772 >,
6773 #[allow(missing_docs)]
6774 pub payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
6775 #[allow(missing_docs)]
6776 pub predecessor: alloy::sol_types::private::FixedBytes<32>,
6777 #[allow(missing_docs)]
6778 pub salt: alloy::sol_types::private::FixedBytes<32>,
6779 #[allow(missing_docs)]
6780 pub delay: alloy::sol_types::private::primitives::aliases::U256,
6781 }
6782 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6784 #[derive(Clone)]
6785 pub struct scheduleBatchReturn {}
6786 #[allow(
6787 non_camel_case_types,
6788 non_snake_case,
6789 clippy::pub_underscore_fields,
6790 clippy::style
6791 )]
6792 const _: () = {
6793 use alloy::sol_types as alloy_sol_types;
6794 {
6795 #[doc(hidden)]
6796 type UnderlyingSolTuple<'a> = (
6797 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
6798 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
6799 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
6800 alloy::sol_types::sol_data::FixedBytes<32>,
6801 alloy::sol_types::sol_data::FixedBytes<32>,
6802 alloy::sol_types::sol_data::Uint<256>,
6803 );
6804 #[doc(hidden)]
6805 type UnderlyingRustTuple<'a> = (
6806 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
6807 alloy::sol_types::private::Vec<
6808 alloy::sol_types::private::primitives::aliases::U256,
6809 >,
6810 alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
6811 alloy::sol_types::private::FixedBytes<32>,
6812 alloy::sol_types::private::FixedBytes<32>,
6813 alloy::sol_types::private::primitives::aliases::U256,
6814 );
6815 #[cfg(test)]
6816 #[allow(dead_code, unreachable_patterns)]
6817 fn _type_assertion(
6818 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6819 ) {
6820 match _t {
6821 alloy_sol_types::private::AssertTypeEq::<
6822 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6823 >(_) => {}
6824 }
6825 }
6826 #[automatically_derived]
6827 #[doc(hidden)]
6828 impl ::core::convert::From<scheduleBatchCall> for UnderlyingRustTuple<'_> {
6829 fn from(value: scheduleBatchCall) -> Self {
6830 (
6831 value.targets,
6832 value.values,
6833 value.payloads,
6834 value.predecessor,
6835 value.salt,
6836 value.delay,
6837 )
6838 }
6839 }
6840 #[automatically_derived]
6841 #[doc(hidden)]
6842 impl ::core::convert::From<UnderlyingRustTuple<'_>> for scheduleBatchCall {
6843 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6844 Self {
6845 targets: tuple.0,
6846 values: tuple.1,
6847 payloads: tuple.2,
6848 predecessor: tuple.3,
6849 salt: tuple.4,
6850 delay: tuple.5,
6851 }
6852 }
6853 }
6854 }
6855 {
6856 #[doc(hidden)]
6857 type UnderlyingSolTuple<'a> = ();
6858 #[doc(hidden)]
6859 type UnderlyingRustTuple<'a> = ();
6860 #[cfg(test)]
6861 #[allow(dead_code, unreachable_patterns)]
6862 fn _type_assertion(
6863 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6864 ) {
6865 match _t {
6866 alloy_sol_types::private::AssertTypeEq::<
6867 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6868 >(_) => {}
6869 }
6870 }
6871 #[automatically_derived]
6872 #[doc(hidden)]
6873 impl ::core::convert::From<scheduleBatchReturn> for UnderlyingRustTuple<'_> {
6874 fn from(value: scheduleBatchReturn) -> Self {
6875 ()
6876 }
6877 }
6878 #[automatically_derived]
6879 #[doc(hidden)]
6880 impl ::core::convert::From<UnderlyingRustTuple<'_>> for scheduleBatchReturn {
6881 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6882 Self {}
6883 }
6884 }
6885 }
6886 #[automatically_derived]
6887 impl alloy_sol_types::SolCall for scheduleBatchCall {
6888 type Parameters<'a> = (
6889 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
6890 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
6891 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
6892 alloy::sol_types::sol_data::FixedBytes<32>,
6893 alloy::sol_types::sol_data::FixedBytes<32>,
6894 alloy::sol_types::sol_data::Uint<256>,
6895 );
6896 type Token<'a> = <Self::Parameters<
6897 'a,
6898 > as alloy_sol_types::SolType>::Token<'a>;
6899 type Return = scheduleBatchReturn;
6900 type ReturnTuple<'a> = ();
6901 type ReturnToken<'a> = <Self::ReturnTuple<
6902 'a,
6903 > as alloy_sol_types::SolType>::Token<'a>;
6904 const SIGNATURE: &'static str = "scheduleBatch(address[],uint256[],bytes[],bytes32,bytes32,uint256)";
6905 const SELECTOR: [u8; 4] = [143u8, 42u8, 11u8, 176u8];
6906 #[inline]
6907 fn new<'a>(
6908 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6909 ) -> Self {
6910 tuple.into()
6911 }
6912 #[inline]
6913 fn tokenize(&self) -> Self::Token<'_> {
6914 (
6915 <alloy::sol_types::sol_data::Array<
6916 alloy::sol_types::sol_data::Address,
6917 > as alloy_sol_types::SolType>::tokenize(&self.targets),
6918 <alloy::sol_types::sol_data::Array<
6919 alloy::sol_types::sol_data::Uint<256>,
6920 > as alloy_sol_types::SolType>::tokenize(&self.values),
6921 <alloy::sol_types::sol_data::Array<
6922 alloy::sol_types::sol_data::Bytes,
6923 > as alloy_sol_types::SolType>::tokenize(&self.payloads),
6924 <alloy::sol_types::sol_data::FixedBytes<
6925 32,
6926 > as alloy_sol_types::SolType>::tokenize(&self.predecessor),
6927 <alloy::sol_types::sol_data::FixedBytes<
6928 32,
6929 > as alloy_sol_types::SolType>::tokenize(&self.salt),
6930 <alloy::sol_types::sol_data::Uint<
6931 256,
6932 > as alloy_sol_types::SolType>::tokenize(&self.delay),
6933 )
6934 }
6935 #[inline]
6936 fn abi_decode_returns(
6937 data: &[u8],
6938 validate: bool,
6939 ) -> alloy_sol_types::Result<Self::Return> {
6940 <Self::ReturnTuple<
6941 '_,
6942 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
6943 .map(Into::into)
6944 }
6945 }
6946 };
6947 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6948 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6953 #[derive(Clone)]
6954 pub struct supportsInterfaceCall {
6955 #[allow(missing_docs)]
6956 pub interfaceId: alloy::sol_types::private::FixedBytes<4>,
6957 }
6958 #[derive(Default, Debug, PartialEq, Eq, Hash)]
6959 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6961 #[derive(Clone)]
6962 pub struct supportsInterfaceReturn {
6963 #[allow(missing_docs)]
6964 pub _0: bool,
6965 }
6966 #[allow(
6967 non_camel_case_types,
6968 non_snake_case,
6969 clippy::pub_underscore_fields,
6970 clippy::style
6971 )]
6972 const _: () = {
6973 use alloy::sol_types as alloy_sol_types;
6974 {
6975 #[doc(hidden)]
6976 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
6977 #[doc(hidden)]
6978 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
6979 #[cfg(test)]
6980 #[allow(dead_code, unreachable_patterns)]
6981 fn _type_assertion(
6982 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6983 ) {
6984 match _t {
6985 alloy_sol_types::private::AssertTypeEq::<
6986 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6987 >(_) => {}
6988 }
6989 }
6990 #[automatically_derived]
6991 #[doc(hidden)]
6992 impl ::core::convert::From<supportsInterfaceCall>
6993 for UnderlyingRustTuple<'_> {
6994 fn from(value: supportsInterfaceCall) -> Self {
6995 (value.interfaceId,)
6996 }
6997 }
6998 #[automatically_derived]
6999 #[doc(hidden)]
7000 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7001 for supportsInterfaceCall {
7002 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7003 Self { interfaceId: tuple.0 }
7004 }
7005 }
7006 }
7007 {
7008 #[doc(hidden)]
7009 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
7010 #[doc(hidden)]
7011 type UnderlyingRustTuple<'a> = (bool,);
7012 #[cfg(test)]
7013 #[allow(dead_code, unreachable_patterns)]
7014 fn _type_assertion(
7015 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7016 ) {
7017 match _t {
7018 alloy_sol_types::private::AssertTypeEq::<
7019 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7020 >(_) => {}
7021 }
7022 }
7023 #[automatically_derived]
7024 #[doc(hidden)]
7025 impl ::core::convert::From<supportsInterfaceReturn>
7026 for UnderlyingRustTuple<'_> {
7027 fn from(value: supportsInterfaceReturn) -> Self {
7028 (value._0,)
7029 }
7030 }
7031 #[automatically_derived]
7032 #[doc(hidden)]
7033 impl ::core::convert::From<UnderlyingRustTuple<'_>>
7034 for supportsInterfaceReturn {
7035 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7036 Self { _0: tuple.0 }
7037 }
7038 }
7039 }
7040 #[automatically_derived]
7041 impl alloy_sol_types::SolCall for supportsInterfaceCall {
7042 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
7043 type Token<'a> = <Self::Parameters<
7044 'a,
7045 > as alloy_sol_types::SolType>::Token<'a>;
7046 type Return = supportsInterfaceReturn;
7047 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
7048 type ReturnToken<'a> = <Self::ReturnTuple<
7049 'a,
7050 > as alloy_sol_types::SolType>::Token<'a>;
7051 const SIGNATURE: &'static str = "supportsInterface(bytes4)";
7052 const SELECTOR: [u8; 4] = [1u8, 255u8, 201u8, 167u8];
7053 #[inline]
7054 fn new<'a>(
7055 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7056 ) -> Self {
7057 tuple.into()
7058 }
7059 #[inline]
7060 fn tokenize(&self) -> Self::Token<'_> {
7061 (
7062 <alloy::sol_types::sol_data::FixedBytes<
7063 4,
7064 > as alloy_sol_types::SolType>::tokenize(&self.interfaceId),
7065 )
7066 }
7067 #[inline]
7068 fn abi_decode_returns(
7069 data: &[u8],
7070 validate: bool,
7071 ) -> alloy_sol_types::Result<Self::Return> {
7072 <Self::ReturnTuple<
7073 '_,
7074 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7075 .map(Into::into)
7076 }
7077 }
7078 };
7079 #[derive(Default, Debug, PartialEq, Eq, Hash)]
7080 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7085 #[derive(Clone)]
7086 pub struct updateDelayCall {
7087 #[allow(missing_docs)]
7088 pub newDelay: alloy::sol_types::private::primitives::aliases::U256,
7089 }
7090 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7092 #[derive(Clone)]
7093 pub struct updateDelayReturn {}
7094 #[allow(
7095 non_camel_case_types,
7096 non_snake_case,
7097 clippy::pub_underscore_fields,
7098 clippy::style
7099 )]
7100 const _: () = {
7101 use alloy::sol_types as alloy_sol_types;
7102 {
7103 #[doc(hidden)]
7104 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7105 #[doc(hidden)]
7106 type UnderlyingRustTuple<'a> = (
7107 alloy::sol_types::private::primitives::aliases::U256,
7108 );
7109 #[cfg(test)]
7110 #[allow(dead_code, unreachable_patterns)]
7111 fn _type_assertion(
7112 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7113 ) {
7114 match _t {
7115 alloy_sol_types::private::AssertTypeEq::<
7116 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7117 >(_) => {}
7118 }
7119 }
7120 #[automatically_derived]
7121 #[doc(hidden)]
7122 impl ::core::convert::From<updateDelayCall> for UnderlyingRustTuple<'_> {
7123 fn from(value: updateDelayCall) -> Self {
7124 (value.newDelay,)
7125 }
7126 }
7127 #[automatically_derived]
7128 #[doc(hidden)]
7129 impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateDelayCall {
7130 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7131 Self { newDelay: tuple.0 }
7132 }
7133 }
7134 }
7135 {
7136 #[doc(hidden)]
7137 type UnderlyingSolTuple<'a> = ();
7138 #[doc(hidden)]
7139 type UnderlyingRustTuple<'a> = ();
7140 #[cfg(test)]
7141 #[allow(dead_code, unreachable_patterns)]
7142 fn _type_assertion(
7143 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7144 ) {
7145 match _t {
7146 alloy_sol_types::private::AssertTypeEq::<
7147 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7148 >(_) => {}
7149 }
7150 }
7151 #[automatically_derived]
7152 #[doc(hidden)]
7153 impl ::core::convert::From<updateDelayReturn> for UnderlyingRustTuple<'_> {
7154 fn from(value: updateDelayReturn) -> Self {
7155 ()
7156 }
7157 }
7158 #[automatically_derived]
7159 #[doc(hidden)]
7160 impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateDelayReturn {
7161 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7162 Self {}
7163 }
7164 }
7165 }
7166 #[automatically_derived]
7167 impl alloy_sol_types::SolCall for updateDelayCall {
7168 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
7169 type Token<'a> = <Self::Parameters<
7170 'a,
7171 > as alloy_sol_types::SolType>::Token<'a>;
7172 type Return = updateDelayReturn;
7173 type ReturnTuple<'a> = ();
7174 type ReturnToken<'a> = <Self::ReturnTuple<
7175 'a,
7176 > as alloy_sol_types::SolType>::Token<'a>;
7177 const SIGNATURE: &'static str = "updateDelay(uint256)";
7178 const SELECTOR: [u8; 4] = [100u8, 214u8, 35u8, 83u8];
7179 #[inline]
7180 fn new<'a>(
7181 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7182 ) -> Self {
7183 tuple.into()
7184 }
7185 #[inline]
7186 fn tokenize(&self) -> Self::Token<'_> {
7187 (
7188 <alloy::sol_types::sol_data::Uint<
7189 256,
7190 > as alloy_sol_types::SolType>::tokenize(&self.newDelay),
7191 )
7192 }
7193 #[inline]
7194 fn abi_decode_returns(
7195 data: &[u8],
7196 validate: bool,
7197 ) -> alloy_sol_types::Result<Self::Return> {
7198 <Self::ReturnTuple<
7199 '_,
7200 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
7201 .map(Into::into)
7202 }
7203 }
7204 };
7205 #[derive()]
7207 pub enum SafeExitTimelockCalls {
7208 #[allow(missing_docs)]
7209 CANCELLER_ROLE(CANCELLER_ROLECall),
7210 #[allow(missing_docs)]
7211 DEFAULT_ADMIN_ROLE(DEFAULT_ADMIN_ROLECall),
7212 #[allow(missing_docs)]
7213 EXECUTOR_ROLE(EXECUTOR_ROLECall),
7214 #[allow(missing_docs)]
7215 PROPOSER_ROLE(PROPOSER_ROLECall),
7216 #[allow(missing_docs)]
7217 cancel(cancelCall),
7218 #[allow(missing_docs)]
7219 execute(executeCall),
7220 #[allow(missing_docs)]
7221 executeBatch(executeBatchCall),
7222 #[allow(missing_docs)]
7223 getMinDelay(getMinDelayCall),
7224 #[allow(missing_docs)]
7225 getOperationState(getOperationStateCall),
7226 #[allow(missing_docs)]
7227 getRoleAdmin(getRoleAdminCall),
7228 #[allow(missing_docs)]
7229 getTimestamp(getTimestampCall),
7230 #[allow(missing_docs)]
7231 grantRole(grantRoleCall),
7232 #[allow(missing_docs)]
7233 hasRole(hasRoleCall),
7234 #[allow(missing_docs)]
7235 hashOperation(hashOperationCall),
7236 #[allow(missing_docs)]
7237 hashOperationBatch(hashOperationBatchCall),
7238 #[allow(missing_docs)]
7239 isOperation(isOperationCall),
7240 #[allow(missing_docs)]
7241 isOperationDone(isOperationDoneCall),
7242 #[allow(missing_docs)]
7243 isOperationPending(isOperationPendingCall),
7244 #[allow(missing_docs)]
7245 isOperationReady(isOperationReadyCall),
7246 #[allow(missing_docs)]
7247 onERC1155BatchReceived(onERC1155BatchReceivedCall),
7248 #[allow(missing_docs)]
7249 onERC1155Received(onERC1155ReceivedCall),
7250 #[allow(missing_docs)]
7251 onERC721Received(onERC721ReceivedCall),
7252 #[allow(missing_docs)]
7253 renounceRole(renounceRoleCall),
7254 #[allow(missing_docs)]
7255 revokeRole(revokeRoleCall),
7256 #[allow(missing_docs)]
7257 schedule(scheduleCall),
7258 #[allow(missing_docs)]
7259 scheduleBatch(scheduleBatchCall),
7260 #[allow(missing_docs)]
7261 supportsInterface(supportsInterfaceCall),
7262 #[allow(missing_docs)]
7263 updateDelay(updateDelayCall),
7264 }
7265 #[automatically_derived]
7266 impl SafeExitTimelockCalls {
7267 pub const SELECTORS: &'static [[u8; 4usize]] = &[
7274 [1u8, 213u8, 6u8, 42u8],
7275 [1u8, 255u8, 201u8, 167u8],
7276 [7u8, 189u8, 2u8, 101u8],
7277 [19u8, 64u8, 8u8, 211u8],
7278 [19u8, 188u8, 159u8, 32u8],
7279 [21u8, 11u8, 122u8, 2u8],
7280 [36u8, 138u8, 156u8, 163u8],
7281 [42u8, 176u8, 245u8, 41u8],
7282 [47u8, 47u8, 241u8, 93u8],
7283 [49u8, 213u8, 7u8, 80u8],
7284 [54u8, 86u8, 138u8, 190u8],
7285 [88u8, 75u8, 21u8, 62u8],
7286 [100u8, 214u8, 35u8, 83u8],
7287 [121u8, 88u8, 0u8, 76u8],
7288 [128u8, 101u8, 101u8, 127u8],
7289 [143u8, 42u8, 11u8, 176u8],
7290 [143u8, 97u8, 244u8, 245u8],
7291 [145u8, 209u8, 72u8, 84u8],
7292 [162u8, 23u8, 253u8, 223u8],
7293 [176u8, 142u8, 81u8, 192u8],
7294 [177u8, 197u8, 244u8, 39u8],
7295 [188u8, 25u8, 124u8, 129u8],
7296 [196u8, 210u8, 82u8, 245u8],
7297 [212u8, 92u8, 68u8, 53u8],
7298 [213u8, 71u8, 116u8, 31u8],
7299 [227u8, 131u8, 53u8, 229u8],
7300 [242u8, 58u8, 110u8, 97u8],
7301 [242u8, 122u8, 12u8, 146u8],
7302 ];
7303 }
7304 #[automatically_derived]
7305 impl alloy_sol_types::SolInterface for SafeExitTimelockCalls {
7306 const NAME: &'static str = "SafeExitTimelockCalls";
7307 const MIN_DATA_LENGTH: usize = 0usize;
7308 const COUNT: usize = 28usize;
7309 #[inline]
7310 fn selector(&self) -> [u8; 4] {
7311 match self {
7312 Self::CANCELLER_ROLE(_) => {
7313 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::SELECTOR
7314 }
7315 Self::DEFAULT_ADMIN_ROLE(_) => {
7316 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::SELECTOR
7317 }
7318 Self::EXECUTOR_ROLE(_) => {
7319 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::SELECTOR
7320 }
7321 Self::PROPOSER_ROLE(_) => {
7322 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::SELECTOR
7323 }
7324 Self::cancel(_) => <cancelCall as alloy_sol_types::SolCall>::SELECTOR,
7325 Self::execute(_) => <executeCall as alloy_sol_types::SolCall>::SELECTOR,
7326 Self::executeBatch(_) => {
7327 <executeBatchCall as alloy_sol_types::SolCall>::SELECTOR
7328 }
7329 Self::getMinDelay(_) => {
7330 <getMinDelayCall as alloy_sol_types::SolCall>::SELECTOR
7331 }
7332 Self::getOperationState(_) => {
7333 <getOperationStateCall as alloy_sol_types::SolCall>::SELECTOR
7334 }
7335 Self::getRoleAdmin(_) => {
7336 <getRoleAdminCall as alloy_sol_types::SolCall>::SELECTOR
7337 }
7338 Self::getTimestamp(_) => {
7339 <getTimestampCall as alloy_sol_types::SolCall>::SELECTOR
7340 }
7341 Self::grantRole(_) => {
7342 <grantRoleCall as alloy_sol_types::SolCall>::SELECTOR
7343 }
7344 Self::hasRole(_) => <hasRoleCall as alloy_sol_types::SolCall>::SELECTOR,
7345 Self::hashOperation(_) => {
7346 <hashOperationCall as alloy_sol_types::SolCall>::SELECTOR
7347 }
7348 Self::hashOperationBatch(_) => {
7349 <hashOperationBatchCall as alloy_sol_types::SolCall>::SELECTOR
7350 }
7351 Self::isOperation(_) => {
7352 <isOperationCall as alloy_sol_types::SolCall>::SELECTOR
7353 }
7354 Self::isOperationDone(_) => {
7355 <isOperationDoneCall as alloy_sol_types::SolCall>::SELECTOR
7356 }
7357 Self::isOperationPending(_) => {
7358 <isOperationPendingCall as alloy_sol_types::SolCall>::SELECTOR
7359 }
7360 Self::isOperationReady(_) => {
7361 <isOperationReadyCall as alloy_sol_types::SolCall>::SELECTOR
7362 }
7363 Self::onERC1155BatchReceived(_) => {
7364 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::SELECTOR
7365 }
7366 Self::onERC1155Received(_) => {
7367 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
7368 }
7369 Self::onERC721Received(_) => {
7370 <onERC721ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
7371 }
7372 Self::renounceRole(_) => {
7373 <renounceRoleCall as alloy_sol_types::SolCall>::SELECTOR
7374 }
7375 Self::revokeRole(_) => {
7376 <revokeRoleCall as alloy_sol_types::SolCall>::SELECTOR
7377 }
7378 Self::schedule(_) => <scheduleCall as alloy_sol_types::SolCall>::SELECTOR,
7379 Self::scheduleBatch(_) => {
7380 <scheduleBatchCall as alloy_sol_types::SolCall>::SELECTOR
7381 }
7382 Self::supportsInterface(_) => {
7383 <supportsInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
7384 }
7385 Self::updateDelay(_) => {
7386 <updateDelayCall as alloy_sol_types::SolCall>::SELECTOR
7387 }
7388 }
7389 }
7390 #[inline]
7391 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
7392 Self::SELECTORS.get(i).copied()
7393 }
7394 #[inline]
7395 fn valid_selector(selector: [u8; 4]) -> bool {
7396 Self::SELECTORS.binary_search(&selector).is_ok()
7397 }
7398 #[inline]
7399 #[allow(non_snake_case)]
7400 fn abi_decode_raw(
7401 selector: [u8; 4],
7402 data: &[u8],
7403 validate: bool,
7404 ) -> alloy_sol_types::Result<Self> {
7405 static DECODE_SHIMS: &[fn(
7406 &[u8],
7407 bool,
7408 ) -> alloy_sol_types::Result<SafeExitTimelockCalls>] = &[
7409 {
7410 fn schedule(
7411 data: &[u8],
7412 validate: bool,
7413 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7414 <scheduleCall as alloy_sol_types::SolCall>::abi_decode_raw(
7415 data,
7416 validate,
7417 )
7418 .map(SafeExitTimelockCalls::schedule)
7419 }
7420 schedule
7421 },
7422 {
7423 fn supportsInterface(
7424 data: &[u8],
7425 validate: bool,
7426 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7427 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(
7428 data,
7429 validate,
7430 )
7431 .map(SafeExitTimelockCalls::supportsInterface)
7432 }
7433 supportsInterface
7434 },
7435 {
7436 fn EXECUTOR_ROLE(
7437 data: &[u8],
7438 validate: bool,
7439 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7440 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
7441 data,
7442 validate,
7443 )
7444 .map(SafeExitTimelockCalls::EXECUTOR_ROLE)
7445 }
7446 EXECUTOR_ROLE
7447 },
7448 {
7449 fn execute(
7450 data: &[u8],
7451 validate: bool,
7452 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7453 <executeCall as alloy_sol_types::SolCall>::abi_decode_raw(
7454 data,
7455 validate,
7456 )
7457 .map(SafeExitTimelockCalls::execute)
7458 }
7459 execute
7460 },
7461 {
7462 fn isOperationReady(
7463 data: &[u8],
7464 validate: bool,
7465 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7466 <isOperationReadyCall as alloy_sol_types::SolCall>::abi_decode_raw(
7467 data,
7468 validate,
7469 )
7470 .map(SafeExitTimelockCalls::isOperationReady)
7471 }
7472 isOperationReady
7473 },
7474 {
7475 fn onERC721Received(
7476 data: &[u8],
7477 validate: bool,
7478 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7479 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
7480 data,
7481 validate,
7482 )
7483 .map(SafeExitTimelockCalls::onERC721Received)
7484 }
7485 onERC721Received
7486 },
7487 {
7488 fn getRoleAdmin(
7489 data: &[u8],
7490 validate: bool,
7491 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7492 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
7493 data,
7494 validate,
7495 )
7496 .map(SafeExitTimelockCalls::getRoleAdmin)
7497 }
7498 getRoleAdmin
7499 },
7500 {
7501 fn isOperationDone(
7502 data: &[u8],
7503 validate: bool,
7504 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7505 <isOperationDoneCall as alloy_sol_types::SolCall>::abi_decode_raw(
7506 data,
7507 validate,
7508 )
7509 .map(SafeExitTimelockCalls::isOperationDone)
7510 }
7511 isOperationDone
7512 },
7513 {
7514 fn grantRole(
7515 data: &[u8],
7516 validate: bool,
7517 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7518 <grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
7519 data,
7520 validate,
7521 )
7522 .map(SafeExitTimelockCalls::grantRole)
7523 }
7524 grantRole
7525 },
7526 {
7527 fn isOperation(
7528 data: &[u8],
7529 validate: bool,
7530 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7531 <isOperationCall as alloy_sol_types::SolCall>::abi_decode_raw(
7532 data,
7533 validate,
7534 )
7535 .map(SafeExitTimelockCalls::isOperation)
7536 }
7537 isOperation
7538 },
7539 {
7540 fn renounceRole(
7541 data: &[u8],
7542 validate: bool,
7543 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7544 <renounceRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
7545 data,
7546 validate,
7547 )
7548 .map(SafeExitTimelockCalls::renounceRole)
7549 }
7550 renounceRole
7551 },
7552 {
7553 fn isOperationPending(
7554 data: &[u8],
7555 validate: bool,
7556 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7557 <isOperationPendingCall as alloy_sol_types::SolCall>::abi_decode_raw(
7558 data,
7559 validate,
7560 )
7561 .map(SafeExitTimelockCalls::isOperationPending)
7562 }
7563 isOperationPending
7564 },
7565 {
7566 fn updateDelay(
7567 data: &[u8],
7568 validate: bool,
7569 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7570 <updateDelayCall as alloy_sol_types::SolCall>::abi_decode_raw(
7571 data,
7572 validate,
7573 )
7574 .map(SafeExitTimelockCalls::updateDelay)
7575 }
7576 updateDelay
7577 },
7578 {
7579 fn getOperationState(
7580 data: &[u8],
7581 validate: bool,
7582 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7583 <getOperationStateCall as alloy_sol_types::SolCall>::abi_decode_raw(
7584 data,
7585 validate,
7586 )
7587 .map(SafeExitTimelockCalls::getOperationState)
7588 }
7589 getOperationState
7590 },
7591 {
7592 fn hashOperation(
7593 data: &[u8],
7594 validate: bool,
7595 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7596 <hashOperationCall as alloy_sol_types::SolCall>::abi_decode_raw(
7597 data,
7598 validate,
7599 )
7600 .map(SafeExitTimelockCalls::hashOperation)
7601 }
7602 hashOperation
7603 },
7604 {
7605 fn scheduleBatch(
7606 data: &[u8],
7607 validate: bool,
7608 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7609 <scheduleBatchCall as alloy_sol_types::SolCall>::abi_decode_raw(
7610 data,
7611 validate,
7612 )
7613 .map(SafeExitTimelockCalls::scheduleBatch)
7614 }
7615 scheduleBatch
7616 },
7617 {
7618 fn PROPOSER_ROLE(
7619 data: &[u8],
7620 validate: bool,
7621 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7622 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
7623 data,
7624 validate,
7625 )
7626 .map(SafeExitTimelockCalls::PROPOSER_ROLE)
7627 }
7628 PROPOSER_ROLE
7629 },
7630 {
7631 fn hasRole(
7632 data: &[u8],
7633 validate: bool,
7634 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7635 <hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
7636 data,
7637 validate,
7638 )
7639 .map(SafeExitTimelockCalls::hasRole)
7640 }
7641 hasRole
7642 },
7643 {
7644 fn DEFAULT_ADMIN_ROLE(
7645 data: &[u8],
7646 validate: bool,
7647 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7648 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
7649 data,
7650 validate,
7651 )
7652 .map(SafeExitTimelockCalls::DEFAULT_ADMIN_ROLE)
7653 }
7654 DEFAULT_ADMIN_ROLE
7655 },
7656 {
7657 fn CANCELLER_ROLE(
7658 data: &[u8],
7659 validate: bool,
7660 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7661 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
7662 data,
7663 validate,
7664 )
7665 .map(SafeExitTimelockCalls::CANCELLER_ROLE)
7666 }
7667 CANCELLER_ROLE
7668 },
7669 {
7670 fn hashOperationBatch(
7671 data: &[u8],
7672 validate: bool,
7673 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7674 <hashOperationBatchCall as alloy_sol_types::SolCall>::abi_decode_raw(
7675 data,
7676 validate,
7677 )
7678 .map(SafeExitTimelockCalls::hashOperationBatch)
7679 }
7680 hashOperationBatch
7681 },
7682 {
7683 fn onERC1155BatchReceived(
7684 data: &[u8],
7685 validate: bool,
7686 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7687 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
7688 data,
7689 validate,
7690 )
7691 .map(SafeExitTimelockCalls::onERC1155BatchReceived)
7692 }
7693 onERC1155BatchReceived
7694 },
7695 {
7696 fn cancel(
7697 data: &[u8],
7698 validate: bool,
7699 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7700 <cancelCall as alloy_sol_types::SolCall>::abi_decode_raw(
7701 data,
7702 validate,
7703 )
7704 .map(SafeExitTimelockCalls::cancel)
7705 }
7706 cancel
7707 },
7708 {
7709 fn getTimestamp(
7710 data: &[u8],
7711 validate: bool,
7712 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7713 <getTimestampCall as alloy_sol_types::SolCall>::abi_decode_raw(
7714 data,
7715 validate,
7716 )
7717 .map(SafeExitTimelockCalls::getTimestamp)
7718 }
7719 getTimestamp
7720 },
7721 {
7722 fn revokeRole(
7723 data: &[u8],
7724 validate: bool,
7725 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7726 <revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
7727 data,
7728 validate,
7729 )
7730 .map(SafeExitTimelockCalls::revokeRole)
7731 }
7732 revokeRole
7733 },
7734 {
7735 fn executeBatch(
7736 data: &[u8],
7737 validate: bool,
7738 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7739 <executeBatchCall as alloy_sol_types::SolCall>::abi_decode_raw(
7740 data,
7741 validate,
7742 )
7743 .map(SafeExitTimelockCalls::executeBatch)
7744 }
7745 executeBatch
7746 },
7747 {
7748 fn onERC1155Received(
7749 data: &[u8],
7750 validate: bool,
7751 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7752 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
7753 data,
7754 validate,
7755 )
7756 .map(SafeExitTimelockCalls::onERC1155Received)
7757 }
7758 onERC1155Received
7759 },
7760 {
7761 fn getMinDelay(
7762 data: &[u8],
7763 validate: bool,
7764 ) -> alloy_sol_types::Result<SafeExitTimelockCalls> {
7765 <getMinDelayCall as alloy_sol_types::SolCall>::abi_decode_raw(
7766 data,
7767 validate,
7768 )
7769 .map(SafeExitTimelockCalls::getMinDelay)
7770 }
7771 getMinDelay
7772 },
7773 ];
7774 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
7775 return Err(
7776 alloy_sol_types::Error::unknown_selector(
7777 <Self as alloy_sol_types::SolInterface>::NAME,
7778 selector,
7779 ),
7780 );
7781 };
7782 DECODE_SHIMS[idx](data, validate)
7783 }
7784 #[inline]
7785 fn abi_encoded_size(&self) -> usize {
7786 match self {
7787 Self::CANCELLER_ROLE(inner) => {
7788 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
7789 inner,
7790 )
7791 }
7792 Self::DEFAULT_ADMIN_ROLE(inner) => {
7793 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
7794 inner,
7795 )
7796 }
7797 Self::EXECUTOR_ROLE(inner) => {
7798 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
7799 inner,
7800 )
7801 }
7802 Self::PROPOSER_ROLE(inner) => {
7803 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(
7804 inner,
7805 )
7806 }
7807 Self::cancel(inner) => {
7808 <cancelCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
7809 }
7810 Self::execute(inner) => {
7811 <executeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
7812 }
7813 Self::executeBatch(inner) => {
7814 <executeBatchCall as alloy_sol_types::SolCall>::abi_encoded_size(
7815 inner,
7816 )
7817 }
7818 Self::getMinDelay(inner) => {
7819 <getMinDelayCall as alloy_sol_types::SolCall>::abi_encoded_size(
7820 inner,
7821 )
7822 }
7823 Self::getOperationState(inner) => {
7824 <getOperationStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
7825 inner,
7826 )
7827 }
7828 Self::getRoleAdmin(inner) => {
7829 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
7830 inner,
7831 )
7832 }
7833 Self::getTimestamp(inner) => {
7834 <getTimestampCall as alloy_sol_types::SolCall>::abi_encoded_size(
7835 inner,
7836 )
7837 }
7838 Self::grantRole(inner) => {
7839 <grantRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
7840 }
7841 Self::hasRole(inner) => {
7842 <hasRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
7843 }
7844 Self::hashOperation(inner) => {
7845 <hashOperationCall as alloy_sol_types::SolCall>::abi_encoded_size(
7846 inner,
7847 )
7848 }
7849 Self::hashOperationBatch(inner) => {
7850 <hashOperationBatchCall as alloy_sol_types::SolCall>::abi_encoded_size(
7851 inner,
7852 )
7853 }
7854 Self::isOperation(inner) => {
7855 <isOperationCall as alloy_sol_types::SolCall>::abi_encoded_size(
7856 inner,
7857 )
7858 }
7859 Self::isOperationDone(inner) => {
7860 <isOperationDoneCall as alloy_sol_types::SolCall>::abi_encoded_size(
7861 inner,
7862 )
7863 }
7864 Self::isOperationPending(inner) => {
7865 <isOperationPendingCall as alloy_sol_types::SolCall>::abi_encoded_size(
7866 inner,
7867 )
7868 }
7869 Self::isOperationReady(inner) => {
7870 <isOperationReadyCall as alloy_sol_types::SolCall>::abi_encoded_size(
7871 inner,
7872 )
7873 }
7874 Self::onERC1155BatchReceived(inner) => {
7875 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
7876 inner,
7877 )
7878 }
7879 Self::onERC1155Received(inner) => {
7880 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
7881 inner,
7882 )
7883 }
7884 Self::onERC721Received(inner) => {
7885 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
7886 inner,
7887 )
7888 }
7889 Self::renounceRole(inner) => {
7890 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(
7891 inner,
7892 )
7893 }
7894 Self::revokeRole(inner) => {
7895 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
7896 }
7897 Self::schedule(inner) => {
7898 <scheduleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
7899 }
7900 Self::scheduleBatch(inner) => {
7901 <scheduleBatchCall as alloy_sol_types::SolCall>::abi_encoded_size(
7902 inner,
7903 )
7904 }
7905 Self::supportsInterface(inner) => {
7906 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(
7907 inner,
7908 )
7909 }
7910 Self::updateDelay(inner) => {
7911 <updateDelayCall as alloy_sol_types::SolCall>::abi_encoded_size(
7912 inner,
7913 )
7914 }
7915 }
7916 }
7917 #[inline]
7918 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
7919 match self {
7920 Self::CANCELLER_ROLE(inner) => {
7921 <CANCELLER_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
7922 inner,
7923 out,
7924 )
7925 }
7926 Self::DEFAULT_ADMIN_ROLE(inner) => {
7927 <DEFAULT_ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
7928 inner,
7929 out,
7930 )
7931 }
7932 Self::EXECUTOR_ROLE(inner) => {
7933 <EXECUTOR_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
7934 inner,
7935 out,
7936 )
7937 }
7938 Self::PROPOSER_ROLE(inner) => {
7939 <PROPOSER_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
7940 inner,
7941 out,
7942 )
7943 }
7944 Self::cancel(inner) => {
7945 <cancelCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
7946 }
7947 Self::execute(inner) => {
7948 <executeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
7949 }
7950 Self::executeBatch(inner) => {
7951 <executeBatchCall as alloy_sol_types::SolCall>::abi_encode_raw(
7952 inner,
7953 out,
7954 )
7955 }
7956 Self::getMinDelay(inner) => {
7957 <getMinDelayCall as alloy_sol_types::SolCall>::abi_encode_raw(
7958 inner,
7959 out,
7960 )
7961 }
7962 Self::getOperationState(inner) => {
7963 <getOperationStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
7964 inner,
7965 out,
7966 )
7967 }
7968 Self::getRoleAdmin(inner) => {
7969 <getRoleAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
7970 inner,
7971 out,
7972 )
7973 }
7974 Self::getTimestamp(inner) => {
7975 <getTimestampCall as alloy_sol_types::SolCall>::abi_encode_raw(
7976 inner,
7977 out,
7978 )
7979 }
7980 Self::grantRole(inner) => {
7981 <grantRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
7982 inner,
7983 out,
7984 )
7985 }
7986 Self::hasRole(inner) => {
7987 <hasRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
7988 }
7989 Self::hashOperation(inner) => {
7990 <hashOperationCall as alloy_sol_types::SolCall>::abi_encode_raw(
7991 inner,
7992 out,
7993 )
7994 }
7995 Self::hashOperationBatch(inner) => {
7996 <hashOperationBatchCall as alloy_sol_types::SolCall>::abi_encode_raw(
7997 inner,
7998 out,
7999 )
8000 }
8001 Self::isOperation(inner) => {
8002 <isOperationCall as alloy_sol_types::SolCall>::abi_encode_raw(
8003 inner,
8004 out,
8005 )
8006 }
8007 Self::isOperationDone(inner) => {
8008 <isOperationDoneCall as alloy_sol_types::SolCall>::abi_encode_raw(
8009 inner,
8010 out,
8011 )
8012 }
8013 Self::isOperationPending(inner) => {
8014 <isOperationPendingCall as alloy_sol_types::SolCall>::abi_encode_raw(
8015 inner,
8016 out,
8017 )
8018 }
8019 Self::isOperationReady(inner) => {
8020 <isOperationReadyCall as alloy_sol_types::SolCall>::abi_encode_raw(
8021 inner,
8022 out,
8023 )
8024 }
8025 Self::onERC1155BatchReceived(inner) => {
8026 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
8027 inner,
8028 out,
8029 )
8030 }
8031 Self::onERC1155Received(inner) => {
8032 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
8033 inner,
8034 out,
8035 )
8036 }
8037 Self::onERC721Received(inner) => {
8038 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
8039 inner,
8040 out,
8041 )
8042 }
8043 Self::renounceRole(inner) => {
8044 <renounceRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
8045 inner,
8046 out,
8047 )
8048 }
8049 Self::revokeRole(inner) => {
8050 <revokeRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
8051 inner,
8052 out,
8053 )
8054 }
8055 Self::schedule(inner) => {
8056 <scheduleCall as alloy_sol_types::SolCall>::abi_encode_raw(
8057 inner,
8058 out,
8059 )
8060 }
8061 Self::scheduleBatch(inner) => {
8062 <scheduleBatchCall as alloy_sol_types::SolCall>::abi_encode_raw(
8063 inner,
8064 out,
8065 )
8066 }
8067 Self::supportsInterface(inner) => {
8068 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(
8069 inner,
8070 out,
8071 )
8072 }
8073 Self::updateDelay(inner) => {
8074 <updateDelayCall as alloy_sol_types::SolCall>::abi_encode_raw(
8075 inner,
8076 out,
8077 )
8078 }
8079 }
8080 }
8081 }
8082 #[derive(Debug, PartialEq, Eq, Hash)]
8084 pub enum SafeExitTimelockErrors {
8085 #[allow(missing_docs)]
8086 AccessControlBadConfirmation(AccessControlBadConfirmation),
8087 #[allow(missing_docs)]
8088 AccessControlUnauthorizedAccount(AccessControlUnauthorizedAccount),
8089 #[allow(missing_docs)]
8090 FailedInnerCall(FailedInnerCall),
8091 #[allow(missing_docs)]
8092 TimelockInsufficientDelay(TimelockInsufficientDelay),
8093 #[allow(missing_docs)]
8094 TimelockInvalidOperationLength(TimelockInvalidOperationLength),
8095 #[allow(missing_docs)]
8096 TimelockUnauthorizedCaller(TimelockUnauthorizedCaller),
8097 #[allow(missing_docs)]
8098 TimelockUnexecutedPredecessor(TimelockUnexecutedPredecessor),
8099 #[allow(missing_docs)]
8100 TimelockUnexpectedOperationState(TimelockUnexpectedOperationState),
8101 }
8102 #[automatically_derived]
8103 impl SafeExitTimelockErrors {
8104 pub const SELECTORS: &'static [[u8; 4usize]] = &[
8111 [20u8, 37u8, 234u8, 66u8],
8112 [84u8, 51u8, 102u8, 9u8],
8113 [94u8, 173u8, 142u8, 181u8],
8114 [102u8, 151u8, 178u8, 50u8],
8115 [144u8, 169u8, 166u8, 24u8],
8116 [226u8, 81u8, 125u8, 63u8],
8117 [226u8, 133u8, 12u8, 89u8],
8118 [255u8, 176u8, 50u8, 17u8],
8119 ];
8120 }
8121 #[automatically_derived]
8122 impl alloy_sol_types::SolInterface for SafeExitTimelockErrors {
8123 const NAME: &'static str = "SafeExitTimelockErrors";
8124 const MIN_DATA_LENGTH: usize = 0usize;
8125 const COUNT: usize = 8usize;
8126 #[inline]
8127 fn selector(&self) -> [u8; 4] {
8128 match self {
8129 Self::AccessControlBadConfirmation(_) => {
8130 <AccessControlBadConfirmation as alloy_sol_types::SolError>::SELECTOR
8131 }
8132 Self::AccessControlUnauthorizedAccount(_) => {
8133 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
8134 }
8135 Self::FailedInnerCall(_) => {
8136 <FailedInnerCall as alloy_sol_types::SolError>::SELECTOR
8137 }
8138 Self::TimelockInsufficientDelay(_) => {
8139 <TimelockInsufficientDelay as alloy_sol_types::SolError>::SELECTOR
8140 }
8141 Self::TimelockInvalidOperationLength(_) => {
8142 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::SELECTOR
8143 }
8144 Self::TimelockUnauthorizedCaller(_) => {
8145 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::SELECTOR
8146 }
8147 Self::TimelockUnexecutedPredecessor(_) => {
8148 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::SELECTOR
8149 }
8150 Self::TimelockUnexpectedOperationState(_) => {
8151 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::SELECTOR
8152 }
8153 }
8154 }
8155 #[inline]
8156 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
8157 Self::SELECTORS.get(i).copied()
8158 }
8159 #[inline]
8160 fn valid_selector(selector: [u8; 4]) -> bool {
8161 Self::SELECTORS.binary_search(&selector).is_ok()
8162 }
8163 #[inline]
8164 #[allow(non_snake_case)]
8165 fn abi_decode_raw(
8166 selector: [u8; 4],
8167 data: &[u8],
8168 validate: bool,
8169 ) -> alloy_sol_types::Result<Self> {
8170 static DECODE_SHIMS: &[fn(
8171 &[u8],
8172 bool,
8173 ) -> alloy_sol_types::Result<SafeExitTimelockErrors>] = &[
8174 {
8175 fn FailedInnerCall(
8176 data: &[u8],
8177 validate: bool,
8178 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
8179 <FailedInnerCall as alloy_sol_types::SolError>::abi_decode_raw(
8180 data,
8181 validate,
8182 )
8183 .map(SafeExitTimelockErrors::FailedInnerCall)
8184 }
8185 FailedInnerCall
8186 },
8187 {
8188 fn TimelockInsufficientDelay(
8189 data: &[u8],
8190 validate: bool,
8191 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
8192 <TimelockInsufficientDelay as alloy_sol_types::SolError>::abi_decode_raw(
8193 data,
8194 validate,
8195 )
8196 .map(SafeExitTimelockErrors::TimelockInsufficientDelay)
8197 }
8198 TimelockInsufficientDelay
8199 },
8200 {
8201 fn TimelockUnexpectedOperationState(
8202 data: &[u8],
8203 validate: bool,
8204 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
8205 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::abi_decode_raw(
8206 data,
8207 validate,
8208 )
8209 .map(
8210 SafeExitTimelockErrors::TimelockUnexpectedOperationState,
8211 )
8212 }
8213 TimelockUnexpectedOperationState
8214 },
8215 {
8216 fn AccessControlBadConfirmation(
8217 data: &[u8],
8218 validate: bool,
8219 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
8220 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_decode_raw(
8221 data,
8222 validate,
8223 )
8224 .map(SafeExitTimelockErrors::AccessControlBadConfirmation)
8225 }
8226 AccessControlBadConfirmation
8227 },
8228 {
8229 fn TimelockUnexecutedPredecessor(
8230 data: &[u8],
8231 validate: bool,
8232 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
8233 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::abi_decode_raw(
8234 data,
8235 validate,
8236 )
8237 .map(SafeExitTimelockErrors::TimelockUnexecutedPredecessor)
8238 }
8239 TimelockUnexecutedPredecessor
8240 },
8241 {
8242 fn AccessControlUnauthorizedAccount(
8243 data: &[u8],
8244 validate: bool,
8245 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
8246 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw(
8247 data,
8248 validate,
8249 )
8250 .map(
8251 SafeExitTimelockErrors::AccessControlUnauthorizedAccount,
8252 )
8253 }
8254 AccessControlUnauthorizedAccount
8255 },
8256 {
8257 fn TimelockUnauthorizedCaller(
8258 data: &[u8],
8259 validate: bool,
8260 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
8261 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::abi_decode_raw(
8262 data,
8263 validate,
8264 )
8265 .map(SafeExitTimelockErrors::TimelockUnauthorizedCaller)
8266 }
8267 TimelockUnauthorizedCaller
8268 },
8269 {
8270 fn TimelockInvalidOperationLength(
8271 data: &[u8],
8272 validate: bool,
8273 ) -> alloy_sol_types::Result<SafeExitTimelockErrors> {
8274 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::abi_decode_raw(
8275 data,
8276 validate,
8277 )
8278 .map(SafeExitTimelockErrors::TimelockInvalidOperationLength)
8279 }
8280 TimelockInvalidOperationLength
8281 },
8282 ];
8283 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
8284 return Err(
8285 alloy_sol_types::Error::unknown_selector(
8286 <Self as alloy_sol_types::SolInterface>::NAME,
8287 selector,
8288 ),
8289 );
8290 };
8291 DECODE_SHIMS[idx](data, validate)
8292 }
8293 #[inline]
8294 fn abi_encoded_size(&self) -> usize {
8295 match self {
8296 Self::AccessControlBadConfirmation(inner) => {
8297 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_encoded_size(
8298 inner,
8299 )
8300 }
8301 Self::AccessControlUnauthorizedAccount(inner) => {
8302 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
8303 inner,
8304 )
8305 }
8306 Self::FailedInnerCall(inner) => {
8307 <FailedInnerCall as alloy_sol_types::SolError>::abi_encoded_size(
8308 inner,
8309 )
8310 }
8311 Self::TimelockInsufficientDelay(inner) => {
8312 <TimelockInsufficientDelay as alloy_sol_types::SolError>::abi_encoded_size(
8313 inner,
8314 )
8315 }
8316 Self::TimelockInvalidOperationLength(inner) => {
8317 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::abi_encoded_size(
8318 inner,
8319 )
8320 }
8321 Self::TimelockUnauthorizedCaller(inner) => {
8322 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::abi_encoded_size(
8323 inner,
8324 )
8325 }
8326 Self::TimelockUnexecutedPredecessor(inner) => {
8327 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::abi_encoded_size(
8328 inner,
8329 )
8330 }
8331 Self::TimelockUnexpectedOperationState(inner) => {
8332 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::abi_encoded_size(
8333 inner,
8334 )
8335 }
8336 }
8337 }
8338 #[inline]
8339 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
8340 match self {
8341 Self::AccessControlBadConfirmation(inner) => {
8342 <AccessControlBadConfirmation as alloy_sol_types::SolError>::abi_encode_raw(
8343 inner,
8344 out,
8345 )
8346 }
8347 Self::AccessControlUnauthorizedAccount(inner) => {
8348 <AccessControlUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
8349 inner,
8350 out,
8351 )
8352 }
8353 Self::FailedInnerCall(inner) => {
8354 <FailedInnerCall as alloy_sol_types::SolError>::abi_encode_raw(
8355 inner,
8356 out,
8357 )
8358 }
8359 Self::TimelockInsufficientDelay(inner) => {
8360 <TimelockInsufficientDelay as alloy_sol_types::SolError>::abi_encode_raw(
8361 inner,
8362 out,
8363 )
8364 }
8365 Self::TimelockInvalidOperationLength(inner) => {
8366 <TimelockInvalidOperationLength as alloy_sol_types::SolError>::abi_encode_raw(
8367 inner,
8368 out,
8369 )
8370 }
8371 Self::TimelockUnauthorizedCaller(inner) => {
8372 <TimelockUnauthorizedCaller as alloy_sol_types::SolError>::abi_encode_raw(
8373 inner,
8374 out,
8375 )
8376 }
8377 Self::TimelockUnexecutedPredecessor(inner) => {
8378 <TimelockUnexecutedPredecessor as alloy_sol_types::SolError>::abi_encode_raw(
8379 inner,
8380 out,
8381 )
8382 }
8383 Self::TimelockUnexpectedOperationState(inner) => {
8384 <TimelockUnexpectedOperationState as alloy_sol_types::SolError>::abi_encode_raw(
8385 inner,
8386 out,
8387 )
8388 }
8389 }
8390 }
8391 }
8392 #[derive(Debug, PartialEq, Eq, Hash)]
8394 pub enum SafeExitTimelockEvents {
8395 #[allow(missing_docs)]
8396 CallExecuted(CallExecuted),
8397 #[allow(missing_docs)]
8398 CallSalt(CallSalt),
8399 #[allow(missing_docs)]
8400 CallScheduled(CallScheduled),
8401 #[allow(missing_docs)]
8402 Cancelled(Cancelled),
8403 #[allow(missing_docs)]
8404 MinDelayChange(MinDelayChange),
8405 #[allow(missing_docs)]
8406 RoleAdminChanged(RoleAdminChanged),
8407 #[allow(missing_docs)]
8408 RoleGranted(RoleGranted),
8409 #[allow(missing_docs)]
8410 RoleRevoked(RoleRevoked),
8411 }
8412 #[automatically_derived]
8413 impl SafeExitTimelockEvents {
8414 pub const SELECTORS: &'static [[u8; 32usize]] = &[
8421 [
8422 17u8, 194u8, 79u8, 78u8, 173u8, 22u8, 80u8, 124u8, 105u8, 172u8, 70u8,
8423 127u8, 189u8, 94u8, 78u8, 237u8, 95u8, 181u8, 198u8, 153u8, 98u8, 109u8,
8424 44u8, 198u8, 214u8, 100u8, 33u8, 223u8, 37u8, 56u8, 134u8, 213u8,
8425 ],
8426 [
8427 32u8, 253u8, 165u8, 253u8, 39u8, 161u8, 234u8, 123u8, 245u8, 185u8, 86u8,
8428 127u8, 20u8, 58u8, 197u8, 71u8, 11u8, 176u8, 89u8, 55u8, 74u8, 39u8,
8429 232u8, 246u8, 124u8, 180u8, 79u8, 148u8, 111u8, 109u8, 3u8, 135u8,
8430 ],
8431 [
8432 47u8, 135u8, 136u8, 17u8, 126u8, 126u8, 255u8, 29u8, 130u8, 233u8, 38u8,
8433 236u8, 121u8, 73u8, 1u8, 209u8, 124u8, 120u8, 2u8, 74u8, 80u8, 39u8, 9u8,
8434 64u8, 48u8, 69u8, 64u8, 167u8, 51u8, 101u8, 111u8, 13u8,
8435 ],
8436 [
8437 76u8, 244u8, 65u8, 12u8, 197u8, 112u8, 64u8, 228u8, 72u8, 98u8, 239u8,
8438 15u8, 69u8, 243u8, 221u8, 90u8, 94u8, 2u8, 219u8, 142u8, 184u8, 173u8,
8439 214u8, 72u8, 212u8, 176u8, 226u8, 54u8, 241u8, 208u8, 125u8, 202u8,
8440 ],
8441 [
8442 186u8, 161u8, 235u8, 34u8, 242u8, 164u8, 146u8, 186u8, 26u8, 95u8, 234u8,
8443 97u8, 184u8, 223u8, 77u8, 39u8, 198u8, 200u8, 181u8, 243u8, 151u8, 30u8,
8444 99u8, 187u8, 88u8, 250u8, 20u8, 255u8, 114u8, 238u8, 219u8, 112u8,
8445 ],
8446 [
8447 189u8, 121u8, 184u8, 111u8, 254u8, 10u8, 184u8, 232u8, 119u8, 97u8, 81u8,
8448 81u8, 66u8, 23u8, 205u8, 124u8, 172u8, 213u8, 44u8, 144u8, 159u8, 102u8,
8449 71u8, 92u8, 58u8, 244u8, 78u8, 18u8, 159u8, 11u8, 0u8, 255u8,
8450 ],
8451 [
8452 194u8, 97u8, 126u8, 250u8, 105u8, 186u8, 182u8, 103u8, 130u8, 250u8,
8453 33u8, 149u8, 67u8, 113u8, 67u8, 56u8, 72u8, 156u8, 78u8, 158u8, 23u8,
8454 130u8, 113u8, 86u8, 10u8, 145u8, 184u8, 44u8, 63u8, 97u8, 43u8, 88u8,
8455 ],
8456 [
8457 246u8, 57u8, 31u8, 92u8, 50u8, 217u8, 198u8, 157u8, 42u8, 71u8, 234u8,
8458 103u8, 11u8, 68u8, 41u8, 116u8, 181u8, 57u8, 53u8, 209u8, 237u8, 199u8,
8459 253u8, 100u8, 235u8, 33u8, 224u8, 71u8, 168u8, 57u8, 23u8, 27u8,
8460 ],
8461 ];
8462 }
8463 #[automatically_derived]
8464 impl alloy_sol_types::SolEventInterface for SafeExitTimelockEvents {
8465 const NAME: &'static str = "SafeExitTimelockEvents";
8466 const COUNT: usize = 8usize;
8467 fn decode_raw_log(
8468 topics: &[alloy_sol_types::Word],
8469 data: &[u8],
8470 validate: bool,
8471 ) -> alloy_sol_types::Result<Self> {
8472 match topics.first().copied() {
8473 Some(<CallExecuted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8474 <CallExecuted as alloy_sol_types::SolEvent>::decode_raw_log(
8475 topics,
8476 data,
8477 validate,
8478 )
8479 .map(Self::CallExecuted)
8480 }
8481 Some(<CallSalt as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8482 <CallSalt as alloy_sol_types::SolEvent>::decode_raw_log(
8483 topics,
8484 data,
8485 validate,
8486 )
8487 .map(Self::CallSalt)
8488 }
8489 Some(<CallScheduled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8490 <CallScheduled as alloy_sol_types::SolEvent>::decode_raw_log(
8491 topics,
8492 data,
8493 validate,
8494 )
8495 .map(Self::CallScheduled)
8496 }
8497 Some(<Cancelled as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8498 <Cancelled as alloy_sol_types::SolEvent>::decode_raw_log(
8499 topics,
8500 data,
8501 validate,
8502 )
8503 .map(Self::Cancelled)
8504 }
8505 Some(<MinDelayChange as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8506 <MinDelayChange as alloy_sol_types::SolEvent>::decode_raw_log(
8507 topics,
8508 data,
8509 validate,
8510 )
8511 .map(Self::MinDelayChange)
8512 }
8513 Some(<RoleAdminChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8514 <RoleAdminChanged as alloy_sol_types::SolEvent>::decode_raw_log(
8515 topics,
8516 data,
8517 validate,
8518 )
8519 .map(Self::RoleAdminChanged)
8520 }
8521 Some(<RoleGranted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8522 <RoleGranted as alloy_sol_types::SolEvent>::decode_raw_log(
8523 topics,
8524 data,
8525 validate,
8526 )
8527 .map(Self::RoleGranted)
8528 }
8529 Some(<RoleRevoked as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
8530 <RoleRevoked as alloy_sol_types::SolEvent>::decode_raw_log(
8531 topics,
8532 data,
8533 validate,
8534 )
8535 .map(Self::RoleRevoked)
8536 }
8537 _ => {
8538 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
8539 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
8540 log: alloy_sol_types::private::Box::new(
8541 alloy_sol_types::private::LogData::new_unchecked(
8542 topics.to_vec(),
8543 data.to_vec().into(),
8544 ),
8545 ),
8546 })
8547 }
8548 }
8549 }
8550 }
8551 #[automatically_derived]
8552 impl alloy_sol_types::private::IntoLogData for SafeExitTimelockEvents {
8553 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
8554 match self {
8555 Self::CallExecuted(inner) => {
8556 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8557 }
8558 Self::CallSalt(inner) => {
8559 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8560 }
8561 Self::CallScheduled(inner) => {
8562 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8563 }
8564 Self::Cancelled(inner) => {
8565 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8566 }
8567 Self::MinDelayChange(inner) => {
8568 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8569 }
8570 Self::RoleAdminChanged(inner) => {
8571 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8572 }
8573 Self::RoleGranted(inner) => {
8574 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8575 }
8576 Self::RoleRevoked(inner) => {
8577 alloy_sol_types::private::IntoLogData::to_log_data(inner)
8578 }
8579 }
8580 }
8581 fn into_log_data(self) -> alloy_sol_types::private::LogData {
8582 match self {
8583 Self::CallExecuted(inner) => {
8584 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8585 }
8586 Self::CallSalt(inner) => {
8587 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8588 }
8589 Self::CallScheduled(inner) => {
8590 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8591 }
8592 Self::Cancelled(inner) => {
8593 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8594 }
8595 Self::MinDelayChange(inner) => {
8596 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8597 }
8598 Self::RoleAdminChanged(inner) => {
8599 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8600 }
8601 Self::RoleGranted(inner) => {
8602 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8603 }
8604 Self::RoleRevoked(inner) => {
8605 alloy_sol_types::private::IntoLogData::into_log_data(inner)
8606 }
8607 }
8608 }
8609 }
8610 use alloy::contract as alloy_contract;
8611 #[inline]
8615 pub const fn new<
8616 T: alloy_contract::private::Transport + ::core::clone::Clone,
8617 P: alloy_contract::private::Provider<T, N>,
8618 N: alloy_contract::private::Network,
8619 >(
8620 address: alloy_sol_types::private::Address,
8621 provider: P,
8622 ) -> SafeExitTimelockInstance<T, P, N> {
8623 SafeExitTimelockInstance::<T, P, N>::new(address, provider)
8624 }
8625 #[inline]
8631 pub fn deploy<
8632 T: alloy_contract::private::Transport + ::core::clone::Clone,
8633 P: alloy_contract::private::Provider<T, N>,
8634 N: alloy_contract::private::Network,
8635 >(
8636 provider: P,
8637 minDelay: alloy::sol_types::private::primitives::aliases::U256,
8638 proposers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
8639 executors: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
8640 admin: alloy::sol_types::private::Address,
8641 ) -> impl ::core::future::Future<
8642 Output = alloy_contract::Result<SafeExitTimelockInstance<T, P, N>>,
8643 > {
8644 SafeExitTimelockInstance::<
8645 T,
8646 P,
8647 N,
8648 >::deploy(provider, minDelay, proposers, executors, admin)
8649 }
8650 #[inline]
8656 pub fn deploy_builder<
8657 T: alloy_contract::private::Transport + ::core::clone::Clone,
8658 P: alloy_contract::private::Provider<T, N>,
8659 N: alloy_contract::private::Network,
8660 >(
8661 provider: P,
8662 minDelay: alloy::sol_types::private::primitives::aliases::U256,
8663 proposers: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
8664 executors: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
8665 admin: alloy::sol_types::private::Address,
8666 ) -> alloy_contract::RawCallBuilder<T, P, N> {
8667 SafeExitTimelockInstance::<
8668 T,
8669 P,
8670 N,
8671 >::deploy_builder(provider, minDelay, proposers, executors, admin)
8672 }
8673 #[derive(Clone)]
8685 pub struct SafeExitTimelockInstance<T, P, N = alloy_contract::private::Ethereum> {
8686 address: alloy_sol_types::private::Address,
8687 provider: P,
8688 _network_transport: ::core::marker::PhantomData<(N, T)>,
8689 }
8690 #[automatically_derived]
8691 impl<T, P, N> ::core::fmt::Debug for SafeExitTimelockInstance<T, P, N> {
8692 #[inline]
8693 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8694 f.debug_tuple("SafeExitTimelockInstance").field(&self.address).finish()
8695 }
8696 }
8697 #[automatically_derived]
8699 impl<
8700 T: alloy_contract::private::Transport + ::core::clone::Clone,
8701 P: alloy_contract::private::Provider<T, N>,
8702 N: alloy_contract::private::Network,
8703 > SafeExitTimelockInstance<T, P, N> {
8704 #[inline]
8708 pub const fn new(
8709 address: alloy_sol_types::private::Address,
8710 provider: P,
8711 ) -> Self {
8712 Self {
8713 address,
8714 provider,
8715 _network_transport: ::core::marker::PhantomData,
8716 }
8717 }
8718 #[inline]
8724 pub async fn deploy(
8725 provider: P,
8726 minDelay: alloy::sol_types::private::primitives::aliases::U256,
8727 proposers: alloy::sol_types::private::Vec<
8728 alloy::sol_types::private::Address,
8729 >,
8730 executors: alloy::sol_types::private::Vec<
8731 alloy::sol_types::private::Address,
8732 >,
8733 admin: alloy::sol_types::private::Address,
8734 ) -> alloy_contract::Result<SafeExitTimelockInstance<T, P, N>> {
8735 let call_builder = Self::deploy_builder(
8736 provider,
8737 minDelay,
8738 proposers,
8739 executors,
8740 admin,
8741 );
8742 let contract_address = call_builder.deploy().await?;
8743 Ok(Self::new(contract_address, call_builder.provider))
8744 }
8745 #[inline]
8751 pub fn deploy_builder(
8752 provider: P,
8753 minDelay: alloy::sol_types::private::primitives::aliases::U256,
8754 proposers: alloy::sol_types::private::Vec<
8755 alloy::sol_types::private::Address,
8756 >,
8757 executors: alloy::sol_types::private::Vec<
8758 alloy::sol_types::private::Address,
8759 >,
8760 admin: alloy::sol_types::private::Address,
8761 ) -> alloy_contract::RawCallBuilder<T, P, N> {
8762 alloy_contract::RawCallBuilder::new_raw_deploy(
8763 provider,
8764 [
8765 &BYTECODE[..],
8766 &alloy_sol_types::SolConstructor::abi_encode(
8767 &constructorCall {
8768 minDelay,
8769 proposers,
8770 executors,
8771 admin,
8772 },
8773 )[..],
8774 ]
8775 .concat()
8776 .into(),
8777 )
8778 }
8779 #[inline]
8781 pub const fn address(&self) -> &alloy_sol_types::private::Address {
8782 &self.address
8783 }
8784 #[inline]
8786 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
8787 self.address = address;
8788 }
8789 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
8791 self.set_address(address);
8792 self
8793 }
8794 #[inline]
8796 pub const fn provider(&self) -> &P {
8797 &self.provider
8798 }
8799 }
8800 impl<T, P: ::core::clone::Clone, N> SafeExitTimelockInstance<T, &P, N> {
8801 #[inline]
8803 pub fn with_cloned_provider(self) -> SafeExitTimelockInstance<T, P, N> {
8804 SafeExitTimelockInstance {
8805 address: self.address,
8806 provider: ::core::clone::Clone::clone(&self.provider),
8807 _network_transport: ::core::marker::PhantomData,
8808 }
8809 }
8810 }
8811 #[automatically_derived]
8813 impl<
8814 T: alloy_contract::private::Transport + ::core::clone::Clone,
8815 P: alloy_contract::private::Provider<T, N>,
8816 N: alloy_contract::private::Network,
8817 > SafeExitTimelockInstance<T, P, N> {
8818 pub fn call_builder<C: alloy_sol_types::SolCall>(
8823 &self,
8824 call: &C,
8825 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
8826 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
8827 }
8828 pub fn CANCELLER_ROLE(
8830 &self,
8831 ) -> alloy_contract::SolCallBuilder<T, &P, CANCELLER_ROLECall, N> {
8832 self.call_builder(&CANCELLER_ROLECall {})
8833 }
8834 pub fn DEFAULT_ADMIN_ROLE(
8836 &self,
8837 ) -> alloy_contract::SolCallBuilder<T, &P, DEFAULT_ADMIN_ROLECall, N> {
8838 self.call_builder(&DEFAULT_ADMIN_ROLECall {})
8839 }
8840 pub fn EXECUTOR_ROLE(
8842 &self,
8843 ) -> alloy_contract::SolCallBuilder<T, &P, EXECUTOR_ROLECall, N> {
8844 self.call_builder(&EXECUTOR_ROLECall {})
8845 }
8846 pub fn PROPOSER_ROLE(
8848 &self,
8849 ) -> alloy_contract::SolCallBuilder<T, &P, PROPOSER_ROLECall, N> {
8850 self.call_builder(&PROPOSER_ROLECall {})
8851 }
8852 pub fn cancel(
8854 &self,
8855 id: alloy::sol_types::private::FixedBytes<32>,
8856 ) -> alloy_contract::SolCallBuilder<T, &P, cancelCall, N> {
8857 self.call_builder(&cancelCall { id })
8858 }
8859 pub fn execute(
8861 &self,
8862 target: alloy::sol_types::private::Address,
8863 value: alloy::sol_types::private::primitives::aliases::U256,
8864 payload: alloy::sol_types::private::Bytes,
8865 predecessor: alloy::sol_types::private::FixedBytes<32>,
8866 salt: alloy::sol_types::private::FixedBytes<32>,
8867 ) -> alloy_contract::SolCallBuilder<T, &P, executeCall, N> {
8868 self.call_builder(
8869 &executeCall {
8870 target,
8871 value,
8872 payload,
8873 predecessor,
8874 salt,
8875 },
8876 )
8877 }
8878 pub fn executeBatch(
8880 &self,
8881 targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
8882 values: alloy::sol_types::private::Vec<
8883 alloy::sol_types::private::primitives::aliases::U256,
8884 >,
8885 payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
8886 predecessor: alloy::sol_types::private::FixedBytes<32>,
8887 salt: alloy::sol_types::private::FixedBytes<32>,
8888 ) -> alloy_contract::SolCallBuilder<T, &P, executeBatchCall, N> {
8889 self.call_builder(
8890 &executeBatchCall {
8891 targets,
8892 values,
8893 payloads,
8894 predecessor,
8895 salt,
8896 },
8897 )
8898 }
8899 pub fn getMinDelay(
8901 &self,
8902 ) -> alloy_contract::SolCallBuilder<T, &P, getMinDelayCall, N> {
8903 self.call_builder(&getMinDelayCall {})
8904 }
8905 pub fn getOperationState(
8907 &self,
8908 id: alloy::sol_types::private::FixedBytes<32>,
8909 ) -> alloy_contract::SolCallBuilder<T, &P, getOperationStateCall, N> {
8910 self.call_builder(&getOperationStateCall { id })
8911 }
8912 pub fn getRoleAdmin(
8914 &self,
8915 role: alloy::sol_types::private::FixedBytes<32>,
8916 ) -> alloy_contract::SolCallBuilder<T, &P, getRoleAdminCall, N> {
8917 self.call_builder(&getRoleAdminCall { role })
8918 }
8919 pub fn getTimestamp(
8921 &self,
8922 id: alloy::sol_types::private::FixedBytes<32>,
8923 ) -> alloy_contract::SolCallBuilder<T, &P, getTimestampCall, N> {
8924 self.call_builder(&getTimestampCall { id })
8925 }
8926 pub fn grantRole(
8928 &self,
8929 role: alloy::sol_types::private::FixedBytes<32>,
8930 account: alloy::sol_types::private::Address,
8931 ) -> alloy_contract::SolCallBuilder<T, &P, grantRoleCall, N> {
8932 self.call_builder(&grantRoleCall { role, account })
8933 }
8934 pub fn hasRole(
8936 &self,
8937 role: alloy::sol_types::private::FixedBytes<32>,
8938 account: alloy::sol_types::private::Address,
8939 ) -> alloy_contract::SolCallBuilder<T, &P, hasRoleCall, N> {
8940 self.call_builder(&hasRoleCall { role, account })
8941 }
8942 pub fn hashOperation(
8944 &self,
8945 target: alloy::sol_types::private::Address,
8946 value: alloy::sol_types::private::primitives::aliases::U256,
8947 data: alloy::sol_types::private::Bytes,
8948 predecessor: alloy::sol_types::private::FixedBytes<32>,
8949 salt: alloy::sol_types::private::FixedBytes<32>,
8950 ) -> alloy_contract::SolCallBuilder<T, &P, hashOperationCall, N> {
8951 self.call_builder(
8952 &hashOperationCall {
8953 target,
8954 value,
8955 data,
8956 predecessor,
8957 salt,
8958 },
8959 )
8960 }
8961 pub fn hashOperationBatch(
8963 &self,
8964 targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
8965 values: alloy::sol_types::private::Vec<
8966 alloy::sol_types::private::primitives::aliases::U256,
8967 >,
8968 payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
8969 predecessor: alloy::sol_types::private::FixedBytes<32>,
8970 salt: alloy::sol_types::private::FixedBytes<32>,
8971 ) -> alloy_contract::SolCallBuilder<T, &P, hashOperationBatchCall, N> {
8972 self.call_builder(
8973 &hashOperationBatchCall {
8974 targets,
8975 values,
8976 payloads,
8977 predecessor,
8978 salt,
8979 },
8980 )
8981 }
8982 pub fn isOperation(
8984 &self,
8985 id: alloy::sol_types::private::FixedBytes<32>,
8986 ) -> alloy_contract::SolCallBuilder<T, &P, isOperationCall, N> {
8987 self.call_builder(&isOperationCall { id })
8988 }
8989 pub fn isOperationDone(
8991 &self,
8992 id: alloy::sol_types::private::FixedBytes<32>,
8993 ) -> alloy_contract::SolCallBuilder<T, &P, isOperationDoneCall, N> {
8994 self.call_builder(&isOperationDoneCall { id })
8995 }
8996 pub fn isOperationPending(
8998 &self,
8999 id: alloy::sol_types::private::FixedBytes<32>,
9000 ) -> alloy_contract::SolCallBuilder<T, &P, isOperationPendingCall, N> {
9001 self.call_builder(&isOperationPendingCall { id })
9002 }
9003 pub fn isOperationReady(
9005 &self,
9006 id: alloy::sol_types::private::FixedBytes<32>,
9007 ) -> alloy_contract::SolCallBuilder<T, &P, isOperationReadyCall, N> {
9008 self.call_builder(&isOperationReadyCall { id })
9009 }
9010 pub fn onERC1155BatchReceived(
9012 &self,
9013 _0: alloy::sol_types::private::Address,
9014 _1: alloy::sol_types::private::Address,
9015 _2: alloy::sol_types::private::Vec<
9016 alloy::sol_types::private::primitives::aliases::U256,
9017 >,
9018 _3: alloy::sol_types::private::Vec<
9019 alloy::sol_types::private::primitives::aliases::U256,
9020 >,
9021 _4: alloy::sol_types::private::Bytes,
9022 ) -> alloy_contract::SolCallBuilder<T, &P, onERC1155BatchReceivedCall, N> {
9023 self.call_builder(
9024 &onERC1155BatchReceivedCall {
9025 _0,
9026 _1,
9027 _2,
9028 _3,
9029 _4,
9030 },
9031 )
9032 }
9033 pub fn onERC1155Received(
9035 &self,
9036 _0: alloy::sol_types::private::Address,
9037 _1: alloy::sol_types::private::Address,
9038 _2: alloy::sol_types::private::primitives::aliases::U256,
9039 _3: alloy::sol_types::private::primitives::aliases::U256,
9040 _4: alloy::sol_types::private::Bytes,
9041 ) -> alloy_contract::SolCallBuilder<T, &P, onERC1155ReceivedCall, N> {
9042 self.call_builder(
9043 &onERC1155ReceivedCall {
9044 _0,
9045 _1,
9046 _2,
9047 _3,
9048 _4,
9049 },
9050 )
9051 }
9052 pub fn onERC721Received(
9054 &self,
9055 _0: alloy::sol_types::private::Address,
9056 _1: alloy::sol_types::private::Address,
9057 _2: alloy::sol_types::private::primitives::aliases::U256,
9058 _3: alloy::sol_types::private::Bytes,
9059 ) -> alloy_contract::SolCallBuilder<T, &P, onERC721ReceivedCall, N> {
9060 self.call_builder(
9061 &onERC721ReceivedCall {
9062 _0,
9063 _1,
9064 _2,
9065 _3,
9066 },
9067 )
9068 }
9069 pub fn renounceRole(
9071 &self,
9072 role: alloy::sol_types::private::FixedBytes<32>,
9073 callerConfirmation: alloy::sol_types::private::Address,
9074 ) -> alloy_contract::SolCallBuilder<T, &P, renounceRoleCall, N> {
9075 self.call_builder(
9076 &renounceRoleCall {
9077 role,
9078 callerConfirmation,
9079 },
9080 )
9081 }
9082 pub fn revokeRole(
9084 &self,
9085 role: alloy::sol_types::private::FixedBytes<32>,
9086 account: alloy::sol_types::private::Address,
9087 ) -> alloy_contract::SolCallBuilder<T, &P, revokeRoleCall, N> {
9088 self.call_builder(&revokeRoleCall { role, account })
9089 }
9090 pub fn schedule(
9092 &self,
9093 target: alloy::sol_types::private::Address,
9094 value: alloy::sol_types::private::primitives::aliases::U256,
9095 data: alloy::sol_types::private::Bytes,
9096 predecessor: alloy::sol_types::private::FixedBytes<32>,
9097 salt: alloy::sol_types::private::FixedBytes<32>,
9098 delay: alloy::sol_types::private::primitives::aliases::U256,
9099 ) -> alloy_contract::SolCallBuilder<T, &P, scheduleCall, N> {
9100 self.call_builder(
9101 &scheduleCall {
9102 target,
9103 value,
9104 data,
9105 predecessor,
9106 salt,
9107 delay,
9108 },
9109 )
9110 }
9111 pub fn scheduleBatch(
9113 &self,
9114 targets: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9115 values: alloy::sol_types::private::Vec<
9116 alloy::sol_types::private::primitives::aliases::U256,
9117 >,
9118 payloads: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
9119 predecessor: alloy::sol_types::private::FixedBytes<32>,
9120 salt: alloy::sol_types::private::FixedBytes<32>,
9121 delay: alloy::sol_types::private::primitives::aliases::U256,
9122 ) -> alloy_contract::SolCallBuilder<T, &P, scheduleBatchCall, N> {
9123 self.call_builder(
9124 &scheduleBatchCall {
9125 targets,
9126 values,
9127 payloads,
9128 predecessor,
9129 salt,
9130 delay,
9131 },
9132 )
9133 }
9134 pub fn supportsInterface(
9136 &self,
9137 interfaceId: alloy::sol_types::private::FixedBytes<4>,
9138 ) -> alloy_contract::SolCallBuilder<T, &P, supportsInterfaceCall, N> {
9139 self.call_builder(
9140 &supportsInterfaceCall {
9141 interfaceId,
9142 },
9143 )
9144 }
9145 pub fn updateDelay(
9147 &self,
9148 newDelay: alloy::sol_types::private::primitives::aliases::U256,
9149 ) -> alloy_contract::SolCallBuilder<T, &P, updateDelayCall, N> {
9150 self.call_builder(&updateDelayCall { newDelay })
9151 }
9152 }
9153 #[automatically_derived]
9155 impl<
9156 T: alloy_contract::private::Transport + ::core::clone::Clone,
9157 P: alloy_contract::private::Provider<T, N>,
9158 N: alloy_contract::private::Network,
9159 > SafeExitTimelockInstance<T, P, N> {
9160 pub fn event_filter<E: alloy_sol_types::SolEvent>(
9165 &self,
9166 ) -> alloy_contract::Event<T, &P, E, N> {
9167 alloy_contract::Event::new_sol(&self.provider, &self.address)
9168 }
9169 pub fn CallExecuted_filter(
9171 &self,
9172 ) -> alloy_contract::Event<T, &P, CallExecuted, N> {
9173 self.event_filter::<CallExecuted>()
9174 }
9175 pub fn CallSalt_filter(&self) -> alloy_contract::Event<T, &P, CallSalt, N> {
9177 self.event_filter::<CallSalt>()
9178 }
9179 pub fn CallScheduled_filter(
9181 &self,
9182 ) -> alloy_contract::Event<T, &P, CallScheduled, N> {
9183 self.event_filter::<CallScheduled>()
9184 }
9185 pub fn Cancelled_filter(&self) -> alloy_contract::Event<T, &P, Cancelled, N> {
9187 self.event_filter::<Cancelled>()
9188 }
9189 pub fn MinDelayChange_filter(
9191 &self,
9192 ) -> alloy_contract::Event<T, &P, MinDelayChange, N> {
9193 self.event_filter::<MinDelayChange>()
9194 }
9195 pub fn RoleAdminChanged_filter(
9197 &self,
9198 ) -> alloy_contract::Event<T, &P, RoleAdminChanged, N> {
9199 self.event_filter::<RoleAdminChanged>()
9200 }
9201 pub fn RoleGranted_filter(
9203 &self,
9204 ) -> alloy_contract::Event<T, &P, RoleGranted, N> {
9205 self.event_filter::<RoleGranted>()
9206 }
9207 pub fn RoleRevoked_filter(
9209 &self,
9210 ) -> alloy_contract::Event<T, &P, RoleRevoked, N> {
9211 self.event_filter::<RoleRevoked>()
9212 }
9213 }
9214}