1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use InstantSlasher::*;
3
4#[allow(
13 non_camel_case_types,
14 non_snake_case,
15 clippy::pub_underscore_fields,
16 clippy::style,
17 clippy::empty_structs_with_brackets
18)]
19pub mod IAllocationManagerTypes {
20 use super::*;
21 use alloy::sol_types as alloy_sol_types;
22 #[derive(serde::Serialize, serde::Deserialize)]
23 #[derive(Default, Debug, PartialEq, Eq, Hash)]
24 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
28 #[derive(Clone)]
29 pub struct SlashingParams {
30 #[allow(missing_docs)]
31 pub operator: alloy::sol_types::private::Address,
32 #[allow(missing_docs)]
33 pub operatorSetId: u32,
34 #[allow(missing_docs)]
35 pub strategies: alloy::sol_types::private::Vec<
36 alloy::sol_types::private::Address,
37 >,
38 #[allow(missing_docs)]
39 pub wadsToSlash: alloy::sol_types::private::Vec<
40 alloy::sol_types::private::primitives::aliases::U256,
41 >,
42 #[allow(missing_docs)]
43 pub description: alloy::sol_types::private::String,
44 }
45 #[allow(
46 non_camel_case_types,
47 non_snake_case,
48 clippy::pub_underscore_fields,
49 clippy::style
50 )]
51 const _: () = {
52 use alloy::sol_types as alloy_sol_types;
53 #[doc(hidden)]
54 type UnderlyingSolTuple<'a> = (
55 alloy::sol_types::sol_data::Address,
56 alloy::sol_types::sol_data::Uint<32>,
57 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
58 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
59 alloy::sol_types::sol_data::String,
60 );
61 #[doc(hidden)]
62 type UnderlyingRustTuple<'a> = (
63 alloy::sol_types::private::Address,
64 u32,
65 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
66 alloy::sol_types::private::Vec<
67 alloy::sol_types::private::primitives::aliases::U256,
68 >,
69 alloy::sol_types::private::String,
70 );
71 #[cfg(test)]
72 #[allow(dead_code, unreachable_patterns)]
73 fn _type_assertion(
74 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
75 ) {
76 match _t {
77 alloy_sol_types::private::AssertTypeEq::<
78 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
79 >(_) => {}
80 }
81 }
82 #[automatically_derived]
83 #[doc(hidden)]
84 impl ::core::convert::From<SlashingParams> for UnderlyingRustTuple<'_> {
85 fn from(value: SlashingParams) -> Self {
86 (
87 value.operator,
88 value.operatorSetId,
89 value.strategies,
90 value.wadsToSlash,
91 value.description,
92 )
93 }
94 }
95 #[automatically_derived]
96 #[doc(hidden)]
97 impl ::core::convert::From<UnderlyingRustTuple<'_>> for SlashingParams {
98 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
99 Self {
100 operator: tuple.0,
101 operatorSetId: tuple.1,
102 strategies: tuple.2,
103 wadsToSlash: tuple.3,
104 description: tuple.4,
105 }
106 }
107 }
108 #[automatically_derived]
109 impl alloy_sol_types::SolValue for SlashingParams {
110 type SolType = Self;
111 }
112 #[automatically_derived]
113 impl alloy_sol_types::private::SolTypeValue<Self> for SlashingParams {
114 #[inline]
115 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
116 (
117 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
118 &self.operator,
119 ),
120 <alloy::sol_types::sol_data::Uint<
121 32,
122 > as alloy_sol_types::SolType>::tokenize(&self.operatorSetId),
123 <alloy::sol_types::sol_data::Array<
124 alloy::sol_types::sol_data::Address,
125 > as alloy_sol_types::SolType>::tokenize(&self.strategies),
126 <alloy::sol_types::sol_data::Array<
127 alloy::sol_types::sol_data::Uint<256>,
128 > as alloy_sol_types::SolType>::tokenize(&self.wadsToSlash),
129 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
130 &self.description,
131 ),
132 )
133 }
134 #[inline]
135 fn stv_abi_encoded_size(&self) -> usize {
136 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
137 return size;
138 }
139 let tuple = <UnderlyingRustTuple<
140 '_,
141 > as ::core::convert::From<Self>>::from(self.clone());
142 <UnderlyingSolTuple<
143 '_,
144 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
145 }
146 #[inline]
147 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
148 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
149 }
150 #[inline]
151 fn stv_abi_encode_packed_to(
152 &self,
153 out: &mut alloy_sol_types::private::Vec<u8>,
154 ) {
155 let tuple = <UnderlyingRustTuple<
156 '_,
157 > as ::core::convert::From<Self>>::from(self.clone());
158 <UnderlyingSolTuple<
159 '_,
160 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
161 }
162 #[inline]
163 fn stv_abi_packed_encoded_size(&self) -> usize {
164 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
165 return size;
166 }
167 let tuple = <UnderlyingRustTuple<
168 '_,
169 > as ::core::convert::From<Self>>::from(self.clone());
170 <UnderlyingSolTuple<
171 '_,
172 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
173 }
174 }
175 #[automatically_derived]
176 impl alloy_sol_types::SolType for SlashingParams {
177 type RustType = Self;
178 type Token<'a> = <UnderlyingSolTuple<
179 'a,
180 > as alloy_sol_types::SolType>::Token<'a>;
181 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
182 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
183 '_,
184 > as alloy_sol_types::SolType>::ENCODED_SIZE;
185 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
186 '_,
187 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
188 #[inline]
189 fn valid_token(token: &Self::Token<'_>) -> bool {
190 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
191 }
192 #[inline]
193 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
194 let tuple = <UnderlyingSolTuple<
195 '_,
196 > as alloy_sol_types::SolType>::detokenize(token);
197 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
198 }
199 }
200 #[automatically_derived]
201 impl alloy_sol_types::SolStruct for SlashingParams {
202 const NAME: &'static str = "SlashingParams";
203 #[inline]
204 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
205 alloy_sol_types::private::Cow::Borrowed(
206 "SlashingParams(address operator,uint32 operatorSetId,address[] strategies,uint256[] wadsToSlash,string description)",
207 )
208 }
209 #[inline]
210 fn eip712_components() -> alloy_sol_types::private::Vec<
211 alloy_sol_types::private::Cow<'static, str>,
212 > {
213 alloy_sol_types::private::Vec::new()
214 }
215 #[inline]
216 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
217 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
218 }
219 #[inline]
220 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
221 [
222 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
223 &self.operator,
224 )
225 .0,
226 <alloy::sol_types::sol_data::Uint<
227 32,
228 > as alloy_sol_types::SolType>::eip712_data_word(&self.operatorSetId)
229 .0,
230 <alloy::sol_types::sol_data::Array<
231 alloy::sol_types::sol_data::Address,
232 > as alloy_sol_types::SolType>::eip712_data_word(&self.strategies)
233 .0,
234 <alloy::sol_types::sol_data::Array<
235 alloy::sol_types::sol_data::Uint<256>,
236 > as alloy_sol_types::SolType>::eip712_data_word(&self.wadsToSlash)
237 .0,
238 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
239 &self.description,
240 )
241 .0,
242 ]
243 .concat()
244 }
245 }
246 #[automatically_derived]
247 impl alloy_sol_types::EventTopic for SlashingParams {
248 #[inline]
249 fn topic_preimage_length(rust: &Self::RustType) -> usize {
250 0usize
251 + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
252 &rust.operator,
253 )
254 + <alloy::sol_types::sol_data::Uint<
255 32,
256 > as alloy_sol_types::EventTopic>::topic_preimage_length(
257 &rust.operatorSetId,
258 )
259 + <alloy::sol_types::sol_data::Array<
260 alloy::sol_types::sol_data::Address,
261 > as alloy_sol_types::EventTopic>::topic_preimage_length(
262 &rust.strategies,
263 )
264 + <alloy::sol_types::sol_data::Array<
265 alloy::sol_types::sol_data::Uint<256>,
266 > as alloy_sol_types::EventTopic>::topic_preimage_length(
267 &rust.wadsToSlash,
268 )
269 + <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
270 &rust.description,
271 )
272 }
273 #[inline]
274 fn encode_topic_preimage(
275 rust: &Self::RustType,
276 out: &mut alloy_sol_types::private::Vec<u8>,
277 ) {
278 out.reserve(
279 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
280 );
281 <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
282 &rust.operator,
283 out,
284 );
285 <alloy::sol_types::sol_data::Uint<
286 32,
287 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
288 &rust.operatorSetId,
289 out,
290 );
291 <alloy::sol_types::sol_data::Array<
292 alloy::sol_types::sol_data::Address,
293 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
294 &rust.strategies,
295 out,
296 );
297 <alloy::sol_types::sol_data::Array<
298 alloy::sol_types::sol_data::Uint<256>,
299 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
300 &rust.wadsToSlash,
301 out,
302 );
303 <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
304 &rust.description,
305 out,
306 );
307 }
308 #[inline]
309 fn encode_topic(
310 rust: &Self::RustType,
311 ) -> alloy_sol_types::abi::token::WordToken {
312 let mut out = alloy_sol_types::private::Vec::new();
313 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
314 rust,
315 &mut out,
316 );
317 alloy_sol_types::abi::token::WordToken(
318 alloy_sol_types::private::keccak256(out),
319 )
320 }
321 }
322 };
323 use alloy::contract as alloy_contract;
324 #[inline]
328 pub const fn new<
329 P: alloy_contract::private::Provider<N>,
330 N: alloy_contract::private::Network,
331 >(
332 address: alloy_sol_types::private::Address,
333 provider: P,
334 ) -> IAllocationManagerTypesInstance<P, N> {
335 IAllocationManagerTypesInstance::<P, N>::new(address, provider)
336 }
337 #[derive(Clone)]
349 pub struct IAllocationManagerTypesInstance<
350 P,
351 N = alloy_contract::private::Ethereum,
352 > {
353 address: alloy_sol_types::private::Address,
354 provider: P,
355 _network: ::core::marker::PhantomData<N>,
356 }
357 #[automatically_derived]
358 impl<P, N> ::core::fmt::Debug for IAllocationManagerTypesInstance<P, N> {
359 #[inline]
360 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
361 f.debug_tuple("IAllocationManagerTypesInstance")
362 .field(&self.address)
363 .finish()
364 }
365 }
366 #[automatically_derived]
368 impl<
369 P: alloy_contract::private::Provider<N>,
370 N: alloy_contract::private::Network,
371 > IAllocationManagerTypesInstance<P, N> {
372 #[inline]
376 pub const fn new(
377 address: alloy_sol_types::private::Address,
378 provider: P,
379 ) -> Self {
380 Self {
381 address,
382 provider,
383 _network: ::core::marker::PhantomData,
384 }
385 }
386 #[inline]
388 pub const fn address(&self) -> &alloy_sol_types::private::Address {
389 &self.address
390 }
391 #[inline]
393 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
394 self.address = address;
395 }
396 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
398 self.set_address(address);
399 self
400 }
401 #[inline]
403 pub const fn provider(&self) -> &P {
404 &self.provider
405 }
406 }
407 impl<P: ::core::clone::Clone, N> IAllocationManagerTypesInstance<&P, N> {
408 #[inline]
410 pub fn with_cloned_provider(self) -> IAllocationManagerTypesInstance<P, N> {
411 IAllocationManagerTypesInstance {
412 address: self.address,
413 provider: ::core::clone::Clone::clone(&self.provider),
414 _network: ::core::marker::PhantomData,
415 }
416 }
417 }
418 #[automatically_derived]
420 impl<
421 P: alloy_contract::private::Provider<N>,
422 N: alloy_contract::private::Network,
423 > IAllocationManagerTypesInstance<P, N> {
424 pub fn call_builder<C: alloy_sol_types::SolCall>(
429 &self,
430 call: &C,
431 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
432 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
433 }
434 }
435 #[automatically_derived]
437 impl<
438 P: alloy_contract::private::Provider<N>,
439 N: alloy_contract::private::Network,
440 > IAllocationManagerTypesInstance<P, N> {
441 pub fn event_filter<E: alloy_sol_types::SolEvent>(
446 &self,
447 ) -> alloy_contract::Event<&P, E, N> {
448 alloy_contract::Event::new_sol(&self.provider, &self.address)
449 }
450 }
451}
452#[allow(
642 non_camel_case_types,
643 non_snake_case,
644 clippy::pub_underscore_fields,
645 clippy::style,
646 clippy::empty_structs_with_brackets
647)]
648pub mod InstantSlasher {
649 use super::*;
650 use alloy::sol_types as alloy_sol_types;
651 #[rustfmt::skip]
657 #[allow(clippy::all)]
658 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
659 b"`\xE0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\n\x058\x03\x80a\n\x05\x839\x81\x01`@\x81\x90Ra\0.\x91a\0bV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x80R\x90\x82\x16`\xA0R\x16`\xC0Ra\0\xACV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0_W__\xFD[PV[___``\x84\x86\x03\x12\x15a\0tW__\xFD[\x83Qa\0\x7F\x81a\0KV[` \x85\x01Q\x90\x93Pa\0\x90\x81a\0KV[`@\x85\x01Q\x90\x92Pa\0\xA1\x81a\0KV[\x80\x91PP\x92P\x92P\x92V[`\x80Q`\xA0Q`\xC0Qa\t\x16a\0\xEF_9_\x81\x81`\x8E\x01Ra\x02\x13\x01R_\x81\x81`\xF4\x01R\x81\x81a\x01\xA9\x01Ra\x02\x97\x01R_\x81\x81`\xCD\x01Ra\x02h\x01Ra\t\x16_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0UW_5`\xE0\x1C\x80cjf\x9BA\x14a\0YW\x80cj\x84\xA9\x85\x14a\0nW\x80c\xB14Bq\x14a\0\x89W\x80c\xCA\x8A\xA7\xC7\x14a\0\xC8W\x80c\xCF\x1DkB\x14a\0\xEFW[__\xFD[a\0la\0g6`\x04a\x03\xBEV[a\x01\x16V[\0[a\0v_T\x81V[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xB0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\x80V[a\0\xB0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\0\xB0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\x1F3a\x02\x11V[_\x80T\x81\x80a\x01-\x83a\x03\xFCV[\x90\x91UP\x90Pa\x01E\x81a\x01@\x84a\x06\"V[a\x02fV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90Pa\x01s` \x84\x01\x84a\x06\xDDV[\x81_\x81Q\x81\x10a\x01\x85Wa\x01\x85a\x06\xF8V[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16` \x91\x82\x02\x92\x90\x92\x01\x01R`@Qb\xCF*\xB5`\xE0\x1B\x81R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x90b\xCF*\xB5\x90a\x01\xDF\x90\x84\x90`\x04\x01a\x07\x0CV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x01\xF6W__\xFD[PZ\xF1\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPPPPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x81`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02cW`@Qc~W\xB1\xE1`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c65 W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xDE\x11d\xBB`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xF1W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x15\x91\x90a\x07WV[\x83`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x033\x92\x91\x90a\x07\xEFV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03JW__\xFD[PZ\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP\x80` \x01Qc\xFF\xFF\xFF\xFF\x16\x81_\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x83\x7F\x8A\x83\xCF\x9A\xFB\t\xA9\x811OO\xB3S\xB9[\x004Q\xDA\x17\n\x99\xF4\x8D\x8D\xB6GK\x06\xD7\x9F;\x84``\x01Q\x85`\x80\x01Q`@Qa\x03\xB2\x92\x91\x90a\x08\xB3V[`@Q\x80\x91\x03\x90\xA4PPV[_` \x82\x84\x03\x12\x15a\x03\xCEW__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03\xE4W__\xFD[\x82\x01`\xA0\x81\x85\x03\x12\x15a\x03\xF5W__\xFD[\x93\x92PPPV[_`\x01\x82\x01a\x04\x19WcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q`\xA0\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x04WWa\x04Wa\x04 V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x04\x86Wa\x04\x86a\x04 V[`@R\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x02cW__\xFD[\x805a\x04\xAD\x81a\x04\x8EV[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x04\xADW__\xFD[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x04\xDEWa\x04\xDEa\x04 V[P`\x05\x1B` \x01\x90V[_\x82`\x1F\x83\x01\x12a\x04\xF7W__\xFD[\x815a\x05\na\x05\x05\x82a\x04\xC5V[a\x04]V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15a\x05+W__\xFD[` \x85\x01[\x83\x81\x10\x15a\x05QW\x805a\x05C\x81a\x04\x8EV[\x83R` \x92\x83\x01\x92\x01a\x050V[P\x95\x94PPPPPV[_\x82`\x1F\x83\x01\x12a\x05jW__\xFD[\x815a\x05xa\x05\x05\x82a\x04\xC5V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15a\x05\x99W__\xFD[` \x85\x01[\x83\x81\x10\x15a\x05QW\x805\x83R` \x92\x83\x01\x92\x01a\x05\x9EV[_\x82`\x1F\x83\x01\x12a\x05\xC5W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05\xDFWa\x05\xDFa\x04 V[a\x05\xF2`\x1F\x82\x01`\x1F\x19\x16` \x01a\x04]V[\x81\x81R\x84` \x83\x86\x01\x01\x11\x15a\x06\x06W__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[_`\xA0\x826\x03\x12\x15a\x062W__\xFD[a\x06:a\x044V[a\x06C\x83a\x04\xA2V[\x81Ra\x06Q` \x84\x01a\x04\xB2V[` \x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06oW__\xFD[a\x06{6\x82\x86\x01a\x04\xE8V[`@\x83\x01RP``\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\x9AW__\xFD[a\x06\xA66\x82\x86\x01a\x05[V[``\x83\x01RP`\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\xC5W__\xFD[a\x06\xD16\x82\x86\x01a\x05\xB6V[`\x80\x83\x01RP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x06\xEDW__\xFD[\x815a\x03\xF5\x81a\x04\x8EV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x07LW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x07%V[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x07gW__\xFD[\x81Qa\x03\xF5\x81a\x04\x8EV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x07\xA2W\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x07\x84V[P\x93\x94\x93PPPPV[_\x81Q\x80\x84R_[\x81\x81\x10\x15a\x07\xD0W` \x81\x85\x01\x81\x01Q\x86\x83\x01\x82\x01R\x01a\x07\xB4V[P_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16\x82R`@` \x80\x84\x01\x82\x90R\x84Q\x90\x92\x16\x81\x84\x01R\x83\x82\x01Qc\xFF\xFF\xFF\xFF\x16``\x84\x01R\x83\x01Q`\xA0`\x80\x84\x01R\x80Q`\xE0\x84\x01\x81\x90R_\x92\x91\x90\x91\x01\x90\x82\x90a\x01\0\x85\x01\x90[\x80\x83\x10\x15a\x08lW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x82R` \x93\x84\x01\x93`\x01\x93\x90\x93\x01\x92\x90\x91\x01\x90a\x08AV[P``\x86\x01Q\x85\x82\x03`?\x19\x01`\xA0\x87\x01R\x92Pa\x08\x8A\x81\x84a\x07rV[\x92PPP`\x80\x84\x01Q`?\x19\x84\x83\x03\x01`\xC0\x85\x01Ra\x08\xA9\x82\x82a\x07\xACV[\x96\x95PPPPPPV[`@\x81R_a\x08\xC5`@\x83\x01\x85a\x07rV[\x82\x81\x03` \x84\x01Ra\x08\xD7\x81\x85a\x07\xACV[\x95\x94PPPPPV\xFE\xA2dipfsX\"\x12 \xB5\x17\xEB\xB7\xFD\xD5\x1ATs\x97\x05`\xBC\x12aj\xAF\x1F\xD6\x85\x049\xFB\x9F\xB6\xE93\xBF\xD0\xF0\xA3\xD9dsolcC\0\x08\x1B\x003",
660 );
661 #[rustfmt::skip]
667 #[allow(clippy::all)]
668 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
669 b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0UW_5`\xE0\x1C\x80cjf\x9BA\x14a\0YW\x80cj\x84\xA9\x85\x14a\0nW\x80c\xB14Bq\x14a\0\x89W\x80c\xCA\x8A\xA7\xC7\x14a\0\xC8W\x80c\xCF\x1DkB\x14a\0\xEFW[__\xFD[a\0la\0g6`\x04a\x03\xBEV[a\x01\x16V[\0[a\0v_T\x81V[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xB0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\x80V[a\0\xB0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\0\xB0\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[a\x01\x1F3a\x02\x11V[_\x80T\x81\x80a\x01-\x83a\x03\xFCV[\x90\x91UP\x90Pa\x01E\x81a\x01@\x84a\x06\"V[a\x02fV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90Pa\x01s` \x84\x01\x84a\x06\xDDV[\x81_\x81Q\x81\x10a\x01\x85Wa\x01\x85a\x06\xF8V[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16` \x91\x82\x02\x92\x90\x92\x01\x01R`@Qb\xCF*\xB5`\xE0\x1B\x81R\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x91\x16\x90b\xCF*\xB5\x90a\x01\xDF\x90\x84\x90`\x04\x01a\x07\x0CV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x01\xF6W__\xFD[PZ\xF1\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPPPPPV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16\x81`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02cW`@Qc~W\xB1\xE1`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PV[\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c65 W\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16c\xDE\x11d\xBB`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xF1W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x15\x91\x90a\x07WV[\x83`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x033\x92\x91\x90a\x07\xEFV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03JW__\xFD[PZ\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP\x80` \x01Qc\xFF\xFF\xFF\xFF\x16\x81_\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x83\x7F\x8A\x83\xCF\x9A\xFB\t\xA9\x811OO\xB3S\xB9[\x004Q\xDA\x17\n\x99\xF4\x8D\x8D\xB6GK\x06\xD7\x9F;\x84``\x01Q\x85`\x80\x01Q`@Qa\x03\xB2\x92\x91\x90a\x08\xB3V[`@Q\x80\x91\x03\x90\xA4PPV[_` \x82\x84\x03\x12\x15a\x03\xCEW__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03\xE4W__\xFD[\x82\x01`\xA0\x81\x85\x03\x12\x15a\x03\xF5W__\xFD[\x93\x92PPPV[_`\x01\x82\x01a\x04\x19WcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q`\xA0\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x04WWa\x04Wa\x04 V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x04\x86Wa\x04\x86a\x04 V[`@R\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x02cW__\xFD[\x805a\x04\xAD\x81a\x04\x8EV[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x04\xADW__\xFD[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x04\xDEWa\x04\xDEa\x04 V[P`\x05\x1B` \x01\x90V[_\x82`\x1F\x83\x01\x12a\x04\xF7W__\xFD[\x815a\x05\na\x05\x05\x82a\x04\xC5V[a\x04]V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15a\x05+W__\xFD[` \x85\x01[\x83\x81\x10\x15a\x05QW\x805a\x05C\x81a\x04\x8EV[\x83R` \x92\x83\x01\x92\x01a\x050V[P\x95\x94PPPPPV[_\x82`\x1F\x83\x01\x12a\x05jW__\xFD[\x815a\x05xa\x05\x05\x82a\x04\xC5V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15a\x05\x99W__\xFD[` \x85\x01[\x83\x81\x10\x15a\x05QW\x805\x83R` \x92\x83\x01\x92\x01a\x05\x9EV[_\x82`\x1F\x83\x01\x12a\x05\xC5W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05\xDFWa\x05\xDFa\x04 V[a\x05\xF2`\x1F\x82\x01`\x1F\x19\x16` \x01a\x04]V[\x81\x81R\x84` \x83\x86\x01\x01\x11\x15a\x06\x06W__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[_`\xA0\x826\x03\x12\x15a\x062W__\xFD[a\x06:a\x044V[a\x06C\x83a\x04\xA2V[\x81Ra\x06Q` \x84\x01a\x04\xB2V[` \x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06oW__\xFD[a\x06{6\x82\x86\x01a\x04\xE8V[`@\x83\x01RP``\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\x9AW__\xFD[a\x06\xA66\x82\x86\x01a\x05[V[``\x83\x01RP`\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\xC5W__\xFD[a\x06\xD16\x82\x86\x01a\x05\xB6V[`\x80\x83\x01RP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x06\xEDW__\xFD[\x815a\x03\xF5\x81a\x04\x8EV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x07LW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x07%V[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x07gW__\xFD[\x81Qa\x03\xF5\x81a\x04\x8EV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x07\xA2W\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x07\x84V[P\x93\x94\x93PPPPV[_\x81Q\x80\x84R_[\x81\x81\x10\x15a\x07\xD0W` \x81\x85\x01\x81\x01Q\x86\x83\x01\x82\x01R\x01a\x07\xB4V[P_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16\x82R`@` \x80\x84\x01\x82\x90R\x84Q\x90\x92\x16\x81\x84\x01R\x83\x82\x01Qc\xFF\xFF\xFF\xFF\x16``\x84\x01R\x83\x01Q`\xA0`\x80\x84\x01R\x80Q`\xE0\x84\x01\x81\x90R_\x92\x91\x90\x91\x01\x90\x82\x90a\x01\0\x85\x01\x90[\x80\x83\x10\x15a\x08lW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x82R` \x93\x84\x01\x93`\x01\x93\x90\x93\x01\x92\x90\x91\x01\x90a\x08AV[P``\x86\x01Q\x85\x82\x03`?\x19\x01`\xA0\x87\x01R\x92Pa\x08\x8A\x81\x84a\x07rV[\x92PPP`\x80\x84\x01Q`?\x19\x84\x83\x03\x01`\xC0\x85\x01Ra\x08\xA9\x82\x82a\x07\xACV[\x96\x95PPPPPPV[`@\x81R_a\x08\xC5`@\x83\x01\x85a\x07rV[\x82\x81\x03` \x84\x01Ra\x08\xD7\x81\x85a\x07\xACV[\x95\x94PPPPPV\xFE\xA2dipfsX\"\x12 \xB5\x17\xEB\xB7\xFD\xD5\x1ATs\x97\x05`\xBC\x12aj\xAF\x1F\xD6\x85\x049\xFB\x9F\xB6\xE93\xBF\xD0\xF0\xA3\xD9dsolcC\0\x08\x1B\x003",
670 );
671 #[derive(serde::Serialize, serde::Deserialize)]
672 #[derive(Default, Debug, PartialEq, Eq, Hash)]
673 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
678 #[derive(Clone)]
679 pub struct OnlySlasher;
680 #[allow(
681 non_camel_case_types,
682 non_snake_case,
683 clippy::pub_underscore_fields,
684 clippy::style
685 )]
686 const _: () = {
687 use alloy::sol_types as alloy_sol_types;
688 #[doc(hidden)]
689 type UnderlyingSolTuple<'a> = ();
690 #[doc(hidden)]
691 type UnderlyingRustTuple<'a> = ();
692 #[cfg(test)]
693 #[allow(dead_code, unreachable_patterns)]
694 fn _type_assertion(
695 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
696 ) {
697 match _t {
698 alloy_sol_types::private::AssertTypeEq::<
699 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
700 >(_) => {}
701 }
702 }
703 #[automatically_derived]
704 #[doc(hidden)]
705 impl ::core::convert::From<OnlySlasher> for UnderlyingRustTuple<'_> {
706 fn from(value: OnlySlasher) -> Self {
707 ()
708 }
709 }
710 #[automatically_derived]
711 #[doc(hidden)]
712 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlySlasher {
713 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
714 Self
715 }
716 }
717 #[automatically_derived]
718 impl alloy_sol_types::SolError for OnlySlasher {
719 type Parameters<'a> = UnderlyingSolTuple<'a>;
720 type Token<'a> = <Self::Parameters<
721 'a,
722 > as alloy_sol_types::SolType>::Token<'a>;
723 const SIGNATURE: &'static str = "OnlySlasher()";
724 const SELECTOR: [u8; 4] = [126u8, 87u8, 177u8, 225u8];
725 #[inline]
726 fn new<'a>(
727 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
728 ) -> Self {
729 tuple.into()
730 }
731 #[inline]
732 fn tokenize(&self) -> Self::Token<'_> {
733 ()
734 }
735 #[inline]
736 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
737 <Self::Parameters<
738 '_,
739 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
740 .map(Self::new)
741 }
742 }
743 };
744 #[derive(serde::Serialize, serde::Deserialize)]
745 #[derive(Default, Debug, PartialEq, Eq, Hash)]
746 #[allow(
751 non_camel_case_types,
752 non_snake_case,
753 clippy::pub_underscore_fields,
754 clippy::style
755 )]
756 #[derive(Clone)]
757 pub struct OperatorSlashed {
758 #[allow(missing_docs)]
759 pub slashingRequestId: alloy::sol_types::private::primitives::aliases::U256,
760 #[allow(missing_docs)]
761 pub operator: alloy::sol_types::private::Address,
762 #[allow(missing_docs)]
763 pub operatorSetId: u32,
764 #[allow(missing_docs)]
765 pub wadsToSlash: alloy::sol_types::private::Vec<
766 alloy::sol_types::private::primitives::aliases::U256,
767 >,
768 #[allow(missing_docs)]
769 pub description: alloy::sol_types::private::String,
770 }
771 #[allow(
772 non_camel_case_types,
773 non_snake_case,
774 clippy::pub_underscore_fields,
775 clippy::style
776 )]
777 const _: () = {
778 use alloy::sol_types as alloy_sol_types;
779 #[automatically_derived]
780 impl alloy_sol_types::SolEvent for OperatorSlashed {
781 type DataTuple<'a> = (
782 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
783 alloy::sol_types::sol_data::String,
784 );
785 type DataToken<'a> = <Self::DataTuple<
786 'a,
787 > as alloy_sol_types::SolType>::Token<'a>;
788 type TopicList = (
789 alloy_sol_types::sol_data::FixedBytes<32>,
790 alloy::sol_types::sol_data::Uint<256>,
791 alloy::sol_types::sol_data::Address,
792 alloy::sol_types::sol_data::Uint<32>,
793 );
794 const SIGNATURE: &'static str = "OperatorSlashed(uint256,address,uint32,uint256[],string)";
795 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
796 138u8, 131u8, 207u8, 154u8, 251u8, 9u8, 169u8, 129u8, 49u8, 79u8, 79u8,
797 179u8, 83u8, 185u8, 91u8, 0u8, 52u8, 81u8, 218u8, 23u8, 10u8, 153u8,
798 244u8, 141u8, 141u8, 182u8, 71u8, 75u8, 6u8, 215u8, 159u8, 59u8,
799 ]);
800 const ANONYMOUS: bool = false;
801 #[allow(unused_variables)]
802 #[inline]
803 fn new(
804 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
805 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
806 ) -> Self {
807 Self {
808 slashingRequestId: topics.1,
809 operator: topics.2,
810 operatorSetId: topics.3,
811 wadsToSlash: data.0,
812 description: data.1,
813 }
814 }
815 #[inline]
816 fn check_signature(
817 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
818 ) -> alloy_sol_types::Result<()> {
819 if topics.0 != Self::SIGNATURE_HASH {
820 return Err(
821 alloy_sol_types::Error::invalid_event_signature_hash(
822 Self::SIGNATURE,
823 topics.0,
824 Self::SIGNATURE_HASH,
825 ),
826 );
827 }
828 Ok(())
829 }
830 #[inline]
831 fn tokenize_body(&self) -> Self::DataToken<'_> {
832 (
833 <alloy::sol_types::sol_data::Array<
834 alloy::sol_types::sol_data::Uint<256>,
835 > as alloy_sol_types::SolType>::tokenize(&self.wadsToSlash),
836 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
837 &self.description,
838 ),
839 )
840 }
841 #[inline]
842 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
843 (
844 Self::SIGNATURE_HASH.into(),
845 self.slashingRequestId.clone(),
846 self.operator.clone(),
847 self.operatorSetId.clone(),
848 )
849 }
850 #[inline]
851 fn encode_topics_raw(
852 &self,
853 out: &mut [alloy_sol_types::abi::token::WordToken],
854 ) -> alloy_sol_types::Result<()> {
855 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
856 return Err(alloy_sol_types::Error::Overrun);
857 }
858 out[0usize] = alloy_sol_types::abi::token::WordToken(
859 Self::SIGNATURE_HASH,
860 );
861 out[1usize] = <alloy::sol_types::sol_data::Uint<
862 256,
863 > as alloy_sol_types::EventTopic>::encode_topic(&self.slashingRequestId);
864 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
865 &self.operator,
866 );
867 out[3usize] = <alloy::sol_types::sol_data::Uint<
868 32,
869 > as alloy_sol_types::EventTopic>::encode_topic(&self.operatorSetId);
870 Ok(())
871 }
872 }
873 #[automatically_derived]
874 impl alloy_sol_types::private::IntoLogData for OperatorSlashed {
875 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
876 From::from(self)
877 }
878 fn into_log_data(self) -> alloy_sol_types::private::LogData {
879 From::from(&self)
880 }
881 }
882 #[automatically_derived]
883 impl From<&OperatorSlashed> for alloy_sol_types::private::LogData {
884 #[inline]
885 fn from(this: &OperatorSlashed) -> alloy_sol_types::private::LogData {
886 alloy_sol_types::SolEvent::encode_log_data(this)
887 }
888 }
889 };
890 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
895 #[derive(Clone)]
896 pub struct constructorCall {
897 #[allow(missing_docs)]
898 pub _allocationManager: alloy::sol_types::private::Address,
899 #[allow(missing_docs)]
900 pub _slashingRegistryCoordinator: alloy::sol_types::private::Address,
901 #[allow(missing_docs)]
902 pub _slasher: alloy::sol_types::private::Address,
903 }
904 const _: () = {
905 use alloy::sol_types as alloy_sol_types;
906 {
907 #[doc(hidden)]
908 type UnderlyingSolTuple<'a> = (
909 alloy::sol_types::sol_data::Address,
910 alloy::sol_types::sol_data::Address,
911 alloy::sol_types::sol_data::Address,
912 );
913 #[doc(hidden)]
914 type UnderlyingRustTuple<'a> = (
915 alloy::sol_types::private::Address,
916 alloy::sol_types::private::Address,
917 alloy::sol_types::private::Address,
918 );
919 #[cfg(test)]
920 #[allow(dead_code, unreachable_patterns)]
921 fn _type_assertion(
922 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
923 ) {
924 match _t {
925 alloy_sol_types::private::AssertTypeEq::<
926 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
927 >(_) => {}
928 }
929 }
930 #[automatically_derived]
931 #[doc(hidden)]
932 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
933 fn from(value: constructorCall) -> Self {
934 (
935 value._allocationManager,
936 value._slashingRegistryCoordinator,
937 value._slasher,
938 )
939 }
940 }
941 #[automatically_derived]
942 #[doc(hidden)]
943 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
944 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
945 Self {
946 _allocationManager: tuple.0,
947 _slashingRegistryCoordinator: tuple.1,
948 _slasher: tuple.2,
949 }
950 }
951 }
952 }
953 #[automatically_derived]
954 impl alloy_sol_types::SolConstructor for constructorCall {
955 type Parameters<'a> = (
956 alloy::sol_types::sol_data::Address,
957 alloy::sol_types::sol_data::Address,
958 alloy::sol_types::sol_data::Address,
959 );
960 type Token<'a> = <Self::Parameters<
961 'a,
962 > as alloy_sol_types::SolType>::Token<'a>;
963 #[inline]
964 fn new<'a>(
965 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
966 ) -> Self {
967 tuple.into()
968 }
969 #[inline]
970 fn tokenize(&self) -> Self::Token<'_> {
971 (
972 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
973 &self._allocationManager,
974 ),
975 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
976 &self._slashingRegistryCoordinator,
977 ),
978 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
979 &self._slasher,
980 ),
981 )
982 }
983 }
984 };
985 #[derive(serde::Serialize, serde::Deserialize)]
986 #[derive(Default, Debug, PartialEq, Eq, Hash)]
987 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
992 #[derive(Clone)]
993 pub struct allocationManagerCall;
994 #[derive(serde::Serialize, serde::Deserialize)]
995 #[derive(Default, Debug, PartialEq, Eq, Hash)]
996 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
998 #[derive(Clone)]
999 pub struct allocationManagerReturn {
1000 #[allow(missing_docs)]
1001 pub _0: alloy::sol_types::private::Address,
1002 }
1003 #[allow(
1004 non_camel_case_types,
1005 non_snake_case,
1006 clippy::pub_underscore_fields,
1007 clippy::style
1008 )]
1009 const _: () = {
1010 use alloy::sol_types as alloy_sol_types;
1011 {
1012 #[doc(hidden)]
1013 type UnderlyingSolTuple<'a> = ();
1014 #[doc(hidden)]
1015 type UnderlyingRustTuple<'a> = ();
1016 #[cfg(test)]
1017 #[allow(dead_code, unreachable_patterns)]
1018 fn _type_assertion(
1019 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1020 ) {
1021 match _t {
1022 alloy_sol_types::private::AssertTypeEq::<
1023 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1024 >(_) => {}
1025 }
1026 }
1027 #[automatically_derived]
1028 #[doc(hidden)]
1029 impl ::core::convert::From<allocationManagerCall>
1030 for UnderlyingRustTuple<'_> {
1031 fn from(value: allocationManagerCall) -> Self {
1032 ()
1033 }
1034 }
1035 #[automatically_derived]
1036 #[doc(hidden)]
1037 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1038 for allocationManagerCall {
1039 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1040 Self
1041 }
1042 }
1043 }
1044 {
1045 #[doc(hidden)]
1046 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1047 #[doc(hidden)]
1048 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1049 #[cfg(test)]
1050 #[allow(dead_code, unreachable_patterns)]
1051 fn _type_assertion(
1052 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1053 ) {
1054 match _t {
1055 alloy_sol_types::private::AssertTypeEq::<
1056 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1057 >(_) => {}
1058 }
1059 }
1060 #[automatically_derived]
1061 #[doc(hidden)]
1062 impl ::core::convert::From<allocationManagerReturn>
1063 for UnderlyingRustTuple<'_> {
1064 fn from(value: allocationManagerReturn) -> Self {
1065 (value._0,)
1066 }
1067 }
1068 #[automatically_derived]
1069 #[doc(hidden)]
1070 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1071 for allocationManagerReturn {
1072 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1073 Self { _0: tuple.0 }
1074 }
1075 }
1076 }
1077 #[automatically_derived]
1078 impl alloy_sol_types::SolCall for allocationManagerCall {
1079 type Parameters<'a> = ();
1080 type Token<'a> = <Self::Parameters<
1081 'a,
1082 > as alloy_sol_types::SolType>::Token<'a>;
1083 type Return = alloy::sol_types::private::Address;
1084 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1085 type ReturnToken<'a> = <Self::ReturnTuple<
1086 'a,
1087 > as alloy_sol_types::SolType>::Token<'a>;
1088 const SIGNATURE: &'static str = "allocationManager()";
1089 const SELECTOR: [u8; 4] = [202u8, 138u8, 167u8, 199u8];
1090 #[inline]
1091 fn new<'a>(
1092 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1093 ) -> Self {
1094 tuple.into()
1095 }
1096 #[inline]
1097 fn tokenize(&self) -> Self::Token<'_> {
1098 ()
1099 }
1100 #[inline]
1101 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1102 (
1103 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1104 ret,
1105 ),
1106 )
1107 }
1108 #[inline]
1109 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1110 <Self::ReturnTuple<
1111 '_,
1112 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1113 .map(|r| {
1114 let r: allocationManagerReturn = r.into();
1115 r._0
1116 })
1117 }
1118 #[inline]
1119 fn abi_decode_returns_validate(
1120 data: &[u8],
1121 ) -> alloy_sol_types::Result<Self::Return> {
1122 <Self::ReturnTuple<
1123 '_,
1124 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1125 .map(|r| {
1126 let r: allocationManagerReturn = r.into();
1127 r._0
1128 })
1129 }
1130 }
1131 };
1132 #[derive(serde::Serialize, serde::Deserialize)]
1133 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1134 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1139 #[derive(Clone)]
1140 pub struct fulfillSlashingRequestCall {
1141 #[allow(missing_docs)]
1142 pub _slashingParams: <IAllocationManagerTypes::SlashingParams as alloy::sol_types::SolType>::RustType,
1143 }
1144 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1146 #[derive(Clone)]
1147 pub struct fulfillSlashingRequestReturn {}
1148 #[allow(
1149 non_camel_case_types,
1150 non_snake_case,
1151 clippy::pub_underscore_fields,
1152 clippy::style
1153 )]
1154 const _: () = {
1155 use alloy::sol_types as alloy_sol_types;
1156 {
1157 #[doc(hidden)]
1158 type UnderlyingSolTuple<'a> = (IAllocationManagerTypes::SlashingParams,);
1159 #[doc(hidden)]
1160 type UnderlyingRustTuple<'a> = (
1161 <IAllocationManagerTypes::SlashingParams as alloy::sol_types::SolType>::RustType,
1162 );
1163 #[cfg(test)]
1164 #[allow(dead_code, unreachable_patterns)]
1165 fn _type_assertion(
1166 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1167 ) {
1168 match _t {
1169 alloy_sol_types::private::AssertTypeEq::<
1170 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1171 >(_) => {}
1172 }
1173 }
1174 #[automatically_derived]
1175 #[doc(hidden)]
1176 impl ::core::convert::From<fulfillSlashingRequestCall>
1177 for UnderlyingRustTuple<'_> {
1178 fn from(value: fulfillSlashingRequestCall) -> Self {
1179 (value._slashingParams,)
1180 }
1181 }
1182 #[automatically_derived]
1183 #[doc(hidden)]
1184 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1185 for fulfillSlashingRequestCall {
1186 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1187 Self { _slashingParams: tuple.0 }
1188 }
1189 }
1190 }
1191 {
1192 #[doc(hidden)]
1193 type UnderlyingSolTuple<'a> = ();
1194 #[doc(hidden)]
1195 type UnderlyingRustTuple<'a> = ();
1196 #[cfg(test)]
1197 #[allow(dead_code, unreachable_patterns)]
1198 fn _type_assertion(
1199 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1200 ) {
1201 match _t {
1202 alloy_sol_types::private::AssertTypeEq::<
1203 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1204 >(_) => {}
1205 }
1206 }
1207 #[automatically_derived]
1208 #[doc(hidden)]
1209 impl ::core::convert::From<fulfillSlashingRequestReturn>
1210 for UnderlyingRustTuple<'_> {
1211 fn from(value: fulfillSlashingRequestReturn) -> Self {
1212 ()
1213 }
1214 }
1215 #[automatically_derived]
1216 #[doc(hidden)]
1217 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1218 for fulfillSlashingRequestReturn {
1219 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1220 Self {}
1221 }
1222 }
1223 }
1224 impl fulfillSlashingRequestReturn {
1225 fn _tokenize(
1226 &self,
1227 ) -> <fulfillSlashingRequestCall as alloy_sol_types::SolCall>::ReturnToken<
1228 '_,
1229 > {
1230 ()
1231 }
1232 }
1233 #[automatically_derived]
1234 impl alloy_sol_types::SolCall for fulfillSlashingRequestCall {
1235 type Parameters<'a> = (IAllocationManagerTypes::SlashingParams,);
1236 type Token<'a> = <Self::Parameters<
1237 'a,
1238 > as alloy_sol_types::SolType>::Token<'a>;
1239 type Return = fulfillSlashingRequestReturn;
1240 type ReturnTuple<'a> = ();
1241 type ReturnToken<'a> = <Self::ReturnTuple<
1242 'a,
1243 > as alloy_sol_types::SolType>::Token<'a>;
1244 const SIGNATURE: &'static str = "fulfillSlashingRequest((address,uint32,address[],uint256[],string))";
1245 const SELECTOR: [u8; 4] = [106u8, 102u8, 155u8, 65u8];
1246 #[inline]
1247 fn new<'a>(
1248 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1249 ) -> Self {
1250 tuple.into()
1251 }
1252 #[inline]
1253 fn tokenize(&self) -> Self::Token<'_> {
1254 (
1255 <IAllocationManagerTypes::SlashingParams as alloy_sol_types::SolType>::tokenize(
1256 &self._slashingParams,
1257 ),
1258 )
1259 }
1260 #[inline]
1261 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1262 fulfillSlashingRequestReturn::_tokenize(ret)
1263 }
1264 #[inline]
1265 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1266 <Self::ReturnTuple<
1267 '_,
1268 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1269 .map(Into::into)
1270 }
1271 #[inline]
1272 fn abi_decode_returns_validate(
1273 data: &[u8],
1274 ) -> alloy_sol_types::Result<Self::Return> {
1275 <Self::ReturnTuple<
1276 '_,
1277 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1278 .map(Into::into)
1279 }
1280 }
1281 };
1282 #[derive(serde::Serialize, serde::Deserialize)]
1283 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1284 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1289 #[derive(Clone)]
1290 pub struct nextRequestIdCall;
1291 #[derive(serde::Serialize, serde::Deserialize)]
1292 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1293 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1295 #[derive(Clone)]
1296 pub struct nextRequestIdReturn {
1297 #[allow(missing_docs)]
1298 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1299 }
1300 #[allow(
1301 non_camel_case_types,
1302 non_snake_case,
1303 clippy::pub_underscore_fields,
1304 clippy::style
1305 )]
1306 const _: () = {
1307 use alloy::sol_types as alloy_sol_types;
1308 {
1309 #[doc(hidden)]
1310 type UnderlyingSolTuple<'a> = ();
1311 #[doc(hidden)]
1312 type UnderlyingRustTuple<'a> = ();
1313 #[cfg(test)]
1314 #[allow(dead_code, unreachable_patterns)]
1315 fn _type_assertion(
1316 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1317 ) {
1318 match _t {
1319 alloy_sol_types::private::AssertTypeEq::<
1320 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1321 >(_) => {}
1322 }
1323 }
1324 #[automatically_derived]
1325 #[doc(hidden)]
1326 impl ::core::convert::From<nextRequestIdCall> for UnderlyingRustTuple<'_> {
1327 fn from(value: nextRequestIdCall) -> Self {
1328 ()
1329 }
1330 }
1331 #[automatically_derived]
1332 #[doc(hidden)]
1333 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nextRequestIdCall {
1334 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1335 Self
1336 }
1337 }
1338 }
1339 {
1340 #[doc(hidden)]
1341 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1342 #[doc(hidden)]
1343 type UnderlyingRustTuple<'a> = (
1344 alloy::sol_types::private::primitives::aliases::U256,
1345 );
1346 #[cfg(test)]
1347 #[allow(dead_code, unreachable_patterns)]
1348 fn _type_assertion(
1349 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1350 ) {
1351 match _t {
1352 alloy_sol_types::private::AssertTypeEq::<
1353 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1354 >(_) => {}
1355 }
1356 }
1357 #[automatically_derived]
1358 #[doc(hidden)]
1359 impl ::core::convert::From<nextRequestIdReturn> for UnderlyingRustTuple<'_> {
1360 fn from(value: nextRequestIdReturn) -> Self {
1361 (value._0,)
1362 }
1363 }
1364 #[automatically_derived]
1365 #[doc(hidden)]
1366 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nextRequestIdReturn {
1367 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1368 Self { _0: tuple.0 }
1369 }
1370 }
1371 }
1372 #[automatically_derived]
1373 impl alloy_sol_types::SolCall for nextRequestIdCall {
1374 type Parameters<'a> = ();
1375 type Token<'a> = <Self::Parameters<
1376 'a,
1377 > as alloy_sol_types::SolType>::Token<'a>;
1378 type Return = alloy::sol_types::private::primitives::aliases::U256;
1379 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1380 type ReturnToken<'a> = <Self::ReturnTuple<
1381 'a,
1382 > as alloy_sol_types::SolType>::Token<'a>;
1383 const SIGNATURE: &'static str = "nextRequestId()";
1384 const SELECTOR: [u8; 4] = [106u8, 132u8, 169u8, 133u8];
1385 #[inline]
1386 fn new<'a>(
1387 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1388 ) -> Self {
1389 tuple.into()
1390 }
1391 #[inline]
1392 fn tokenize(&self) -> Self::Token<'_> {
1393 ()
1394 }
1395 #[inline]
1396 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1397 (
1398 <alloy::sol_types::sol_data::Uint<
1399 256,
1400 > as alloy_sol_types::SolType>::tokenize(ret),
1401 )
1402 }
1403 #[inline]
1404 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1405 <Self::ReturnTuple<
1406 '_,
1407 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1408 .map(|r| {
1409 let r: nextRequestIdReturn = r.into();
1410 r._0
1411 })
1412 }
1413 #[inline]
1414 fn abi_decode_returns_validate(
1415 data: &[u8],
1416 ) -> alloy_sol_types::Result<Self::Return> {
1417 <Self::ReturnTuple<
1418 '_,
1419 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1420 .map(|r| {
1421 let r: nextRequestIdReturn = r.into();
1422 r._0
1423 })
1424 }
1425 }
1426 };
1427 #[derive(serde::Serialize, serde::Deserialize)]
1428 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1429 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1434 #[derive(Clone)]
1435 pub struct slasherCall;
1436 #[derive(serde::Serialize, serde::Deserialize)]
1437 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1438 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1440 #[derive(Clone)]
1441 pub struct slasherReturn {
1442 #[allow(missing_docs)]
1443 pub _0: alloy::sol_types::private::Address,
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 {
1454 #[doc(hidden)]
1455 type UnderlyingSolTuple<'a> = ();
1456 #[doc(hidden)]
1457 type UnderlyingRustTuple<'a> = ();
1458 #[cfg(test)]
1459 #[allow(dead_code, unreachable_patterns)]
1460 fn _type_assertion(
1461 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1462 ) {
1463 match _t {
1464 alloy_sol_types::private::AssertTypeEq::<
1465 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1466 >(_) => {}
1467 }
1468 }
1469 #[automatically_derived]
1470 #[doc(hidden)]
1471 impl ::core::convert::From<slasherCall> for UnderlyingRustTuple<'_> {
1472 fn from(value: slasherCall) -> Self {
1473 ()
1474 }
1475 }
1476 #[automatically_derived]
1477 #[doc(hidden)]
1478 impl ::core::convert::From<UnderlyingRustTuple<'_>> for slasherCall {
1479 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1480 Self
1481 }
1482 }
1483 }
1484 {
1485 #[doc(hidden)]
1486 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1487 #[doc(hidden)]
1488 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1489 #[cfg(test)]
1490 #[allow(dead_code, unreachable_patterns)]
1491 fn _type_assertion(
1492 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1493 ) {
1494 match _t {
1495 alloy_sol_types::private::AssertTypeEq::<
1496 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1497 >(_) => {}
1498 }
1499 }
1500 #[automatically_derived]
1501 #[doc(hidden)]
1502 impl ::core::convert::From<slasherReturn> for UnderlyingRustTuple<'_> {
1503 fn from(value: slasherReturn) -> Self {
1504 (value._0,)
1505 }
1506 }
1507 #[automatically_derived]
1508 #[doc(hidden)]
1509 impl ::core::convert::From<UnderlyingRustTuple<'_>> for slasherReturn {
1510 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1511 Self { _0: tuple.0 }
1512 }
1513 }
1514 }
1515 #[automatically_derived]
1516 impl alloy_sol_types::SolCall for slasherCall {
1517 type Parameters<'a> = ();
1518 type Token<'a> = <Self::Parameters<
1519 'a,
1520 > as alloy_sol_types::SolType>::Token<'a>;
1521 type Return = alloy::sol_types::private::Address;
1522 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1523 type ReturnToken<'a> = <Self::ReturnTuple<
1524 'a,
1525 > as alloy_sol_types::SolType>::Token<'a>;
1526 const SIGNATURE: &'static str = "slasher()";
1527 const SELECTOR: [u8; 4] = [177u8, 52u8, 66u8, 113u8];
1528 #[inline]
1529 fn new<'a>(
1530 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1531 ) -> Self {
1532 tuple.into()
1533 }
1534 #[inline]
1535 fn tokenize(&self) -> Self::Token<'_> {
1536 ()
1537 }
1538 #[inline]
1539 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1540 (
1541 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1542 ret,
1543 ),
1544 )
1545 }
1546 #[inline]
1547 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1548 <Self::ReturnTuple<
1549 '_,
1550 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1551 .map(|r| {
1552 let r: slasherReturn = r.into();
1553 r._0
1554 })
1555 }
1556 #[inline]
1557 fn abi_decode_returns_validate(
1558 data: &[u8],
1559 ) -> alloy_sol_types::Result<Self::Return> {
1560 <Self::ReturnTuple<
1561 '_,
1562 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1563 .map(|r| {
1564 let r: slasherReturn = r.into();
1565 r._0
1566 })
1567 }
1568 }
1569 };
1570 #[derive(serde::Serialize, serde::Deserialize)]
1571 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1572 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1577 #[derive(Clone)]
1578 pub struct slashingRegistryCoordinatorCall;
1579 #[derive(serde::Serialize, serde::Deserialize)]
1580 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1581 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1583 #[derive(Clone)]
1584 pub struct slashingRegistryCoordinatorReturn {
1585 #[allow(missing_docs)]
1586 pub _0: alloy::sol_types::private::Address,
1587 }
1588 #[allow(
1589 non_camel_case_types,
1590 non_snake_case,
1591 clippy::pub_underscore_fields,
1592 clippy::style
1593 )]
1594 const _: () = {
1595 use alloy::sol_types as alloy_sol_types;
1596 {
1597 #[doc(hidden)]
1598 type UnderlyingSolTuple<'a> = ();
1599 #[doc(hidden)]
1600 type UnderlyingRustTuple<'a> = ();
1601 #[cfg(test)]
1602 #[allow(dead_code, unreachable_patterns)]
1603 fn _type_assertion(
1604 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1605 ) {
1606 match _t {
1607 alloy_sol_types::private::AssertTypeEq::<
1608 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1609 >(_) => {}
1610 }
1611 }
1612 #[automatically_derived]
1613 #[doc(hidden)]
1614 impl ::core::convert::From<slashingRegistryCoordinatorCall>
1615 for UnderlyingRustTuple<'_> {
1616 fn from(value: slashingRegistryCoordinatorCall) -> Self {
1617 ()
1618 }
1619 }
1620 #[automatically_derived]
1621 #[doc(hidden)]
1622 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1623 for slashingRegistryCoordinatorCall {
1624 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1625 Self
1626 }
1627 }
1628 }
1629 {
1630 #[doc(hidden)]
1631 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1632 #[doc(hidden)]
1633 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1634 #[cfg(test)]
1635 #[allow(dead_code, unreachable_patterns)]
1636 fn _type_assertion(
1637 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1638 ) {
1639 match _t {
1640 alloy_sol_types::private::AssertTypeEq::<
1641 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1642 >(_) => {}
1643 }
1644 }
1645 #[automatically_derived]
1646 #[doc(hidden)]
1647 impl ::core::convert::From<slashingRegistryCoordinatorReturn>
1648 for UnderlyingRustTuple<'_> {
1649 fn from(value: slashingRegistryCoordinatorReturn) -> Self {
1650 (value._0,)
1651 }
1652 }
1653 #[automatically_derived]
1654 #[doc(hidden)]
1655 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1656 for slashingRegistryCoordinatorReturn {
1657 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1658 Self { _0: tuple.0 }
1659 }
1660 }
1661 }
1662 #[automatically_derived]
1663 impl alloy_sol_types::SolCall for slashingRegistryCoordinatorCall {
1664 type Parameters<'a> = ();
1665 type Token<'a> = <Self::Parameters<
1666 'a,
1667 > as alloy_sol_types::SolType>::Token<'a>;
1668 type Return = alloy::sol_types::private::Address;
1669 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1670 type ReturnToken<'a> = <Self::ReturnTuple<
1671 'a,
1672 > as alloy_sol_types::SolType>::Token<'a>;
1673 const SIGNATURE: &'static str = "slashingRegistryCoordinator()";
1674 const SELECTOR: [u8; 4] = [207u8, 29u8, 107u8, 66u8];
1675 #[inline]
1676 fn new<'a>(
1677 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1678 ) -> Self {
1679 tuple.into()
1680 }
1681 #[inline]
1682 fn tokenize(&self) -> Self::Token<'_> {
1683 ()
1684 }
1685 #[inline]
1686 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1687 (
1688 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1689 ret,
1690 ),
1691 )
1692 }
1693 #[inline]
1694 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1695 <Self::ReturnTuple<
1696 '_,
1697 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1698 .map(|r| {
1699 let r: slashingRegistryCoordinatorReturn = r.into();
1700 r._0
1701 })
1702 }
1703 #[inline]
1704 fn abi_decode_returns_validate(
1705 data: &[u8],
1706 ) -> alloy_sol_types::Result<Self::Return> {
1707 <Self::ReturnTuple<
1708 '_,
1709 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1710 .map(|r| {
1711 let r: slashingRegistryCoordinatorReturn = r.into();
1712 r._0
1713 })
1714 }
1715 }
1716 };
1717 #[derive(serde::Serialize, serde::Deserialize)]
1719 #[derive()]
1720 pub enum InstantSlasherCalls {
1721 #[allow(missing_docs)]
1722 allocationManager(allocationManagerCall),
1723 #[allow(missing_docs)]
1724 fulfillSlashingRequest(fulfillSlashingRequestCall),
1725 #[allow(missing_docs)]
1726 nextRequestId(nextRequestIdCall),
1727 #[allow(missing_docs)]
1728 slasher(slasherCall),
1729 #[allow(missing_docs)]
1730 slashingRegistryCoordinator(slashingRegistryCoordinatorCall),
1731 }
1732 #[automatically_derived]
1733 impl InstantSlasherCalls {
1734 pub const SELECTORS: &'static [[u8; 4usize]] = &[
1741 [106u8, 102u8, 155u8, 65u8],
1742 [106u8, 132u8, 169u8, 133u8],
1743 [177u8, 52u8, 66u8, 113u8],
1744 [202u8, 138u8, 167u8, 199u8],
1745 [207u8, 29u8, 107u8, 66u8],
1746 ];
1747 }
1748 #[automatically_derived]
1749 impl alloy_sol_types::SolInterface for InstantSlasherCalls {
1750 const NAME: &'static str = "InstantSlasherCalls";
1751 const MIN_DATA_LENGTH: usize = 0usize;
1752 const COUNT: usize = 5usize;
1753 #[inline]
1754 fn selector(&self) -> [u8; 4] {
1755 match self {
1756 Self::allocationManager(_) => {
1757 <allocationManagerCall as alloy_sol_types::SolCall>::SELECTOR
1758 }
1759 Self::fulfillSlashingRequest(_) => {
1760 <fulfillSlashingRequestCall as alloy_sol_types::SolCall>::SELECTOR
1761 }
1762 Self::nextRequestId(_) => {
1763 <nextRequestIdCall as alloy_sol_types::SolCall>::SELECTOR
1764 }
1765 Self::slasher(_) => <slasherCall as alloy_sol_types::SolCall>::SELECTOR,
1766 Self::slashingRegistryCoordinator(_) => {
1767 <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::SELECTOR
1768 }
1769 }
1770 }
1771 #[inline]
1772 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1773 Self::SELECTORS.get(i).copied()
1774 }
1775 #[inline]
1776 fn valid_selector(selector: [u8; 4]) -> bool {
1777 Self::SELECTORS.binary_search(&selector).is_ok()
1778 }
1779 #[inline]
1780 #[allow(non_snake_case)]
1781 fn abi_decode_raw(
1782 selector: [u8; 4],
1783 data: &[u8],
1784 ) -> alloy_sol_types::Result<Self> {
1785 static DECODE_SHIMS: &[fn(
1786 &[u8],
1787 ) -> alloy_sol_types::Result<InstantSlasherCalls>] = &[
1788 {
1789 fn fulfillSlashingRequest(
1790 data: &[u8],
1791 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1792 <fulfillSlashingRequestCall as alloy_sol_types::SolCall>::abi_decode_raw(
1793 data,
1794 )
1795 .map(InstantSlasherCalls::fulfillSlashingRequest)
1796 }
1797 fulfillSlashingRequest
1798 },
1799 {
1800 fn nextRequestId(
1801 data: &[u8],
1802 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1803 <nextRequestIdCall as alloy_sol_types::SolCall>::abi_decode_raw(
1804 data,
1805 )
1806 .map(InstantSlasherCalls::nextRequestId)
1807 }
1808 nextRequestId
1809 },
1810 {
1811 fn slasher(
1812 data: &[u8],
1813 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1814 <slasherCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
1815 .map(InstantSlasherCalls::slasher)
1816 }
1817 slasher
1818 },
1819 {
1820 fn allocationManager(
1821 data: &[u8],
1822 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1823 <allocationManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
1824 data,
1825 )
1826 .map(InstantSlasherCalls::allocationManager)
1827 }
1828 allocationManager
1829 },
1830 {
1831 fn slashingRegistryCoordinator(
1832 data: &[u8],
1833 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1834 <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
1835 data,
1836 )
1837 .map(InstantSlasherCalls::slashingRegistryCoordinator)
1838 }
1839 slashingRegistryCoordinator
1840 },
1841 ];
1842 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1843 return Err(
1844 alloy_sol_types::Error::unknown_selector(
1845 <Self as alloy_sol_types::SolInterface>::NAME,
1846 selector,
1847 ),
1848 );
1849 };
1850 DECODE_SHIMS[idx](data)
1851 }
1852 #[inline]
1853 #[allow(non_snake_case)]
1854 fn abi_decode_raw_validate(
1855 selector: [u8; 4],
1856 data: &[u8],
1857 ) -> alloy_sol_types::Result<Self> {
1858 static DECODE_VALIDATE_SHIMS: &[fn(
1859 &[u8],
1860 ) -> alloy_sol_types::Result<InstantSlasherCalls>] = &[
1861 {
1862 fn fulfillSlashingRequest(
1863 data: &[u8],
1864 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1865 <fulfillSlashingRequestCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1866 data,
1867 )
1868 .map(InstantSlasherCalls::fulfillSlashingRequest)
1869 }
1870 fulfillSlashingRequest
1871 },
1872 {
1873 fn nextRequestId(
1874 data: &[u8],
1875 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1876 <nextRequestIdCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1877 data,
1878 )
1879 .map(InstantSlasherCalls::nextRequestId)
1880 }
1881 nextRequestId
1882 },
1883 {
1884 fn slasher(
1885 data: &[u8],
1886 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1887 <slasherCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1888 data,
1889 )
1890 .map(InstantSlasherCalls::slasher)
1891 }
1892 slasher
1893 },
1894 {
1895 fn allocationManager(
1896 data: &[u8],
1897 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1898 <allocationManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1899 data,
1900 )
1901 .map(InstantSlasherCalls::allocationManager)
1902 }
1903 allocationManager
1904 },
1905 {
1906 fn slashingRegistryCoordinator(
1907 data: &[u8],
1908 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1909 <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1910 data,
1911 )
1912 .map(InstantSlasherCalls::slashingRegistryCoordinator)
1913 }
1914 slashingRegistryCoordinator
1915 },
1916 ];
1917 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1918 return Err(
1919 alloy_sol_types::Error::unknown_selector(
1920 <Self as alloy_sol_types::SolInterface>::NAME,
1921 selector,
1922 ),
1923 );
1924 };
1925 DECODE_VALIDATE_SHIMS[idx](data)
1926 }
1927 #[inline]
1928 fn abi_encoded_size(&self) -> usize {
1929 match self {
1930 Self::allocationManager(inner) => {
1931 <allocationManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
1932 inner,
1933 )
1934 }
1935 Self::fulfillSlashingRequest(inner) => {
1936 <fulfillSlashingRequestCall as alloy_sol_types::SolCall>::abi_encoded_size(
1937 inner,
1938 )
1939 }
1940 Self::nextRequestId(inner) => {
1941 <nextRequestIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
1942 inner,
1943 )
1944 }
1945 Self::slasher(inner) => {
1946 <slasherCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1947 }
1948 Self::slashingRegistryCoordinator(inner) => {
1949 <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
1950 inner,
1951 )
1952 }
1953 }
1954 }
1955 #[inline]
1956 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1957 match self {
1958 Self::allocationManager(inner) => {
1959 <allocationManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
1960 inner,
1961 out,
1962 )
1963 }
1964 Self::fulfillSlashingRequest(inner) => {
1965 <fulfillSlashingRequestCall as alloy_sol_types::SolCall>::abi_encode_raw(
1966 inner,
1967 out,
1968 )
1969 }
1970 Self::nextRequestId(inner) => {
1971 <nextRequestIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
1972 inner,
1973 out,
1974 )
1975 }
1976 Self::slasher(inner) => {
1977 <slasherCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
1978 }
1979 Self::slashingRegistryCoordinator(inner) => {
1980 <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
1981 inner,
1982 out,
1983 )
1984 }
1985 }
1986 }
1987 }
1988 #[derive(serde::Serialize, serde::Deserialize)]
1990 #[derive(Debug, PartialEq, Eq, Hash)]
1991 pub enum InstantSlasherErrors {
1992 #[allow(missing_docs)]
1993 OnlySlasher(OnlySlasher),
1994 }
1995 #[automatically_derived]
1996 impl InstantSlasherErrors {
1997 pub const SELECTORS: &'static [[u8; 4usize]] = &[[126u8, 87u8, 177u8, 225u8]];
2004 }
2005 #[automatically_derived]
2006 impl alloy_sol_types::SolInterface for InstantSlasherErrors {
2007 const NAME: &'static str = "InstantSlasherErrors";
2008 const MIN_DATA_LENGTH: usize = 0usize;
2009 const COUNT: usize = 1usize;
2010 #[inline]
2011 fn selector(&self) -> [u8; 4] {
2012 match self {
2013 Self::OnlySlasher(_) => {
2014 <OnlySlasher as alloy_sol_types::SolError>::SELECTOR
2015 }
2016 }
2017 }
2018 #[inline]
2019 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2020 Self::SELECTORS.get(i).copied()
2021 }
2022 #[inline]
2023 fn valid_selector(selector: [u8; 4]) -> bool {
2024 Self::SELECTORS.binary_search(&selector).is_ok()
2025 }
2026 #[inline]
2027 #[allow(non_snake_case)]
2028 fn abi_decode_raw(
2029 selector: [u8; 4],
2030 data: &[u8],
2031 ) -> alloy_sol_types::Result<Self> {
2032 static DECODE_SHIMS: &[fn(
2033 &[u8],
2034 ) -> alloy_sol_types::Result<InstantSlasherErrors>] = &[
2035 {
2036 fn OnlySlasher(
2037 data: &[u8],
2038 ) -> alloy_sol_types::Result<InstantSlasherErrors> {
2039 <OnlySlasher as alloy_sol_types::SolError>::abi_decode_raw(data)
2040 .map(InstantSlasherErrors::OnlySlasher)
2041 }
2042 OnlySlasher
2043 },
2044 ];
2045 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2046 return Err(
2047 alloy_sol_types::Error::unknown_selector(
2048 <Self as alloy_sol_types::SolInterface>::NAME,
2049 selector,
2050 ),
2051 );
2052 };
2053 DECODE_SHIMS[idx](data)
2054 }
2055 #[inline]
2056 #[allow(non_snake_case)]
2057 fn abi_decode_raw_validate(
2058 selector: [u8; 4],
2059 data: &[u8],
2060 ) -> alloy_sol_types::Result<Self> {
2061 static DECODE_VALIDATE_SHIMS: &[fn(
2062 &[u8],
2063 ) -> alloy_sol_types::Result<InstantSlasherErrors>] = &[
2064 {
2065 fn OnlySlasher(
2066 data: &[u8],
2067 ) -> alloy_sol_types::Result<InstantSlasherErrors> {
2068 <OnlySlasher as alloy_sol_types::SolError>::abi_decode_raw_validate(
2069 data,
2070 )
2071 .map(InstantSlasherErrors::OnlySlasher)
2072 }
2073 OnlySlasher
2074 },
2075 ];
2076 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2077 return Err(
2078 alloy_sol_types::Error::unknown_selector(
2079 <Self as alloy_sol_types::SolInterface>::NAME,
2080 selector,
2081 ),
2082 );
2083 };
2084 DECODE_VALIDATE_SHIMS[idx](data)
2085 }
2086 #[inline]
2087 fn abi_encoded_size(&self) -> usize {
2088 match self {
2089 Self::OnlySlasher(inner) => {
2090 <OnlySlasher as alloy_sol_types::SolError>::abi_encoded_size(inner)
2091 }
2092 }
2093 }
2094 #[inline]
2095 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
2096 match self {
2097 Self::OnlySlasher(inner) => {
2098 <OnlySlasher as alloy_sol_types::SolError>::abi_encode_raw(
2099 inner,
2100 out,
2101 )
2102 }
2103 }
2104 }
2105 }
2106 #[derive(serde::Serialize, serde::Deserialize)]
2108 #[derive(Debug, PartialEq, Eq, Hash)]
2109 pub enum InstantSlasherEvents {
2110 #[allow(missing_docs)]
2111 OperatorSlashed(OperatorSlashed),
2112 }
2113 #[automatically_derived]
2114 impl InstantSlasherEvents {
2115 pub const SELECTORS: &'static [[u8; 32usize]] = &[
2122 [
2123 138u8, 131u8, 207u8, 154u8, 251u8, 9u8, 169u8, 129u8, 49u8, 79u8, 79u8,
2124 179u8, 83u8, 185u8, 91u8, 0u8, 52u8, 81u8, 218u8, 23u8, 10u8, 153u8,
2125 244u8, 141u8, 141u8, 182u8, 71u8, 75u8, 6u8, 215u8, 159u8, 59u8,
2126 ],
2127 ];
2128 }
2129 #[automatically_derived]
2130 impl alloy_sol_types::SolEventInterface for InstantSlasherEvents {
2131 const NAME: &'static str = "InstantSlasherEvents";
2132 const COUNT: usize = 1usize;
2133 fn decode_raw_log(
2134 topics: &[alloy_sol_types::Word],
2135 data: &[u8],
2136 ) -> alloy_sol_types::Result<Self> {
2137 match topics.first().copied() {
2138 Some(<OperatorSlashed as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
2139 <OperatorSlashed as alloy_sol_types::SolEvent>::decode_raw_log(
2140 topics,
2141 data,
2142 )
2143 .map(Self::OperatorSlashed)
2144 }
2145 _ => {
2146 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
2147 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
2148 log: alloy_sol_types::private::Box::new(
2149 alloy_sol_types::private::LogData::new_unchecked(
2150 topics.to_vec(),
2151 data.to_vec().into(),
2152 ),
2153 ),
2154 })
2155 }
2156 }
2157 }
2158 }
2159 #[automatically_derived]
2160 impl alloy_sol_types::private::IntoLogData for InstantSlasherEvents {
2161 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2162 match self {
2163 Self::OperatorSlashed(inner) => {
2164 alloy_sol_types::private::IntoLogData::to_log_data(inner)
2165 }
2166 }
2167 }
2168 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2169 match self {
2170 Self::OperatorSlashed(inner) => {
2171 alloy_sol_types::private::IntoLogData::into_log_data(inner)
2172 }
2173 }
2174 }
2175 }
2176 use alloy::contract as alloy_contract;
2177 #[inline]
2181 pub const fn new<
2182 P: alloy_contract::private::Provider<N>,
2183 N: alloy_contract::private::Network,
2184 >(
2185 address: alloy_sol_types::private::Address,
2186 provider: P,
2187 ) -> InstantSlasherInstance<P, N> {
2188 InstantSlasherInstance::<P, N>::new(address, provider)
2189 }
2190 #[inline]
2196 pub fn deploy<
2197 P: alloy_contract::private::Provider<N>,
2198 N: alloy_contract::private::Network,
2199 >(
2200 provider: P,
2201 _allocationManager: alloy::sol_types::private::Address,
2202 _slashingRegistryCoordinator: alloy::sol_types::private::Address,
2203 _slasher: alloy::sol_types::private::Address,
2204 ) -> impl ::core::future::Future<
2205 Output = alloy_contract::Result<InstantSlasherInstance<P, N>>,
2206 > {
2207 InstantSlasherInstance::<
2208 P,
2209 N,
2210 >::deploy(provider, _allocationManager, _slashingRegistryCoordinator, _slasher)
2211 }
2212 #[inline]
2218 pub fn deploy_builder<
2219 P: alloy_contract::private::Provider<N>,
2220 N: alloy_contract::private::Network,
2221 >(
2222 provider: P,
2223 _allocationManager: alloy::sol_types::private::Address,
2224 _slashingRegistryCoordinator: alloy::sol_types::private::Address,
2225 _slasher: alloy::sol_types::private::Address,
2226 ) -> alloy_contract::RawCallBuilder<P, N> {
2227 InstantSlasherInstance::<
2228 P,
2229 N,
2230 >::deploy_builder(
2231 provider,
2232 _allocationManager,
2233 _slashingRegistryCoordinator,
2234 _slasher,
2235 )
2236 }
2237 #[derive(Clone)]
2249 pub struct InstantSlasherInstance<P, N = alloy_contract::private::Ethereum> {
2250 address: alloy_sol_types::private::Address,
2251 provider: P,
2252 _network: ::core::marker::PhantomData<N>,
2253 }
2254 #[automatically_derived]
2255 impl<P, N> ::core::fmt::Debug for InstantSlasherInstance<P, N> {
2256 #[inline]
2257 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2258 f.debug_tuple("InstantSlasherInstance").field(&self.address).finish()
2259 }
2260 }
2261 #[automatically_derived]
2263 impl<
2264 P: alloy_contract::private::Provider<N>,
2265 N: alloy_contract::private::Network,
2266 > InstantSlasherInstance<P, N> {
2267 #[inline]
2271 pub const fn new(
2272 address: alloy_sol_types::private::Address,
2273 provider: P,
2274 ) -> Self {
2275 Self {
2276 address,
2277 provider,
2278 _network: ::core::marker::PhantomData,
2279 }
2280 }
2281 #[inline]
2287 pub async fn deploy(
2288 provider: P,
2289 _allocationManager: alloy::sol_types::private::Address,
2290 _slashingRegistryCoordinator: alloy::sol_types::private::Address,
2291 _slasher: alloy::sol_types::private::Address,
2292 ) -> alloy_contract::Result<InstantSlasherInstance<P, N>> {
2293 let call_builder = Self::deploy_builder(
2294 provider,
2295 _allocationManager,
2296 _slashingRegistryCoordinator,
2297 _slasher,
2298 );
2299 let contract_address = call_builder.deploy().await?;
2300 Ok(Self::new(contract_address, call_builder.provider))
2301 }
2302 #[inline]
2308 pub fn deploy_builder(
2309 provider: P,
2310 _allocationManager: alloy::sol_types::private::Address,
2311 _slashingRegistryCoordinator: alloy::sol_types::private::Address,
2312 _slasher: alloy::sol_types::private::Address,
2313 ) -> alloy_contract::RawCallBuilder<P, N> {
2314 alloy_contract::RawCallBuilder::new_raw_deploy(
2315 provider,
2316 [
2317 &BYTECODE[..],
2318 &alloy_sol_types::SolConstructor::abi_encode(
2319 &constructorCall {
2320 _allocationManager,
2321 _slashingRegistryCoordinator,
2322 _slasher,
2323 },
2324 )[..],
2325 ]
2326 .concat()
2327 .into(),
2328 )
2329 }
2330 #[inline]
2332 pub const fn address(&self) -> &alloy_sol_types::private::Address {
2333 &self.address
2334 }
2335 #[inline]
2337 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
2338 self.address = address;
2339 }
2340 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
2342 self.set_address(address);
2343 self
2344 }
2345 #[inline]
2347 pub const fn provider(&self) -> &P {
2348 &self.provider
2349 }
2350 }
2351 impl<P: ::core::clone::Clone, N> InstantSlasherInstance<&P, N> {
2352 #[inline]
2354 pub fn with_cloned_provider(self) -> InstantSlasherInstance<P, N> {
2355 InstantSlasherInstance {
2356 address: self.address,
2357 provider: ::core::clone::Clone::clone(&self.provider),
2358 _network: ::core::marker::PhantomData,
2359 }
2360 }
2361 }
2362 #[automatically_derived]
2364 impl<
2365 P: alloy_contract::private::Provider<N>,
2366 N: alloy_contract::private::Network,
2367 > InstantSlasherInstance<P, N> {
2368 pub fn call_builder<C: alloy_sol_types::SolCall>(
2373 &self,
2374 call: &C,
2375 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
2376 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
2377 }
2378 pub fn allocationManager(
2380 &self,
2381 ) -> alloy_contract::SolCallBuilder<&P, allocationManagerCall, N> {
2382 self.call_builder(&allocationManagerCall)
2383 }
2384 pub fn fulfillSlashingRequest(
2386 &self,
2387 _slashingParams: <IAllocationManagerTypes::SlashingParams as alloy::sol_types::SolType>::RustType,
2388 ) -> alloy_contract::SolCallBuilder<&P, fulfillSlashingRequestCall, N> {
2389 self.call_builder(
2390 &fulfillSlashingRequestCall {
2391 _slashingParams,
2392 },
2393 )
2394 }
2395 pub fn nextRequestId(
2397 &self,
2398 ) -> alloy_contract::SolCallBuilder<&P, nextRequestIdCall, N> {
2399 self.call_builder(&nextRequestIdCall)
2400 }
2401 pub fn slasher(&self) -> alloy_contract::SolCallBuilder<&P, slasherCall, N> {
2403 self.call_builder(&slasherCall)
2404 }
2405 pub fn slashingRegistryCoordinator(
2407 &self,
2408 ) -> alloy_contract::SolCallBuilder<&P, slashingRegistryCoordinatorCall, N> {
2409 self.call_builder(&slashingRegistryCoordinatorCall)
2410 }
2411 }
2412 #[automatically_derived]
2414 impl<
2415 P: alloy_contract::private::Provider<N>,
2416 N: alloy_contract::private::Network,
2417 > InstantSlasherInstance<P, N> {
2418 pub fn event_filter<E: alloy_sol_types::SolEvent>(
2423 &self,
2424 ) -> alloy_contract::Event<&P, E, N> {
2425 alloy_contract::Event::new_sol(&self.provider, &self.address)
2426 }
2427 pub fn OperatorSlashed_filter(
2429 &self,
2430 ) -> alloy_contract::Event<&P, OperatorSlashed, N> {
2431 self.event_filter::<OperatorSlashed>()
2432 }
2433 }
2434}