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(Default, Debug, PartialEq, Eq, Hash)]
23 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
27 #[derive(Clone)]
28 pub struct SlashingParams {
29 #[allow(missing_docs)]
30 pub operator: alloy::sol_types::private::Address,
31 #[allow(missing_docs)]
32 pub operatorSetId: u32,
33 #[allow(missing_docs)]
34 pub strategies: alloy::sol_types::private::Vec<
35 alloy::sol_types::private::Address,
36 >,
37 #[allow(missing_docs)]
38 pub wadsToSlash: alloy::sol_types::private::Vec<
39 alloy::sol_types::private::primitives::aliases::U256,
40 >,
41 #[allow(missing_docs)]
42 pub description: alloy::sol_types::private::String,
43 }
44 #[allow(
45 non_camel_case_types,
46 non_snake_case,
47 clippy::pub_underscore_fields,
48 clippy::style
49 )]
50 const _: () = {
51 use alloy::sol_types as alloy_sol_types;
52 #[doc(hidden)]
53 type UnderlyingSolTuple<'a> = (
54 alloy::sol_types::sol_data::Address,
55 alloy::sol_types::sol_data::Uint<32>,
56 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
57 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
58 alloy::sol_types::sol_data::String,
59 );
60 #[doc(hidden)]
61 type UnderlyingRustTuple<'a> = (
62 alloy::sol_types::private::Address,
63 u32,
64 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
65 alloy::sol_types::private::Vec<
66 alloy::sol_types::private::primitives::aliases::U256,
67 >,
68 alloy::sol_types::private::String,
69 );
70 #[cfg(test)]
71 #[allow(dead_code, unreachable_patterns)]
72 fn _type_assertion(
73 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
74 ) {
75 match _t {
76 alloy_sol_types::private::AssertTypeEq::<
77 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
78 >(_) => {}
79 }
80 }
81 #[automatically_derived]
82 #[doc(hidden)]
83 impl ::core::convert::From<SlashingParams> for UnderlyingRustTuple<'_> {
84 fn from(value: SlashingParams) -> Self {
85 (
86 value.operator,
87 value.operatorSetId,
88 value.strategies,
89 value.wadsToSlash,
90 value.description,
91 )
92 }
93 }
94 #[automatically_derived]
95 #[doc(hidden)]
96 impl ::core::convert::From<UnderlyingRustTuple<'_>> for SlashingParams {
97 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
98 Self {
99 operator: tuple.0,
100 operatorSetId: tuple.1,
101 strategies: tuple.2,
102 wadsToSlash: tuple.3,
103 description: tuple.4,
104 }
105 }
106 }
107 #[automatically_derived]
108 impl alloy_sol_types::SolValue for SlashingParams {
109 type SolType = Self;
110 }
111 #[automatically_derived]
112 impl alloy_sol_types::private::SolTypeValue<Self> for SlashingParams {
113 #[inline]
114 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
115 (
116 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
117 &self.operator,
118 ),
119 <alloy::sol_types::sol_data::Uint<
120 32,
121 > as alloy_sol_types::SolType>::tokenize(&self.operatorSetId),
122 <alloy::sol_types::sol_data::Array<
123 alloy::sol_types::sol_data::Address,
124 > as alloy_sol_types::SolType>::tokenize(&self.strategies),
125 <alloy::sol_types::sol_data::Array<
126 alloy::sol_types::sol_data::Uint<256>,
127 > as alloy_sol_types::SolType>::tokenize(&self.wadsToSlash),
128 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
129 &self.description,
130 ),
131 )
132 }
133 #[inline]
134 fn stv_abi_encoded_size(&self) -> usize {
135 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
136 return size;
137 }
138 let tuple = <UnderlyingRustTuple<
139 '_,
140 > as ::core::convert::From<Self>>::from(self.clone());
141 <UnderlyingSolTuple<
142 '_,
143 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
144 }
145 #[inline]
146 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
147 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
148 }
149 #[inline]
150 fn stv_abi_encode_packed_to(
151 &self,
152 out: &mut alloy_sol_types::private::Vec<u8>,
153 ) {
154 let tuple = <UnderlyingRustTuple<
155 '_,
156 > as ::core::convert::From<Self>>::from(self.clone());
157 <UnderlyingSolTuple<
158 '_,
159 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
160 }
161 #[inline]
162 fn stv_abi_packed_encoded_size(&self) -> usize {
163 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
164 return size;
165 }
166 let tuple = <UnderlyingRustTuple<
167 '_,
168 > as ::core::convert::From<Self>>::from(self.clone());
169 <UnderlyingSolTuple<
170 '_,
171 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
172 }
173 }
174 #[automatically_derived]
175 impl alloy_sol_types::SolType for SlashingParams {
176 type RustType = Self;
177 type Token<'a> = <UnderlyingSolTuple<
178 'a,
179 > as alloy_sol_types::SolType>::Token<'a>;
180 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
181 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
182 '_,
183 > as alloy_sol_types::SolType>::ENCODED_SIZE;
184 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
185 '_,
186 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
187 #[inline]
188 fn valid_token(token: &Self::Token<'_>) -> bool {
189 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
190 }
191 #[inline]
192 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
193 let tuple = <UnderlyingSolTuple<
194 '_,
195 > as alloy_sol_types::SolType>::detokenize(token);
196 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
197 }
198 }
199 #[automatically_derived]
200 impl alloy_sol_types::SolStruct for SlashingParams {
201 const NAME: &'static str = "SlashingParams";
202 #[inline]
203 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
204 alloy_sol_types::private::Cow::Borrowed(
205 "SlashingParams(address operator,uint32 operatorSetId,address[] strategies,uint256[] wadsToSlash,string description)",
206 )
207 }
208 #[inline]
209 fn eip712_components() -> alloy_sol_types::private::Vec<
210 alloy_sol_types::private::Cow<'static, str>,
211 > {
212 alloy_sol_types::private::Vec::new()
213 }
214 #[inline]
215 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
216 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
217 }
218 #[inline]
219 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
220 [
221 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
222 &self.operator,
223 )
224 .0,
225 <alloy::sol_types::sol_data::Uint<
226 32,
227 > as alloy_sol_types::SolType>::eip712_data_word(&self.operatorSetId)
228 .0,
229 <alloy::sol_types::sol_data::Array<
230 alloy::sol_types::sol_data::Address,
231 > as alloy_sol_types::SolType>::eip712_data_word(&self.strategies)
232 .0,
233 <alloy::sol_types::sol_data::Array<
234 alloy::sol_types::sol_data::Uint<256>,
235 > as alloy_sol_types::SolType>::eip712_data_word(&self.wadsToSlash)
236 .0,
237 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
238 &self.description,
239 )
240 .0,
241 ]
242 .concat()
243 }
244 }
245 #[automatically_derived]
246 impl alloy_sol_types::EventTopic for SlashingParams {
247 #[inline]
248 fn topic_preimage_length(rust: &Self::RustType) -> usize {
249 0usize
250 + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
251 &rust.operator,
252 )
253 + <alloy::sol_types::sol_data::Uint<
254 32,
255 > as alloy_sol_types::EventTopic>::topic_preimage_length(
256 &rust.operatorSetId,
257 )
258 + <alloy::sol_types::sol_data::Array<
259 alloy::sol_types::sol_data::Address,
260 > as alloy_sol_types::EventTopic>::topic_preimage_length(
261 &rust.strategies,
262 )
263 + <alloy::sol_types::sol_data::Array<
264 alloy::sol_types::sol_data::Uint<256>,
265 > as alloy_sol_types::EventTopic>::topic_preimage_length(
266 &rust.wadsToSlash,
267 )
268 + <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
269 &rust.description,
270 )
271 }
272 #[inline]
273 fn encode_topic_preimage(
274 rust: &Self::RustType,
275 out: &mut alloy_sol_types::private::Vec<u8>,
276 ) {
277 out.reserve(
278 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
279 );
280 <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
281 &rust.operator,
282 out,
283 );
284 <alloy::sol_types::sol_data::Uint<
285 32,
286 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
287 &rust.operatorSetId,
288 out,
289 );
290 <alloy::sol_types::sol_data::Array<
291 alloy::sol_types::sol_data::Address,
292 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
293 &rust.strategies,
294 out,
295 );
296 <alloy::sol_types::sol_data::Array<
297 alloy::sol_types::sol_data::Uint<256>,
298 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
299 &rust.wadsToSlash,
300 out,
301 );
302 <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
303 &rust.description,
304 out,
305 );
306 }
307 #[inline]
308 fn encode_topic(
309 rust: &Self::RustType,
310 ) -> alloy_sol_types::abi::token::WordToken {
311 let mut out = alloy_sol_types::private::Vec::new();
312 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
313 rust,
314 &mut out,
315 );
316 alloy_sol_types::abi::token::WordToken(
317 alloy_sol_types::private::keccak256(out),
318 )
319 }
320 }
321 };
322 use alloy::contract as alloy_contract;
323 #[inline]
327 pub const fn new<
328 T: alloy_contract::private::Transport + ::core::clone::Clone,
329 P: alloy_contract::private::Provider<T, N>,
330 N: alloy_contract::private::Network,
331 >(
332 address: alloy_sol_types::private::Address,
333 provider: P,
334 ) -> IAllocationManagerTypesInstance<T, P, N> {
335 IAllocationManagerTypesInstance::<T, P, N>::new(address, provider)
336 }
337 #[derive(Clone)]
349 pub struct IAllocationManagerTypesInstance<
350 T,
351 P,
352 N = alloy_contract::private::Ethereum,
353 > {
354 address: alloy_sol_types::private::Address,
355 provider: P,
356 _network_transport: ::core::marker::PhantomData<(N, T)>,
357 }
358 #[automatically_derived]
359 impl<T, P, N> ::core::fmt::Debug for IAllocationManagerTypesInstance<T, P, N> {
360 #[inline]
361 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
362 f.debug_tuple("IAllocationManagerTypesInstance")
363 .field(&self.address)
364 .finish()
365 }
366 }
367 #[automatically_derived]
369 impl<
370 T: alloy_contract::private::Transport + ::core::clone::Clone,
371 P: alloy_contract::private::Provider<T, N>,
372 N: alloy_contract::private::Network,
373 > IAllocationManagerTypesInstance<T, P, N> {
374 #[inline]
378 pub const fn new(
379 address: alloy_sol_types::private::Address,
380 provider: P,
381 ) -> Self {
382 Self {
383 address,
384 provider,
385 _network_transport: ::core::marker::PhantomData,
386 }
387 }
388 #[inline]
390 pub const fn address(&self) -> &alloy_sol_types::private::Address {
391 &self.address
392 }
393 #[inline]
395 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
396 self.address = address;
397 }
398 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
400 self.set_address(address);
401 self
402 }
403 #[inline]
405 pub const fn provider(&self) -> &P {
406 &self.provider
407 }
408 }
409 impl<T, P: ::core::clone::Clone, N> IAllocationManagerTypesInstance<T, &P, N> {
410 #[inline]
412 pub fn with_cloned_provider(self) -> IAllocationManagerTypesInstance<T, P, N> {
413 IAllocationManagerTypesInstance {
414 address: self.address,
415 provider: ::core::clone::Clone::clone(&self.provider),
416 _network_transport: ::core::marker::PhantomData,
417 }
418 }
419 }
420 #[automatically_derived]
422 impl<
423 T: alloy_contract::private::Transport + ::core::clone::Clone,
424 P: alloy_contract::private::Provider<T, N>,
425 N: alloy_contract::private::Network,
426 > IAllocationManagerTypesInstance<T, P, N> {
427 pub fn call_builder<C: alloy_sol_types::SolCall>(
432 &self,
433 call: &C,
434 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
435 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
436 }
437 }
438 #[automatically_derived]
440 impl<
441 T: alloy_contract::private::Transport + ::core::clone::Clone,
442 P: alloy_contract::private::Provider<T, N>,
443 N: alloy_contract::private::Network,
444 > IAllocationManagerTypesInstance<T, P, N> {
445 pub fn event_filter<E: alloy_sol_types::SolEvent>(
450 &self,
451 ) -> alloy_contract::Event<T, &P, E, N> {
452 alloy_contract::Event::new_sol(&self.provider, &self.address)
453 }
454 }
455}
456#[allow(
646 non_camel_case_types,
647 non_snake_case,
648 clippy::pub_underscore_fields,
649 clippy::style,
650 clippy::empty_structs_with_brackets
651)]
652pub mod InstantSlasher {
653 use super::*;
654 use alloy::sol_types as alloy_sol_types;
655 #[rustfmt::skip]
661 #[allow(clippy::all)]
662 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
663 b"`\xE0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\t\xFD8\x03\x80a\t\xFD\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\x0Ea\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\x0E_\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\xFBV[\x90\x91UP\x90Pa\x01E\x81a\x01@\x84a\x06\x1DV[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\xD5V[\x81_\x81Q\x81\x10a\x01\x85Wa\x01\x85a\x06\xF0V[`\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\x04V[_`@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\x07OV[\x83`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x033\x92\x91\x90a\x07\xE7V[_`@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\xABV[`@Q\x80\x91\x03\x90\xA4PPV[_` \x82\x84\x03\x12\x15a\x03\xCEW__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03\xE3W__\xFD[\x82\x01`\xA0\x81\x85\x03\x12\x15a\x03\xF4W__\xFD[\x93\x92PPPV[_`\x01\x82\x01a\x04\x18WcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q`\xA0\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x04UWa\x04Ua\x04\x1FV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x04\x83Wa\x04\x83a\x04\x1FV[`@R\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x02cW__\xFD[\x805a\x04\xAA\x81a\x04\x8BV[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x04\xAAW__\xFD[_`\x01`\x01`@\x1B\x03\x82\x11\x15a\x04\xDAWa\x04\xDAa\x04\x1FV[P`\x05\x1B` \x01\x90V[_\x82`\x1F\x83\x01\x12a\x04\xF3W__\xFD[\x815a\x05\x06a\x05\x01\x82a\x04\xC2V[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\x05MW\x805a\x05?\x81a\x04\x8BV[\x83R` \x92\x83\x01\x92\x01a\x05,V[P\x95\x94PPPPPV[_\x82`\x1F\x83\x01\x12a\x05fW__\xFD[\x815a\x05ta\x05\x01\x82a\x04\xC2V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15a\x05\x95W__\xFD[` \x85\x01[\x83\x81\x10\x15a\x05MW\x805\x83R` \x92\x83\x01\x92\x01a\x05\x9AV[_\x82`\x1F\x83\x01\x12a\x05\xC1W__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a\x05\xDAWa\x05\xDAa\x04\x1FV[a\x05\xED`\x1F\x82\x01`\x1F\x19\x16` \x01a\x04[V[\x81\x81R\x84` \x83\x86\x01\x01\x11\x15a\x06\x01W__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[_`\xA0\x826\x03\x12\x15a\x06-W__\xFD[a\x065a\x043V[a\x06>\x83a\x04\x9FV[\x81Ra\x06L` \x84\x01a\x04\xAFV[` \x82\x01R`@\x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x06iW__\xFD[a\x06u6\x82\x86\x01a\x04\xE4V[`@\x83\x01RP``\x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x06\x93W__\xFD[a\x06\x9F6\x82\x86\x01a\x05WV[``\x83\x01RP`\x80\x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x06\xBDW__\xFD[a\x06\xC96\x82\x86\x01a\x05\xB2V[`\x80\x83\x01RP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x06\xE5W__\xFD[\x815a\x03\xF4\x81a\x04\x8BV[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\x07DW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x07\x1DV[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x07_W__\xFD[\x81Qa\x03\xF4\x81a\x04\x8BV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x07\x9AW\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x07|V[P\x93\x94\x93PPPPV[_\x81Q\x80\x84R_[\x81\x81\x10\x15a\x07\xC8W` \x81\x85\x01\x81\x01Q\x86\x83\x01\x82\x01R\x01a\x07\xACV[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\x08dW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x82R` \x93\x84\x01\x93`\x01\x93\x90\x93\x01\x92\x90\x91\x01\x90a\x089V[P``\x86\x01Q\x85\x82\x03`?\x19\x01`\xA0\x87\x01R\x92Pa\x08\x82\x81\x84a\x07jV[\x92PPP`\x80\x84\x01Q`?\x19\x84\x83\x03\x01`\xC0\x85\x01Ra\x08\xA1\x82\x82a\x07\xA4V[\x96\x95PPPPPPV[`@\x81R_a\x08\xBD`@\x83\x01\x85a\x07jV[\x82\x81\x03` \x84\x01Ra\x08\xCF\x81\x85a\x07\xA4V[\x95\x94PPPPPV\xFE\xA2dipfsX\"\x12 \x9F\x99\xA5\x04\xFB\xD4B\xDB,{VH\x06\x80\x88E\xB0\x12\x97@>6\xE6\xEA)\x01Vm\xA4\x9C\x8B\x8EdsolcC\0\x08\x1B\x003",
664 );
665 #[rustfmt::skip]
671 #[allow(clippy::all)]
672 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
673 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\xFBV[\x90\x91UP\x90Pa\x01E\x81a\x01@\x84a\x06\x1DV[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\xD5V[\x81_\x81Q\x81\x10a\x01\x85Wa\x01\x85a\x06\xF0V[`\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\x04V[_`@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\x07OV[\x83`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x033\x92\x91\x90a\x07\xE7V[_`@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\xABV[`@Q\x80\x91\x03\x90\xA4PPV[_` \x82\x84\x03\x12\x15a\x03\xCEW__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03\xE3W__\xFD[\x82\x01`\xA0\x81\x85\x03\x12\x15a\x03\xF4W__\xFD[\x93\x92PPPV[_`\x01\x82\x01a\x04\x18WcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q`\xA0\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x04UWa\x04Ua\x04\x1FV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x04\x83Wa\x04\x83a\x04\x1FV[`@R\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x02cW__\xFD[\x805a\x04\xAA\x81a\x04\x8BV[\x91\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x04\xAAW__\xFD[_`\x01`\x01`@\x1B\x03\x82\x11\x15a\x04\xDAWa\x04\xDAa\x04\x1FV[P`\x05\x1B` \x01\x90V[_\x82`\x1F\x83\x01\x12a\x04\xF3W__\xFD[\x815a\x05\x06a\x05\x01\x82a\x04\xC2V[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\x05MW\x805a\x05?\x81a\x04\x8BV[\x83R` \x92\x83\x01\x92\x01a\x05,V[P\x95\x94PPPPPV[_\x82`\x1F\x83\x01\x12a\x05fW__\xFD[\x815a\x05ta\x05\x01\x82a\x04\xC2V[\x80\x82\x82R` \x82\x01\x91P` \x83`\x05\x1B\x86\x01\x01\x92P\x85\x83\x11\x15a\x05\x95W__\xFD[` \x85\x01[\x83\x81\x10\x15a\x05MW\x805\x83R` \x92\x83\x01\x92\x01a\x05\x9AV[_\x82`\x1F\x83\x01\x12a\x05\xC1W__\xFD[\x815`\x01`\x01`@\x1B\x03\x81\x11\x15a\x05\xDAWa\x05\xDAa\x04\x1FV[a\x05\xED`\x1F\x82\x01`\x1F\x19\x16` \x01a\x04[V[\x81\x81R\x84` \x83\x86\x01\x01\x11\x15a\x06\x01W__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[_`\xA0\x826\x03\x12\x15a\x06-W__\xFD[a\x065a\x043V[a\x06>\x83a\x04\x9FV[\x81Ra\x06L` \x84\x01a\x04\xAFV[` \x82\x01R`@\x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x06iW__\xFD[a\x06u6\x82\x86\x01a\x04\xE4V[`@\x83\x01RP``\x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x06\x93W__\xFD[a\x06\x9F6\x82\x86\x01a\x05WV[``\x83\x01RP`\x80\x83\x015`\x01`\x01`@\x1B\x03\x81\x11\x15a\x06\xBDW__\xFD[a\x06\xC96\x82\x86\x01a\x05\xB2V[`\x80\x83\x01RP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x06\xE5W__\xFD[\x815a\x03\xF4\x81a\x04\x8BV[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\x07DW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x07\x1DV[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x07_W__\xFD[\x81Qa\x03\xF4\x81a\x04\x8BV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x07\x9AW\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x07|V[P\x93\x94\x93PPPPV[_\x81Q\x80\x84R_[\x81\x81\x10\x15a\x07\xC8W` \x81\x85\x01\x81\x01Q\x86\x83\x01\x82\x01R\x01a\x07\xACV[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\x08dW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x82R` \x93\x84\x01\x93`\x01\x93\x90\x93\x01\x92\x90\x91\x01\x90a\x089V[P``\x86\x01Q\x85\x82\x03`?\x19\x01`\xA0\x87\x01R\x92Pa\x08\x82\x81\x84a\x07jV[\x92PPP`\x80\x84\x01Q`?\x19\x84\x83\x03\x01`\xC0\x85\x01Ra\x08\xA1\x82\x82a\x07\xA4V[\x96\x95PPPPPPV[`@\x81R_a\x08\xBD`@\x83\x01\x85a\x07jV[\x82\x81\x03` \x84\x01Ra\x08\xCF\x81\x85a\x07\xA4V[\x95\x94PPPPPV\xFE\xA2dipfsX\"\x12 \x9F\x99\xA5\x04\xFB\xD4B\xDB,{VH\x06\x80\x88E\xB0\x12\x97@>6\xE6\xEA)\x01Vm\xA4\x9C\x8B\x8EdsolcC\0\x08\x1B\x003",
674 );
675 #[derive(Default, Debug, PartialEq, Eq, Hash)]
676 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
681 #[derive(Clone)]
682 pub struct OnlySlasher {}
683 #[allow(
684 non_camel_case_types,
685 non_snake_case,
686 clippy::pub_underscore_fields,
687 clippy::style
688 )]
689 const _: () = {
690 use alloy::sol_types as alloy_sol_types;
691 #[doc(hidden)]
692 type UnderlyingSolTuple<'a> = ();
693 #[doc(hidden)]
694 type UnderlyingRustTuple<'a> = ();
695 #[cfg(test)]
696 #[allow(dead_code, unreachable_patterns)]
697 fn _type_assertion(
698 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
699 ) {
700 match _t {
701 alloy_sol_types::private::AssertTypeEq::<
702 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
703 >(_) => {}
704 }
705 }
706 #[automatically_derived]
707 #[doc(hidden)]
708 impl ::core::convert::From<OnlySlasher> for UnderlyingRustTuple<'_> {
709 fn from(value: OnlySlasher) -> Self {
710 ()
711 }
712 }
713 #[automatically_derived]
714 #[doc(hidden)]
715 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlySlasher {
716 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
717 Self {}
718 }
719 }
720 #[automatically_derived]
721 impl alloy_sol_types::SolError for OnlySlasher {
722 type Parameters<'a> = UnderlyingSolTuple<'a>;
723 type Token<'a> = <Self::Parameters<
724 'a,
725 > as alloy_sol_types::SolType>::Token<'a>;
726 const SIGNATURE: &'static str = "OnlySlasher()";
727 const SELECTOR: [u8; 4] = [126u8, 87u8, 177u8, 225u8];
728 #[inline]
729 fn new<'a>(
730 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
731 ) -> Self {
732 tuple.into()
733 }
734 #[inline]
735 fn tokenize(&self) -> Self::Token<'_> {
736 ()
737 }
738 }
739 };
740 #[derive(Default, Debug, PartialEq, Eq, Hash)]
741 #[allow(
746 non_camel_case_types,
747 non_snake_case,
748 clippy::pub_underscore_fields,
749 clippy::style
750 )]
751 #[derive(Clone)]
752 pub struct OperatorSlashed {
753 #[allow(missing_docs)]
754 pub slashingRequestId: alloy::sol_types::private::primitives::aliases::U256,
755 #[allow(missing_docs)]
756 pub operator: alloy::sol_types::private::Address,
757 #[allow(missing_docs)]
758 pub operatorSetId: u32,
759 #[allow(missing_docs)]
760 pub wadsToSlash: alloy::sol_types::private::Vec<
761 alloy::sol_types::private::primitives::aliases::U256,
762 >,
763 #[allow(missing_docs)]
764 pub description: alloy::sol_types::private::String,
765 }
766 #[allow(
767 non_camel_case_types,
768 non_snake_case,
769 clippy::pub_underscore_fields,
770 clippy::style
771 )]
772 const _: () = {
773 use alloy::sol_types as alloy_sol_types;
774 #[automatically_derived]
775 impl alloy_sol_types::SolEvent for OperatorSlashed {
776 type DataTuple<'a> = (
777 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
778 alloy::sol_types::sol_data::String,
779 );
780 type DataToken<'a> = <Self::DataTuple<
781 'a,
782 > as alloy_sol_types::SolType>::Token<'a>;
783 type TopicList = (
784 alloy_sol_types::sol_data::FixedBytes<32>,
785 alloy::sol_types::sol_data::Uint<256>,
786 alloy::sol_types::sol_data::Address,
787 alloy::sol_types::sol_data::Uint<32>,
788 );
789 const SIGNATURE: &'static str = "OperatorSlashed(uint256,address,uint32,uint256[],string)";
790 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
791 138u8, 131u8, 207u8, 154u8, 251u8, 9u8, 169u8, 129u8, 49u8, 79u8, 79u8,
792 179u8, 83u8, 185u8, 91u8, 0u8, 52u8, 81u8, 218u8, 23u8, 10u8, 153u8,
793 244u8, 141u8, 141u8, 182u8, 71u8, 75u8, 6u8, 215u8, 159u8, 59u8,
794 ]);
795 const ANONYMOUS: bool = false;
796 #[allow(unused_variables)]
797 #[inline]
798 fn new(
799 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
800 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
801 ) -> Self {
802 Self {
803 slashingRequestId: topics.1,
804 operator: topics.2,
805 operatorSetId: topics.3,
806 wadsToSlash: data.0,
807 description: data.1,
808 }
809 }
810 #[inline]
811 fn check_signature(
812 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
813 ) -> alloy_sol_types::Result<()> {
814 if topics.0 != Self::SIGNATURE_HASH {
815 return Err(
816 alloy_sol_types::Error::invalid_event_signature_hash(
817 Self::SIGNATURE,
818 topics.0,
819 Self::SIGNATURE_HASH,
820 ),
821 );
822 }
823 Ok(())
824 }
825 #[inline]
826 fn tokenize_body(&self) -> Self::DataToken<'_> {
827 (
828 <alloy::sol_types::sol_data::Array<
829 alloy::sol_types::sol_data::Uint<256>,
830 > as alloy_sol_types::SolType>::tokenize(&self.wadsToSlash),
831 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
832 &self.description,
833 ),
834 )
835 }
836 #[inline]
837 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
838 (
839 Self::SIGNATURE_HASH.into(),
840 self.slashingRequestId.clone(),
841 self.operator.clone(),
842 self.operatorSetId.clone(),
843 )
844 }
845 #[inline]
846 fn encode_topics_raw(
847 &self,
848 out: &mut [alloy_sol_types::abi::token::WordToken],
849 ) -> alloy_sol_types::Result<()> {
850 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
851 return Err(alloy_sol_types::Error::Overrun);
852 }
853 out[0usize] = alloy_sol_types::abi::token::WordToken(
854 Self::SIGNATURE_HASH,
855 );
856 out[1usize] = <alloy::sol_types::sol_data::Uint<
857 256,
858 > as alloy_sol_types::EventTopic>::encode_topic(&self.slashingRequestId);
859 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
860 &self.operator,
861 );
862 out[3usize] = <alloy::sol_types::sol_data::Uint<
863 32,
864 > as alloy_sol_types::EventTopic>::encode_topic(&self.operatorSetId);
865 Ok(())
866 }
867 }
868 #[automatically_derived]
869 impl alloy_sol_types::private::IntoLogData for OperatorSlashed {
870 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
871 From::from(self)
872 }
873 fn into_log_data(self) -> alloy_sol_types::private::LogData {
874 From::from(&self)
875 }
876 }
877 #[automatically_derived]
878 impl From<&OperatorSlashed> for alloy_sol_types::private::LogData {
879 #[inline]
880 fn from(this: &OperatorSlashed) -> alloy_sol_types::private::LogData {
881 alloy_sol_types::SolEvent::encode_log_data(this)
882 }
883 }
884 };
885 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
890 #[derive(Clone)]
891 pub struct constructorCall {
892 #[allow(missing_docs)]
893 pub _allocationManager: alloy::sol_types::private::Address,
894 #[allow(missing_docs)]
895 pub _slashingRegistryCoordinator: alloy::sol_types::private::Address,
896 #[allow(missing_docs)]
897 pub _slasher: alloy::sol_types::private::Address,
898 }
899 const _: () = {
900 use alloy::sol_types as alloy_sol_types;
901 {
902 #[doc(hidden)]
903 type UnderlyingSolTuple<'a> = (
904 alloy::sol_types::sol_data::Address,
905 alloy::sol_types::sol_data::Address,
906 alloy::sol_types::sol_data::Address,
907 );
908 #[doc(hidden)]
909 type UnderlyingRustTuple<'a> = (
910 alloy::sol_types::private::Address,
911 alloy::sol_types::private::Address,
912 alloy::sol_types::private::Address,
913 );
914 #[cfg(test)]
915 #[allow(dead_code, unreachable_patterns)]
916 fn _type_assertion(
917 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
918 ) {
919 match _t {
920 alloy_sol_types::private::AssertTypeEq::<
921 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
922 >(_) => {}
923 }
924 }
925 #[automatically_derived]
926 #[doc(hidden)]
927 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
928 fn from(value: constructorCall) -> Self {
929 (
930 value._allocationManager,
931 value._slashingRegistryCoordinator,
932 value._slasher,
933 )
934 }
935 }
936 #[automatically_derived]
937 #[doc(hidden)]
938 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
939 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
940 Self {
941 _allocationManager: tuple.0,
942 _slashingRegistryCoordinator: tuple.1,
943 _slasher: tuple.2,
944 }
945 }
946 }
947 }
948 #[automatically_derived]
949 impl alloy_sol_types::SolConstructor for constructorCall {
950 type Parameters<'a> = (
951 alloy::sol_types::sol_data::Address,
952 alloy::sol_types::sol_data::Address,
953 alloy::sol_types::sol_data::Address,
954 );
955 type Token<'a> = <Self::Parameters<
956 'a,
957 > as alloy_sol_types::SolType>::Token<'a>;
958 #[inline]
959 fn new<'a>(
960 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
961 ) -> Self {
962 tuple.into()
963 }
964 #[inline]
965 fn tokenize(&self) -> Self::Token<'_> {
966 (
967 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
968 &self._allocationManager,
969 ),
970 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
971 &self._slashingRegistryCoordinator,
972 ),
973 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
974 &self._slasher,
975 ),
976 )
977 }
978 }
979 };
980 #[derive(Default, Debug, PartialEq, Eq, Hash)]
981 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
986 #[derive(Clone)]
987 pub struct allocationManagerCall {}
988 #[derive(Default, Debug, PartialEq, Eq, Hash)]
989 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
991 #[derive(Clone)]
992 pub struct allocationManagerReturn {
993 #[allow(missing_docs)]
994 pub _0: alloy::sol_types::private::Address,
995 }
996 #[allow(
997 non_camel_case_types,
998 non_snake_case,
999 clippy::pub_underscore_fields,
1000 clippy::style
1001 )]
1002 const _: () = {
1003 use alloy::sol_types as alloy_sol_types;
1004 {
1005 #[doc(hidden)]
1006 type UnderlyingSolTuple<'a> = ();
1007 #[doc(hidden)]
1008 type UnderlyingRustTuple<'a> = ();
1009 #[cfg(test)]
1010 #[allow(dead_code, unreachable_patterns)]
1011 fn _type_assertion(
1012 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1013 ) {
1014 match _t {
1015 alloy_sol_types::private::AssertTypeEq::<
1016 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1017 >(_) => {}
1018 }
1019 }
1020 #[automatically_derived]
1021 #[doc(hidden)]
1022 impl ::core::convert::From<allocationManagerCall>
1023 for UnderlyingRustTuple<'_> {
1024 fn from(value: allocationManagerCall) -> Self {
1025 ()
1026 }
1027 }
1028 #[automatically_derived]
1029 #[doc(hidden)]
1030 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1031 for allocationManagerCall {
1032 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1033 Self {}
1034 }
1035 }
1036 }
1037 {
1038 #[doc(hidden)]
1039 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1040 #[doc(hidden)]
1041 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1042 #[cfg(test)]
1043 #[allow(dead_code, unreachable_patterns)]
1044 fn _type_assertion(
1045 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1046 ) {
1047 match _t {
1048 alloy_sol_types::private::AssertTypeEq::<
1049 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1050 >(_) => {}
1051 }
1052 }
1053 #[automatically_derived]
1054 #[doc(hidden)]
1055 impl ::core::convert::From<allocationManagerReturn>
1056 for UnderlyingRustTuple<'_> {
1057 fn from(value: allocationManagerReturn) -> Self {
1058 (value._0,)
1059 }
1060 }
1061 #[automatically_derived]
1062 #[doc(hidden)]
1063 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1064 for allocationManagerReturn {
1065 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1066 Self { _0: tuple.0 }
1067 }
1068 }
1069 }
1070 #[automatically_derived]
1071 impl alloy_sol_types::SolCall for allocationManagerCall {
1072 type Parameters<'a> = ();
1073 type Token<'a> = <Self::Parameters<
1074 'a,
1075 > as alloy_sol_types::SolType>::Token<'a>;
1076 type Return = allocationManagerReturn;
1077 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1078 type ReturnToken<'a> = <Self::ReturnTuple<
1079 'a,
1080 > as alloy_sol_types::SolType>::Token<'a>;
1081 const SIGNATURE: &'static str = "allocationManager()";
1082 const SELECTOR: [u8; 4] = [202u8, 138u8, 167u8, 199u8];
1083 #[inline]
1084 fn new<'a>(
1085 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1086 ) -> Self {
1087 tuple.into()
1088 }
1089 #[inline]
1090 fn tokenize(&self) -> Self::Token<'_> {
1091 ()
1092 }
1093 #[inline]
1094 fn abi_decode_returns(
1095 data: &[u8],
1096 validate: bool,
1097 ) -> alloy_sol_types::Result<Self::Return> {
1098 <Self::ReturnTuple<
1099 '_,
1100 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1101 .map(Into::into)
1102 }
1103 }
1104 };
1105 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1106 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1111 #[derive(Clone)]
1112 pub struct fulfillSlashingRequestCall {
1113 #[allow(missing_docs)]
1114 pub _slashingParams: <IAllocationManagerTypes::SlashingParams as alloy::sol_types::SolType>::RustType,
1115 }
1116 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1118 #[derive(Clone)]
1119 pub struct fulfillSlashingRequestReturn {}
1120 #[allow(
1121 non_camel_case_types,
1122 non_snake_case,
1123 clippy::pub_underscore_fields,
1124 clippy::style
1125 )]
1126 const _: () = {
1127 use alloy::sol_types as alloy_sol_types;
1128 {
1129 #[doc(hidden)]
1130 type UnderlyingSolTuple<'a> = (IAllocationManagerTypes::SlashingParams,);
1131 #[doc(hidden)]
1132 type UnderlyingRustTuple<'a> = (
1133 <IAllocationManagerTypes::SlashingParams as alloy::sol_types::SolType>::RustType,
1134 );
1135 #[cfg(test)]
1136 #[allow(dead_code, unreachable_patterns)]
1137 fn _type_assertion(
1138 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1139 ) {
1140 match _t {
1141 alloy_sol_types::private::AssertTypeEq::<
1142 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1143 >(_) => {}
1144 }
1145 }
1146 #[automatically_derived]
1147 #[doc(hidden)]
1148 impl ::core::convert::From<fulfillSlashingRequestCall>
1149 for UnderlyingRustTuple<'_> {
1150 fn from(value: fulfillSlashingRequestCall) -> Self {
1151 (value._slashingParams,)
1152 }
1153 }
1154 #[automatically_derived]
1155 #[doc(hidden)]
1156 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1157 for fulfillSlashingRequestCall {
1158 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1159 Self { _slashingParams: tuple.0 }
1160 }
1161 }
1162 }
1163 {
1164 #[doc(hidden)]
1165 type UnderlyingSolTuple<'a> = ();
1166 #[doc(hidden)]
1167 type UnderlyingRustTuple<'a> = ();
1168 #[cfg(test)]
1169 #[allow(dead_code, unreachable_patterns)]
1170 fn _type_assertion(
1171 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1172 ) {
1173 match _t {
1174 alloy_sol_types::private::AssertTypeEq::<
1175 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1176 >(_) => {}
1177 }
1178 }
1179 #[automatically_derived]
1180 #[doc(hidden)]
1181 impl ::core::convert::From<fulfillSlashingRequestReturn>
1182 for UnderlyingRustTuple<'_> {
1183 fn from(value: fulfillSlashingRequestReturn) -> Self {
1184 ()
1185 }
1186 }
1187 #[automatically_derived]
1188 #[doc(hidden)]
1189 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1190 for fulfillSlashingRequestReturn {
1191 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1192 Self {}
1193 }
1194 }
1195 }
1196 #[automatically_derived]
1197 impl alloy_sol_types::SolCall for fulfillSlashingRequestCall {
1198 type Parameters<'a> = (IAllocationManagerTypes::SlashingParams,);
1199 type Token<'a> = <Self::Parameters<
1200 'a,
1201 > as alloy_sol_types::SolType>::Token<'a>;
1202 type Return = fulfillSlashingRequestReturn;
1203 type ReturnTuple<'a> = ();
1204 type ReturnToken<'a> = <Self::ReturnTuple<
1205 'a,
1206 > as alloy_sol_types::SolType>::Token<'a>;
1207 const SIGNATURE: &'static str = "fulfillSlashingRequest((address,uint32,address[],uint256[],string))";
1208 const SELECTOR: [u8; 4] = [106u8, 102u8, 155u8, 65u8];
1209 #[inline]
1210 fn new<'a>(
1211 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1212 ) -> Self {
1213 tuple.into()
1214 }
1215 #[inline]
1216 fn tokenize(&self) -> Self::Token<'_> {
1217 (
1218 <IAllocationManagerTypes::SlashingParams as alloy_sol_types::SolType>::tokenize(
1219 &self._slashingParams,
1220 ),
1221 )
1222 }
1223 #[inline]
1224 fn abi_decode_returns(
1225 data: &[u8],
1226 validate: bool,
1227 ) -> alloy_sol_types::Result<Self::Return> {
1228 <Self::ReturnTuple<
1229 '_,
1230 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1231 .map(Into::into)
1232 }
1233 }
1234 };
1235 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1236 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1241 #[derive(Clone)]
1242 pub struct nextRequestIdCall {}
1243 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1244 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1246 #[derive(Clone)]
1247 pub struct nextRequestIdReturn {
1248 #[allow(missing_docs)]
1249 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1250 }
1251 #[allow(
1252 non_camel_case_types,
1253 non_snake_case,
1254 clippy::pub_underscore_fields,
1255 clippy::style
1256 )]
1257 const _: () = {
1258 use alloy::sol_types as alloy_sol_types;
1259 {
1260 #[doc(hidden)]
1261 type UnderlyingSolTuple<'a> = ();
1262 #[doc(hidden)]
1263 type UnderlyingRustTuple<'a> = ();
1264 #[cfg(test)]
1265 #[allow(dead_code, unreachable_patterns)]
1266 fn _type_assertion(
1267 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1268 ) {
1269 match _t {
1270 alloy_sol_types::private::AssertTypeEq::<
1271 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1272 >(_) => {}
1273 }
1274 }
1275 #[automatically_derived]
1276 #[doc(hidden)]
1277 impl ::core::convert::From<nextRequestIdCall> for UnderlyingRustTuple<'_> {
1278 fn from(value: nextRequestIdCall) -> Self {
1279 ()
1280 }
1281 }
1282 #[automatically_derived]
1283 #[doc(hidden)]
1284 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nextRequestIdCall {
1285 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1286 Self {}
1287 }
1288 }
1289 }
1290 {
1291 #[doc(hidden)]
1292 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1293 #[doc(hidden)]
1294 type UnderlyingRustTuple<'a> = (
1295 alloy::sol_types::private::primitives::aliases::U256,
1296 );
1297 #[cfg(test)]
1298 #[allow(dead_code, unreachable_patterns)]
1299 fn _type_assertion(
1300 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1301 ) {
1302 match _t {
1303 alloy_sol_types::private::AssertTypeEq::<
1304 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1305 >(_) => {}
1306 }
1307 }
1308 #[automatically_derived]
1309 #[doc(hidden)]
1310 impl ::core::convert::From<nextRequestIdReturn> for UnderlyingRustTuple<'_> {
1311 fn from(value: nextRequestIdReturn) -> Self {
1312 (value._0,)
1313 }
1314 }
1315 #[automatically_derived]
1316 #[doc(hidden)]
1317 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nextRequestIdReturn {
1318 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1319 Self { _0: tuple.0 }
1320 }
1321 }
1322 }
1323 #[automatically_derived]
1324 impl alloy_sol_types::SolCall for nextRequestIdCall {
1325 type Parameters<'a> = ();
1326 type Token<'a> = <Self::Parameters<
1327 'a,
1328 > as alloy_sol_types::SolType>::Token<'a>;
1329 type Return = nextRequestIdReturn;
1330 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1331 type ReturnToken<'a> = <Self::ReturnTuple<
1332 'a,
1333 > as alloy_sol_types::SolType>::Token<'a>;
1334 const SIGNATURE: &'static str = "nextRequestId()";
1335 const SELECTOR: [u8; 4] = [106u8, 132u8, 169u8, 133u8];
1336 #[inline]
1337 fn new<'a>(
1338 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1339 ) -> Self {
1340 tuple.into()
1341 }
1342 #[inline]
1343 fn tokenize(&self) -> Self::Token<'_> {
1344 ()
1345 }
1346 #[inline]
1347 fn abi_decode_returns(
1348 data: &[u8],
1349 validate: bool,
1350 ) -> alloy_sol_types::Result<Self::Return> {
1351 <Self::ReturnTuple<
1352 '_,
1353 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1354 .map(Into::into)
1355 }
1356 }
1357 };
1358 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1359 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1364 #[derive(Clone)]
1365 pub struct slasherCall {}
1366 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1367 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1369 #[derive(Clone)]
1370 pub struct slasherReturn {
1371 #[allow(missing_docs)]
1372 pub _0: alloy::sol_types::private::Address,
1373 }
1374 #[allow(
1375 non_camel_case_types,
1376 non_snake_case,
1377 clippy::pub_underscore_fields,
1378 clippy::style
1379 )]
1380 const _: () = {
1381 use alloy::sol_types as alloy_sol_types;
1382 {
1383 #[doc(hidden)]
1384 type UnderlyingSolTuple<'a> = ();
1385 #[doc(hidden)]
1386 type UnderlyingRustTuple<'a> = ();
1387 #[cfg(test)]
1388 #[allow(dead_code, unreachable_patterns)]
1389 fn _type_assertion(
1390 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1391 ) {
1392 match _t {
1393 alloy_sol_types::private::AssertTypeEq::<
1394 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1395 >(_) => {}
1396 }
1397 }
1398 #[automatically_derived]
1399 #[doc(hidden)]
1400 impl ::core::convert::From<slasherCall> for UnderlyingRustTuple<'_> {
1401 fn from(value: slasherCall) -> Self {
1402 ()
1403 }
1404 }
1405 #[automatically_derived]
1406 #[doc(hidden)]
1407 impl ::core::convert::From<UnderlyingRustTuple<'_>> for slasherCall {
1408 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1409 Self {}
1410 }
1411 }
1412 }
1413 {
1414 #[doc(hidden)]
1415 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1416 #[doc(hidden)]
1417 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1418 #[cfg(test)]
1419 #[allow(dead_code, unreachable_patterns)]
1420 fn _type_assertion(
1421 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1422 ) {
1423 match _t {
1424 alloy_sol_types::private::AssertTypeEq::<
1425 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1426 >(_) => {}
1427 }
1428 }
1429 #[automatically_derived]
1430 #[doc(hidden)]
1431 impl ::core::convert::From<slasherReturn> for UnderlyingRustTuple<'_> {
1432 fn from(value: slasherReturn) -> Self {
1433 (value._0,)
1434 }
1435 }
1436 #[automatically_derived]
1437 #[doc(hidden)]
1438 impl ::core::convert::From<UnderlyingRustTuple<'_>> for slasherReturn {
1439 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1440 Self { _0: tuple.0 }
1441 }
1442 }
1443 }
1444 #[automatically_derived]
1445 impl alloy_sol_types::SolCall for slasherCall {
1446 type Parameters<'a> = ();
1447 type Token<'a> = <Self::Parameters<
1448 'a,
1449 > as alloy_sol_types::SolType>::Token<'a>;
1450 type Return = slasherReturn;
1451 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1452 type ReturnToken<'a> = <Self::ReturnTuple<
1453 'a,
1454 > as alloy_sol_types::SolType>::Token<'a>;
1455 const SIGNATURE: &'static str = "slasher()";
1456 const SELECTOR: [u8; 4] = [177u8, 52u8, 66u8, 113u8];
1457 #[inline]
1458 fn new<'a>(
1459 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1460 ) -> Self {
1461 tuple.into()
1462 }
1463 #[inline]
1464 fn tokenize(&self) -> Self::Token<'_> {
1465 ()
1466 }
1467 #[inline]
1468 fn abi_decode_returns(
1469 data: &[u8],
1470 validate: bool,
1471 ) -> alloy_sol_types::Result<Self::Return> {
1472 <Self::ReturnTuple<
1473 '_,
1474 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1475 .map(Into::into)
1476 }
1477 }
1478 };
1479 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1480 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1485 #[derive(Clone)]
1486 pub struct slashingRegistryCoordinatorCall {}
1487 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1488 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1490 #[derive(Clone)]
1491 pub struct slashingRegistryCoordinatorReturn {
1492 #[allow(missing_docs)]
1493 pub _0: alloy::sol_types::private::Address,
1494 }
1495 #[allow(
1496 non_camel_case_types,
1497 non_snake_case,
1498 clippy::pub_underscore_fields,
1499 clippy::style
1500 )]
1501 const _: () = {
1502 use alloy::sol_types as alloy_sol_types;
1503 {
1504 #[doc(hidden)]
1505 type UnderlyingSolTuple<'a> = ();
1506 #[doc(hidden)]
1507 type UnderlyingRustTuple<'a> = ();
1508 #[cfg(test)]
1509 #[allow(dead_code, unreachable_patterns)]
1510 fn _type_assertion(
1511 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1512 ) {
1513 match _t {
1514 alloy_sol_types::private::AssertTypeEq::<
1515 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1516 >(_) => {}
1517 }
1518 }
1519 #[automatically_derived]
1520 #[doc(hidden)]
1521 impl ::core::convert::From<slashingRegistryCoordinatorCall>
1522 for UnderlyingRustTuple<'_> {
1523 fn from(value: slashingRegistryCoordinatorCall) -> Self {
1524 ()
1525 }
1526 }
1527 #[automatically_derived]
1528 #[doc(hidden)]
1529 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1530 for slashingRegistryCoordinatorCall {
1531 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1532 Self {}
1533 }
1534 }
1535 }
1536 {
1537 #[doc(hidden)]
1538 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1539 #[doc(hidden)]
1540 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1541 #[cfg(test)]
1542 #[allow(dead_code, unreachable_patterns)]
1543 fn _type_assertion(
1544 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1545 ) {
1546 match _t {
1547 alloy_sol_types::private::AssertTypeEq::<
1548 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1549 >(_) => {}
1550 }
1551 }
1552 #[automatically_derived]
1553 #[doc(hidden)]
1554 impl ::core::convert::From<slashingRegistryCoordinatorReturn>
1555 for UnderlyingRustTuple<'_> {
1556 fn from(value: slashingRegistryCoordinatorReturn) -> Self {
1557 (value._0,)
1558 }
1559 }
1560 #[automatically_derived]
1561 #[doc(hidden)]
1562 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1563 for slashingRegistryCoordinatorReturn {
1564 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1565 Self { _0: tuple.0 }
1566 }
1567 }
1568 }
1569 #[automatically_derived]
1570 impl alloy_sol_types::SolCall for slashingRegistryCoordinatorCall {
1571 type Parameters<'a> = ();
1572 type Token<'a> = <Self::Parameters<
1573 'a,
1574 > as alloy_sol_types::SolType>::Token<'a>;
1575 type Return = slashingRegistryCoordinatorReturn;
1576 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1577 type ReturnToken<'a> = <Self::ReturnTuple<
1578 'a,
1579 > as alloy_sol_types::SolType>::Token<'a>;
1580 const SIGNATURE: &'static str = "slashingRegistryCoordinator()";
1581 const SELECTOR: [u8; 4] = [207u8, 29u8, 107u8, 66u8];
1582 #[inline]
1583 fn new<'a>(
1584 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1585 ) -> Self {
1586 tuple.into()
1587 }
1588 #[inline]
1589 fn tokenize(&self) -> Self::Token<'_> {
1590 ()
1591 }
1592 #[inline]
1593 fn abi_decode_returns(
1594 data: &[u8],
1595 validate: bool,
1596 ) -> alloy_sol_types::Result<Self::Return> {
1597 <Self::ReturnTuple<
1598 '_,
1599 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1600 .map(Into::into)
1601 }
1602 }
1603 };
1604 #[derive()]
1606 pub enum InstantSlasherCalls {
1607 #[allow(missing_docs)]
1608 allocationManager(allocationManagerCall),
1609 #[allow(missing_docs)]
1610 fulfillSlashingRequest(fulfillSlashingRequestCall),
1611 #[allow(missing_docs)]
1612 nextRequestId(nextRequestIdCall),
1613 #[allow(missing_docs)]
1614 slasher(slasherCall),
1615 #[allow(missing_docs)]
1616 slashingRegistryCoordinator(slashingRegistryCoordinatorCall),
1617 }
1618 #[automatically_derived]
1619 impl InstantSlasherCalls {
1620 pub const SELECTORS: &'static [[u8; 4usize]] = &[
1627 [106u8, 102u8, 155u8, 65u8],
1628 [106u8, 132u8, 169u8, 133u8],
1629 [177u8, 52u8, 66u8, 113u8],
1630 [202u8, 138u8, 167u8, 199u8],
1631 [207u8, 29u8, 107u8, 66u8],
1632 ];
1633 }
1634 #[automatically_derived]
1635 impl alloy_sol_types::SolInterface for InstantSlasherCalls {
1636 const NAME: &'static str = "InstantSlasherCalls";
1637 const MIN_DATA_LENGTH: usize = 0usize;
1638 const COUNT: usize = 5usize;
1639 #[inline]
1640 fn selector(&self) -> [u8; 4] {
1641 match self {
1642 Self::allocationManager(_) => {
1643 <allocationManagerCall as alloy_sol_types::SolCall>::SELECTOR
1644 }
1645 Self::fulfillSlashingRequest(_) => {
1646 <fulfillSlashingRequestCall as alloy_sol_types::SolCall>::SELECTOR
1647 }
1648 Self::nextRequestId(_) => {
1649 <nextRequestIdCall as alloy_sol_types::SolCall>::SELECTOR
1650 }
1651 Self::slasher(_) => <slasherCall as alloy_sol_types::SolCall>::SELECTOR,
1652 Self::slashingRegistryCoordinator(_) => {
1653 <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::SELECTOR
1654 }
1655 }
1656 }
1657 #[inline]
1658 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1659 Self::SELECTORS.get(i).copied()
1660 }
1661 #[inline]
1662 fn valid_selector(selector: [u8; 4]) -> bool {
1663 Self::SELECTORS.binary_search(&selector).is_ok()
1664 }
1665 #[inline]
1666 #[allow(non_snake_case)]
1667 fn abi_decode_raw(
1668 selector: [u8; 4],
1669 data: &[u8],
1670 validate: bool,
1671 ) -> alloy_sol_types::Result<Self> {
1672 static DECODE_SHIMS: &[fn(
1673 &[u8],
1674 bool,
1675 ) -> alloy_sol_types::Result<InstantSlasherCalls>] = &[
1676 {
1677 fn fulfillSlashingRequest(
1678 data: &[u8],
1679 validate: bool,
1680 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1681 <fulfillSlashingRequestCall as alloy_sol_types::SolCall>::abi_decode_raw(
1682 data,
1683 validate,
1684 )
1685 .map(InstantSlasherCalls::fulfillSlashingRequest)
1686 }
1687 fulfillSlashingRequest
1688 },
1689 {
1690 fn nextRequestId(
1691 data: &[u8],
1692 validate: bool,
1693 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1694 <nextRequestIdCall as alloy_sol_types::SolCall>::abi_decode_raw(
1695 data,
1696 validate,
1697 )
1698 .map(InstantSlasherCalls::nextRequestId)
1699 }
1700 nextRequestId
1701 },
1702 {
1703 fn slasher(
1704 data: &[u8],
1705 validate: bool,
1706 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1707 <slasherCall as alloy_sol_types::SolCall>::abi_decode_raw(
1708 data,
1709 validate,
1710 )
1711 .map(InstantSlasherCalls::slasher)
1712 }
1713 slasher
1714 },
1715 {
1716 fn allocationManager(
1717 data: &[u8],
1718 validate: bool,
1719 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1720 <allocationManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
1721 data,
1722 validate,
1723 )
1724 .map(InstantSlasherCalls::allocationManager)
1725 }
1726 allocationManager
1727 },
1728 {
1729 fn slashingRegistryCoordinator(
1730 data: &[u8],
1731 validate: bool,
1732 ) -> alloy_sol_types::Result<InstantSlasherCalls> {
1733 <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
1734 data,
1735 validate,
1736 )
1737 .map(InstantSlasherCalls::slashingRegistryCoordinator)
1738 }
1739 slashingRegistryCoordinator
1740 },
1741 ];
1742 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1743 return Err(
1744 alloy_sol_types::Error::unknown_selector(
1745 <Self as alloy_sol_types::SolInterface>::NAME,
1746 selector,
1747 ),
1748 );
1749 };
1750 DECODE_SHIMS[idx](data, validate)
1751 }
1752 #[inline]
1753 fn abi_encoded_size(&self) -> usize {
1754 match self {
1755 Self::allocationManager(inner) => {
1756 <allocationManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
1757 inner,
1758 )
1759 }
1760 Self::fulfillSlashingRequest(inner) => {
1761 <fulfillSlashingRequestCall as alloy_sol_types::SolCall>::abi_encoded_size(
1762 inner,
1763 )
1764 }
1765 Self::nextRequestId(inner) => {
1766 <nextRequestIdCall as alloy_sol_types::SolCall>::abi_encoded_size(
1767 inner,
1768 )
1769 }
1770 Self::slasher(inner) => {
1771 <slasherCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1772 }
1773 Self::slashingRegistryCoordinator(inner) => {
1774 <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
1775 inner,
1776 )
1777 }
1778 }
1779 }
1780 #[inline]
1781 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1782 match self {
1783 Self::allocationManager(inner) => {
1784 <allocationManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
1785 inner,
1786 out,
1787 )
1788 }
1789 Self::fulfillSlashingRequest(inner) => {
1790 <fulfillSlashingRequestCall as alloy_sol_types::SolCall>::abi_encode_raw(
1791 inner,
1792 out,
1793 )
1794 }
1795 Self::nextRequestId(inner) => {
1796 <nextRequestIdCall as alloy_sol_types::SolCall>::abi_encode_raw(
1797 inner,
1798 out,
1799 )
1800 }
1801 Self::slasher(inner) => {
1802 <slasherCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
1803 }
1804 Self::slashingRegistryCoordinator(inner) => {
1805 <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
1806 inner,
1807 out,
1808 )
1809 }
1810 }
1811 }
1812 }
1813 #[derive(Debug, PartialEq, Eq, Hash)]
1815 pub enum InstantSlasherErrors {
1816 #[allow(missing_docs)]
1817 OnlySlasher(OnlySlasher),
1818 }
1819 #[automatically_derived]
1820 impl InstantSlasherErrors {
1821 pub const SELECTORS: &'static [[u8; 4usize]] = &[[126u8, 87u8, 177u8, 225u8]];
1828 }
1829 #[automatically_derived]
1830 impl alloy_sol_types::SolInterface for InstantSlasherErrors {
1831 const NAME: &'static str = "InstantSlasherErrors";
1832 const MIN_DATA_LENGTH: usize = 0usize;
1833 const COUNT: usize = 1usize;
1834 #[inline]
1835 fn selector(&self) -> [u8; 4] {
1836 match self {
1837 Self::OnlySlasher(_) => {
1838 <OnlySlasher as alloy_sol_types::SolError>::SELECTOR
1839 }
1840 }
1841 }
1842 #[inline]
1843 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1844 Self::SELECTORS.get(i).copied()
1845 }
1846 #[inline]
1847 fn valid_selector(selector: [u8; 4]) -> bool {
1848 Self::SELECTORS.binary_search(&selector).is_ok()
1849 }
1850 #[inline]
1851 #[allow(non_snake_case)]
1852 fn abi_decode_raw(
1853 selector: [u8; 4],
1854 data: &[u8],
1855 validate: bool,
1856 ) -> alloy_sol_types::Result<Self> {
1857 static DECODE_SHIMS: &[fn(
1858 &[u8],
1859 bool,
1860 ) -> alloy_sol_types::Result<InstantSlasherErrors>] = &[
1861 {
1862 fn OnlySlasher(
1863 data: &[u8],
1864 validate: bool,
1865 ) -> alloy_sol_types::Result<InstantSlasherErrors> {
1866 <OnlySlasher as alloy_sol_types::SolError>::abi_decode_raw(
1867 data,
1868 validate,
1869 )
1870 .map(InstantSlasherErrors::OnlySlasher)
1871 }
1872 OnlySlasher
1873 },
1874 ];
1875 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1876 return Err(
1877 alloy_sol_types::Error::unknown_selector(
1878 <Self as alloy_sol_types::SolInterface>::NAME,
1879 selector,
1880 ),
1881 );
1882 };
1883 DECODE_SHIMS[idx](data, validate)
1884 }
1885 #[inline]
1886 fn abi_encoded_size(&self) -> usize {
1887 match self {
1888 Self::OnlySlasher(inner) => {
1889 <OnlySlasher as alloy_sol_types::SolError>::abi_encoded_size(inner)
1890 }
1891 }
1892 }
1893 #[inline]
1894 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1895 match self {
1896 Self::OnlySlasher(inner) => {
1897 <OnlySlasher as alloy_sol_types::SolError>::abi_encode_raw(
1898 inner,
1899 out,
1900 )
1901 }
1902 }
1903 }
1904 }
1905 #[derive(Debug, PartialEq, Eq, Hash)]
1907 pub enum InstantSlasherEvents {
1908 #[allow(missing_docs)]
1909 OperatorSlashed(OperatorSlashed),
1910 }
1911 #[automatically_derived]
1912 impl InstantSlasherEvents {
1913 pub const SELECTORS: &'static [[u8; 32usize]] = &[
1920 [
1921 138u8, 131u8, 207u8, 154u8, 251u8, 9u8, 169u8, 129u8, 49u8, 79u8, 79u8,
1922 179u8, 83u8, 185u8, 91u8, 0u8, 52u8, 81u8, 218u8, 23u8, 10u8, 153u8,
1923 244u8, 141u8, 141u8, 182u8, 71u8, 75u8, 6u8, 215u8, 159u8, 59u8,
1924 ],
1925 ];
1926 }
1927 #[automatically_derived]
1928 impl alloy_sol_types::SolEventInterface for InstantSlasherEvents {
1929 const NAME: &'static str = "InstantSlasherEvents";
1930 const COUNT: usize = 1usize;
1931 fn decode_raw_log(
1932 topics: &[alloy_sol_types::Word],
1933 data: &[u8],
1934 validate: bool,
1935 ) -> alloy_sol_types::Result<Self> {
1936 match topics.first().copied() {
1937 Some(<OperatorSlashed as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
1938 <OperatorSlashed as alloy_sol_types::SolEvent>::decode_raw_log(
1939 topics,
1940 data,
1941 validate,
1942 )
1943 .map(Self::OperatorSlashed)
1944 }
1945 _ => {
1946 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
1947 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
1948 log: alloy_sol_types::private::Box::new(
1949 alloy_sol_types::private::LogData::new_unchecked(
1950 topics.to_vec(),
1951 data.to_vec().into(),
1952 ),
1953 ),
1954 })
1955 }
1956 }
1957 }
1958 }
1959 #[automatically_derived]
1960 impl alloy_sol_types::private::IntoLogData for InstantSlasherEvents {
1961 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1962 match self {
1963 Self::OperatorSlashed(inner) => {
1964 alloy_sol_types::private::IntoLogData::to_log_data(inner)
1965 }
1966 }
1967 }
1968 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1969 match self {
1970 Self::OperatorSlashed(inner) => {
1971 alloy_sol_types::private::IntoLogData::into_log_data(inner)
1972 }
1973 }
1974 }
1975 }
1976 use alloy::contract as alloy_contract;
1977 #[inline]
1981 pub const fn new<
1982 T: alloy_contract::private::Transport + ::core::clone::Clone,
1983 P: alloy_contract::private::Provider<T, N>,
1984 N: alloy_contract::private::Network,
1985 >(
1986 address: alloy_sol_types::private::Address,
1987 provider: P,
1988 ) -> InstantSlasherInstance<T, P, N> {
1989 InstantSlasherInstance::<T, P, N>::new(address, provider)
1990 }
1991 #[inline]
1997 pub fn deploy<
1998 T: alloy_contract::private::Transport + ::core::clone::Clone,
1999 P: alloy_contract::private::Provider<T, N>,
2000 N: alloy_contract::private::Network,
2001 >(
2002 provider: P,
2003 _allocationManager: alloy::sol_types::private::Address,
2004 _slashingRegistryCoordinator: alloy::sol_types::private::Address,
2005 _slasher: alloy::sol_types::private::Address,
2006 ) -> impl ::core::future::Future<
2007 Output = alloy_contract::Result<InstantSlasherInstance<T, P, N>>,
2008 > {
2009 InstantSlasherInstance::<
2010 T,
2011 P,
2012 N,
2013 >::deploy(provider, _allocationManager, _slashingRegistryCoordinator, _slasher)
2014 }
2015 #[inline]
2021 pub fn deploy_builder<
2022 T: alloy_contract::private::Transport + ::core::clone::Clone,
2023 P: alloy_contract::private::Provider<T, N>,
2024 N: alloy_contract::private::Network,
2025 >(
2026 provider: P,
2027 _allocationManager: alloy::sol_types::private::Address,
2028 _slashingRegistryCoordinator: alloy::sol_types::private::Address,
2029 _slasher: alloy::sol_types::private::Address,
2030 ) -> alloy_contract::RawCallBuilder<T, P, N> {
2031 InstantSlasherInstance::<
2032 T,
2033 P,
2034 N,
2035 >::deploy_builder(
2036 provider,
2037 _allocationManager,
2038 _slashingRegistryCoordinator,
2039 _slasher,
2040 )
2041 }
2042 #[derive(Clone)]
2054 pub struct InstantSlasherInstance<T, P, N = alloy_contract::private::Ethereum> {
2055 address: alloy_sol_types::private::Address,
2056 provider: P,
2057 _network_transport: ::core::marker::PhantomData<(N, T)>,
2058 }
2059 #[automatically_derived]
2060 impl<T, P, N> ::core::fmt::Debug for InstantSlasherInstance<T, P, N> {
2061 #[inline]
2062 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2063 f.debug_tuple("InstantSlasherInstance").field(&self.address).finish()
2064 }
2065 }
2066 #[automatically_derived]
2068 impl<
2069 T: alloy_contract::private::Transport + ::core::clone::Clone,
2070 P: alloy_contract::private::Provider<T, N>,
2071 N: alloy_contract::private::Network,
2072 > InstantSlasherInstance<T, P, N> {
2073 #[inline]
2077 pub const fn new(
2078 address: alloy_sol_types::private::Address,
2079 provider: P,
2080 ) -> Self {
2081 Self {
2082 address,
2083 provider,
2084 _network_transport: ::core::marker::PhantomData,
2085 }
2086 }
2087 #[inline]
2093 pub async fn deploy(
2094 provider: P,
2095 _allocationManager: alloy::sol_types::private::Address,
2096 _slashingRegistryCoordinator: alloy::sol_types::private::Address,
2097 _slasher: alloy::sol_types::private::Address,
2098 ) -> alloy_contract::Result<InstantSlasherInstance<T, P, N>> {
2099 let call_builder = Self::deploy_builder(
2100 provider,
2101 _allocationManager,
2102 _slashingRegistryCoordinator,
2103 _slasher,
2104 );
2105 let contract_address = call_builder.deploy().await?;
2106 Ok(Self::new(contract_address, call_builder.provider))
2107 }
2108 #[inline]
2114 pub fn deploy_builder(
2115 provider: P,
2116 _allocationManager: alloy::sol_types::private::Address,
2117 _slashingRegistryCoordinator: alloy::sol_types::private::Address,
2118 _slasher: alloy::sol_types::private::Address,
2119 ) -> alloy_contract::RawCallBuilder<T, P, N> {
2120 alloy_contract::RawCallBuilder::new_raw_deploy(
2121 provider,
2122 [
2123 &BYTECODE[..],
2124 &alloy_sol_types::SolConstructor::abi_encode(
2125 &constructorCall {
2126 _allocationManager,
2127 _slashingRegistryCoordinator,
2128 _slasher,
2129 },
2130 )[..],
2131 ]
2132 .concat()
2133 .into(),
2134 )
2135 }
2136 #[inline]
2138 pub const fn address(&self) -> &alloy_sol_types::private::Address {
2139 &self.address
2140 }
2141 #[inline]
2143 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
2144 self.address = address;
2145 }
2146 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
2148 self.set_address(address);
2149 self
2150 }
2151 #[inline]
2153 pub const fn provider(&self) -> &P {
2154 &self.provider
2155 }
2156 }
2157 impl<T, P: ::core::clone::Clone, N> InstantSlasherInstance<T, &P, N> {
2158 #[inline]
2160 pub fn with_cloned_provider(self) -> InstantSlasherInstance<T, P, N> {
2161 InstantSlasherInstance {
2162 address: self.address,
2163 provider: ::core::clone::Clone::clone(&self.provider),
2164 _network_transport: ::core::marker::PhantomData,
2165 }
2166 }
2167 }
2168 #[automatically_derived]
2170 impl<
2171 T: alloy_contract::private::Transport + ::core::clone::Clone,
2172 P: alloy_contract::private::Provider<T, N>,
2173 N: alloy_contract::private::Network,
2174 > InstantSlasherInstance<T, P, N> {
2175 pub fn call_builder<C: alloy_sol_types::SolCall>(
2180 &self,
2181 call: &C,
2182 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
2183 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
2184 }
2185 pub fn allocationManager(
2187 &self,
2188 ) -> alloy_contract::SolCallBuilder<T, &P, allocationManagerCall, N> {
2189 self.call_builder(&allocationManagerCall {})
2190 }
2191 pub fn fulfillSlashingRequest(
2193 &self,
2194 _slashingParams: <IAllocationManagerTypes::SlashingParams as alloy::sol_types::SolType>::RustType,
2195 ) -> alloy_contract::SolCallBuilder<T, &P, fulfillSlashingRequestCall, N> {
2196 self.call_builder(
2197 &fulfillSlashingRequestCall {
2198 _slashingParams,
2199 },
2200 )
2201 }
2202 pub fn nextRequestId(
2204 &self,
2205 ) -> alloy_contract::SolCallBuilder<T, &P, nextRequestIdCall, N> {
2206 self.call_builder(&nextRequestIdCall {})
2207 }
2208 pub fn slasher(&self) -> alloy_contract::SolCallBuilder<T, &P, slasherCall, N> {
2210 self.call_builder(&slasherCall {})
2211 }
2212 pub fn slashingRegistryCoordinator(
2214 &self,
2215 ) -> alloy_contract::SolCallBuilder<T, &P, slashingRegistryCoordinatorCall, N> {
2216 self.call_builder(&slashingRegistryCoordinatorCall {})
2217 }
2218 }
2219 #[automatically_derived]
2221 impl<
2222 T: alloy_contract::private::Transport + ::core::clone::Clone,
2223 P: alloy_contract::private::Provider<T, N>,
2224 N: alloy_contract::private::Network,
2225 > InstantSlasherInstance<T, P, N> {
2226 pub fn event_filter<E: alloy_sol_types::SolEvent>(
2231 &self,
2232 ) -> alloy_contract::Event<T, &P, E, N> {
2233 alloy_contract::Event::new_sol(&self.provider, &self.address)
2234 }
2235 pub fn OperatorSlashed_filter(
2237 &self,
2238 ) -> alloy_contract::Event<T, &P, OperatorSlashed, N> {
2239 self.event_filter::<OperatorSlashed>()
2240 }
2241 }
2242}