#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style,
clippy::empty_structs_with_brackets
)]
pub mod ISlasher {
use super::*;
use alloy::sol_types as alloy_sol_types;
#[rustfmt::skip]
#[allow(clippy::all)]
pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
b"",
);
#[rustfmt::skip]
#[allow(clippy::all)]
pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
b"",
);
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct MiddlewareTimes {
#[allow(missing_docs)]
pub stalestUpdateBlock: u32,
#[allow(missing_docs)]
pub latestServeUntilBlock: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Uint<32>,
alloy::sol_types::sol_data::Uint<32>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32, u32);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<MiddlewareTimes> for UnderlyingRustTuple<'_> {
fn from(value: MiddlewareTimes) -> Self {
(value.stalestUpdateBlock, value.latestServeUntilBlock)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for MiddlewareTimes {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
stalestUpdateBlock: tuple.0,
latestServeUntilBlock: tuple.1,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolValue for MiddlewareTimes {
type SolType = Self;
}
#[automatically_derived]
impl alloy_sol_types::private::SolTypeValue<Self> for MiddlewareTimes {
#[inline]
fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
(
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.stalestUpdateBlock,
),
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.latestServeUntilBlock,
),
)
}
#[inline]
fn stv_abi_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
return size;
}
let tuple =
<UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
}
#[inline]
fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
<Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
}
#[inline]
fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
let tuple =
<UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
&tuple, out,
)
}
#[inline]
fn stv_abi_packed_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
return size;
}
let tuple =
<UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
&tuple,
)
}
}
#[automatically_derived]
impl alloy_sol_types::SolType for MiddlewareTimes {
type RustType = Self;
type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
const ENCODED_SIZE: Option<usize> =
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
const PACKED_ENCODED_SIZE: Option<usize> =
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
#[inline]
fn valid_token(token: &Self::Token<'_>) -> bool {
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
}
#[inline]
fn detokenize(token: Self::Token<'_>) -> Self::RustType {
let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
<Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolStruct for MiddlewareTimes {
const NAME: &'static str = "MiddlewareTimes";
#[inline]
fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
alloy_sol_types::private::Cow::Borrowed(
"MiddlewareTimes(uint32 stalestUpdateBlock,uint32 latestServeUntilBlock)",
)
}
#[inline]
fn eip712_components(
) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
{
alloy_sol_types::private::Vec::new()
}
#[inline]
fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
<Self as alloy_sol_types::SolStruct>::eip712_root_type()
}
#[inline]
fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
[
<alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::SolType>::eip712_data_word(
&self.stalestUpdateBlock,
)
.0,
<alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::SolType>::eip712_data_word(
&self.latestServeUntilBlock,
)
.0,
]
.concat()
}
}
#[automatically_derived]
impl alloy_sol_types::EventTopic for MiddlewareTimes {
#[inline]
fn topic_preimage_length(rust: &Self::RustType) -> usize {
0usize
+ <alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.stalestUpdateBlock,
)
+ <alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.latestServeUntilBlock,
)
}
#[inline]
fn encode_topic_preimage(
rust: &Self::RustType,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
<alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.stalestUpdateBlock,
out,
);
<alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.latestServeUntilBlock,
out,
);
}
#[inline]
fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
let mut out = alloy_sol_types::private::Vec::new();
<Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct FrozenStatusReset {
#[allow(missing_docs)]
pub previouslySlashedAddress: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for FrozenStatusReset {
type DataTuple<'a> = ();
type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (
alloy_sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
);
const SIGNATURE: &'static str = "FrozenStatusReset(address)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
212u8, 206u8, 240u8, 175u8, 39u8, 128u8, 13u8, 70u8, 111u8, 202u8, 205u8,
133u8, 119u8, 152u8, 87u8, 55u8, 139u8, 133u8, 203u8, 97u8, 86u8, 144u8, 5u8,
255u8, 20u8, 100u8, 250u8, 110u8, 92u8, 237u8, 105u8, 216u8,
]);
const ANONYMOUS: bool = false;
#[allow(unused_variables)]
#[inline]
fn new(
topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
) -> Self {
Self {
previouslySlashedAddress: topics.1,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
));
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
()
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(
Self::SIGNATURE_HASH.into(),
self.previouslySlashedAddress.clone(),
)
}
#[inline]
fn encode_topics_raw(
&self,
out: &mut [alloy_sol_types::abi::token::WordToken],
) -> alloy_sol_types::Result<()> {
if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
return Err(alloy_sol_types::Error::Overrun);
}
out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.previouslySlashedAddress,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for FrozenStatusReset {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
From::from(self)
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
From::from(&self)
}
}
#[automatically_derived]
impl From<&FrozenStatusReset> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &FrozenStatusReset) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct MiddlewareTimesAdded {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub index: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub stalestUpdateBlock: u32,
#[allow(missing_docs)]
pub latestServeUntilBlock: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for MiddlewareTimesAdded {
type DataTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<32>,
alloy::sol_types::sol_data::Uint<32>,
);
type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
const SIGNATURE: &'static str = "MiddlewareTimesAdded(address,uint256,uint32,uint32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
27u8, 98u8, 186u8, 100u8, 199u8, 45u8, 1u8, 228u8, 26u8, 43u8, 140u8, 70u8,
230u8, 174u8, 239u8, 247u8, 40u8, 239u8, 58u8, 68u8, 56u8, 207u8, 28u8, 172u8,
61u8, 146u8, 238u8, 18u8, 24u8, 157u8, 86u8, 73u8,
]);
const ANONYMOUS: bool = false;
#[allow(unused_variables)]
#[inline]
fn new(
topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
) -> Self {
Self {
operator: data.0,
index: data.1,
stalestUpdateBlock: data.2,
latestServeUntilBlock: data.3,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
));
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self.index,
),
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.stalestUpdateBlock,
),
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.latestServeUntilBlock,
),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(Self::SIGNATURE_HASH.into(),)
}
#[inline]
fn encode_topics_raw(
&self,
out: &mut [alloy_sol_types::abi::token::WordToken],
) -> alloy_sol_types::Result<()> {
if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
return Err(alloy_sol_types::Error::Overrun);
}
out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for MiddlewareTimesAdded {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
From::from(self)
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
From::from(&self)
}
}
#[automatically_derived]
impl From<&MiddlewareTimesAdded> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &MiddlewareTimesAdded) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct OperatorFrozen {
#[allow(missing_docs)]
pub slashedOperator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub slashingContract: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for OperatorFrozen {
type DataTuple<'a> = ();
type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (
alloy_sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
const SIGNATURE: &'static str = "OperatorFrozen(address,address)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
68u8, 74u8, 132u8, 245u8, 18u8, 129u8, 106u8, 231u8, 190u8, 142u8, 216u8,
166u8, 106u8, 168u8, 142u8, 54u8, 46u8, 181u8, 77u8, 9u8, 136u8, 232u8, 58u8,
204u8, 157u8, 129u8, 116u8, 102u8, 34u8, 179u8, 186u8, 81u8,
]);
const ANONYMOUS: bool = false;
#[allow(unused_variables)]
#[inline]
fn new(
topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
) -> Self {
Self {
slashedOperator: topics.1,
slashingContract: topics.2,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
));
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
()
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(
Self::SIGNATURE_HASH.into(),
self.slashedOperator.clone(),
self.slashingContract.clone(),
)
}
#[inline]
fn encode_topics_raw(
&self,
out: &mut [alloy_sol_types::abi::token::WordToken],
) -> alloy_sol_types::Result<()> {
if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
return Err(alloy_sol_types::Error::Overrun);
}
out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.slashedOperator,
);
out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.slashingContract,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for OperatorFrozen {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
From::from(self)
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
From::from(&self)
}
}
#[automatically_derived]
impl From<&OperatorFrozen> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &OperatorFrozen) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct OptedIntoSlashing {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub contractAddress: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for OptedIntoSlashing {
type DataTuple<'a> = ();
type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (
alloy_sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
const SIGNATURE: &'static str = "OptedIntoSlashing(address,address)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
239u8, 169u8, 251u8, 56u8, 232u8, 19u8, 213u8, 60u8, 21u8, 237u8, 245u8, 1u8,
224u8, 56u8, 82u8, 132u8, 58u8, 63u8, 237u8, 105u8, 25u8, 96u8, 82u8, 51u8,
145u8, 215u8, 26u8, 9u8, 43u8, 54u8, 39u8, 216u8,
]);
const ANONYMOUS: bool = false;
#[allow(unused_variables)]
#[inline]
fn new(
topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
) -> Self {
Self {
operator: topics.1,
contractAddress: topics.2,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
));
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
()
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(
Self::SIGNATURE_HASH.into(),
self.operator.clone(),
self.contractAddress.clone(),
)
}
#[inline]
fn encode_topics_raw(
&self,
out: &mut [alloy_sol_types::abi::token::WordToken],
) -> alloy_sol_types::Result<()> {
if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
return Err(alloy_sol_types::Error::Overrun);
}
out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.operator,
);
out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.contractAddress,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for OptedIntoSlashing {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
From::from(self)
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
From::from(&self)
}
}
#[automatically_derived]
impl From<&OptedIntoSlashing> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &OptedIntoSlashing) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct SlashingAbilityRevoked {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub contractAddress: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub contractCanSlashOperatorUntilBlock: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for SlashingAbilityRevoked {
type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (
alloy_sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
const SIGNATURE: &'static str = "SlashingAbilityRevoked(address,address,uint32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
154u8, 161u8, 177u8, 57u8, 31u8, 53u8, 198u8, 114u8, 237u8, 31u8, 59u8, 126u8,
206u8, 99u8, 47u8, 69u8, 19u8, 230u8, 24u8, 54u8, 107u8, 239u8, 122u8, 47u8,
103u8, 183u8, 198u8, 188u8, 31u8, 45u8, 43u8, 20u8,
]);
const ANONYMOUS: bool = false;
#[allow(unused_variables)]
#[inline]
fn new(
topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
) -> Self {
Self {
operator: topics.1,
contractAddress: topics.2,
contractCanSlashOperatorUntilBlock: data.0,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
));
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
(
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.contractCanSlashOperatorUntilBlock,
),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(
Self::SIGNATURE_HASH.into(),
self.operator.clone(),
self.contractAddress.clone(),
)
}
#[inline]
fn encode_topics_raw(
&self,
out: &mut [alloy_sol_types::abi::token::WordToken],
) -> alloy_sol_types::Result<()> {
if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
return Err(alloy_sol_types::Error::Overrun);
}
out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.operator,
);
out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.contractAddress,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for SlashingAbilityRevoked {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
From::from(self)
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
From::from(&self)
}
}
#[automatically_derived]
impl From<&SlashingAbilityRevoked> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &SlashingAbilityRevoked) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct canSlashCall {
#[allow(missing_docs)]
pub toBeSlashed: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub slashingContract: alloy::sol_types::private::Address,
}
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct canSlashReturn {
#[allow(missing_docs)]
pub _0: bool,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Address,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<canSlashCall> for UnderlyingRustTuple<'_> {
fn from(value: canSlashCall) -> Self {
(value.toBeSlashed, value.slashingContract)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for canSlashCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
toBeSlashed: tuple.0,
slashingContract: tuple.1,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (bool,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<canSlashReturn> for UnderlyingRustTuple<'_> {
fn from(value: canSlashReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for canSlashReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for canSlashCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = bool;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "canSlash(address,address)";
const SELECTOR: [u8; 4] = [217u8, 129u8, 40u8, 192u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.toBeSlashed,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.slashingContract,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: canSlashReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: canSlashReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct canWithdrawCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub withdrawalStartBlock: u32,
#[allow(missing_docs)]
pub middlewareTimesIndex: alloy::sol_types::private::primitives::aliases::U256,
}
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct canWithdrawReturn {
#[allow(missing_docs)]
pub _0: bool,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
u32,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<canWithdrawCall> for UnderlyingRustTuple<'_> {
fn from(value: canWithdrawCall) -> Self {
(
value.operator,
value.withdrawalStartBlock,
value.middlewareTimesIndex,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for canWithdrawCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
operator: tuple.0,
withdrawalStartBlock: tuple.1,
middlewareTimesIndex: tuple.2,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (bool,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<canWithdrawReturn> for UnderlyingRustTuple<'_> {
fn from(value: canWithdrawReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for canWithdrawReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for canWithdrawCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
alloy::sol_types::sol_data::Uint<256>,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = bool;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "canWithdraw(address,uint32,uint256)";
const SELECTOR: [u8; 4] = [129u8, 5u8, 224u8, 67u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.withdrawalStartBlock,
),
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self.middlewareTimesIndex,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: canWithdrawReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: canWithdrawReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct contractCanSlashOperatorUntilBlockCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub serviceContract: alloy::sol_types::private::Address,
}
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct contractCanSlashOperatorUntilBlockReturn {
#[allow(missing_docs)]
pub _0: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Address,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<contractCanSlashOperatorUntilBlockCall> for UnderlyingRustTuple<'_> {
fn from(value: contractCanSlashOperatorUntilBlockCall) -> Self {
(value.operator, value.serviceContract)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for contractCanSlashOperatorUntilBlockCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
operator: tuple.0,
serviceContract: tuple.1,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<contractCanSlashOperatorUntilBlockReturn> for UnderlyingRustTuple<'_> {
fn from(value: contractCanSlashOperatorUntilBlockReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for contractCanSlashOperatorUntilBlockReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for contractCanSlashOperatorUntilBlockCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = u32;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "contractCanSlashOperatorUntilBlock(address,address)";
const SELECTOR: [u8; 4] = [111u8, 12u8, 47u8, 116u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.serviceContract,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: contractCanSlashOperatorUntilBlockReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: contractCanSlashOperatorUntilBlockReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct delegationCall;
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct delegationReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<delegationCall> for UnderlyingRustTuple<'_> {
fn from(value: delegationCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for delegationCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<delegationReturn> for UnderlyingRustTuple<'_> {
fn from(value: delegationReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for delegationReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for delegationCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "delegation()";
const SELECTOR: [u8; 4] = [223u8, 92u8, 247u8, 35u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: delegationReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: delegationReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct freezeOperatorCall {
#[allow(missing_docs)]
pub toBeFrozen: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct freezeOperatorReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<freezeOperatorCall> for UnderlyingRustTuple<'_> {
fn from(value: freezeOperatorCall) -> Self {
(value.toBeFrozen,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for freezeOperatorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
toBeFrozen: tuple.0,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<freezeOperatorReturn> for UnderlyingRustTuple<'_> {
fn from(value: freezeOperatorReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for freezeOperatorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl freezeOperatorReturn {
fn _tokenize(
&self,
) -> <freezeOperatorCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for freezeOperatorCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = freezeOperatorReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "freezeOperator(address)";
const SELECTOR: [u8; 4] = [56u8, 200u8, 238u8, 100u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.toBeFrozen,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
freezeOperatorReturn::_tokenize(ret)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(Into::into)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Into::into)
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct getCorrectValueForInsertAfterCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub updateBlock: u32,
}
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct getCorrectValueForInsertAfterReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, u32);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getCorrectValueForInsertAfterCall> for UnderlyingRustTuple<'_> {
fn from(value: getCorrectValueForInsertAfterCall) -> Self {
(value.operator, value.updateBlock)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCorrectValueForInsertAfterCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
operator: tuple.0,
updateBlock: tuple.1,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getCorrectValueForInsertAfterReturn> for UnderlyingRustTuple<'_> {
fn from(value: getCorrectValueForInsertAfterReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for getCorrectValueForInsertAfterReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getCorrectValueForInsertAfterCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::primitives::aliases::U256;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getCorrectValueForInsertAfter(address,uint32)";
const SELECTOR: [u8; 4] = [114u8, 62u8, 89u8, 199u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.updateBlock,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: getCorrectValueForInsertAfterReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: getCorrectValueForInsertAfterReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct getMiddlewareTimesIndexServeUntilBlockCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub index: u32,
}
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct getMiddlewareTimesIndexServeUntilBlockReturn {
#[allow(missing_docs)]
pub _0: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, u32);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getMiddlewareTimesIndexServeUntilBlockCall> for UnderlyingRustTuple<'_> {
fn from(value: getMiddlewareTimesIndexServeUntilBlockCall) -> Self {
(value.operator, value.index)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMiddlewareTimesIndexServeUntilBlockCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
operator: tuple.0,
index: tuple.1,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getMiddlewareTimesIndexServeUntilBlockReturn>
for UnderlyingRustTuple<'_>
{
fn from(value: getMiddlewareTimesIndexServeUntilBlockReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getMiddlewareTimesIndexServeUntilBlockReturn
{
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getMiddlewareTimesIndexServeUntilBlockCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = u32;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str =
"getMiddlewareTimesIndexServeUntilBlock(address,uint32)";
const SELECTOR: [u8; 4] = [114u8, 89u8, 164u8, 92u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.index,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: getMiddlewareTimesIndexServeUntilBlockReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: getMiddlewareTimesIndexServeUntilBlockReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct getMiddlewareTimesIndexStalestUpdateBlockCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub index: u32,
}
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct getMiddlewareTimesIndexStalestUpdateBlockReturn {
#[allow(missing_docs)]
pub _0: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, u32);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getMiddlewareTimesIndexStalestUpdateBlockCall>
for UnderlyingRustTuple<'_>
{
fn from(value: getMiddlewareTimesIndexStalestUpdateBlockCall) -> Self {
(value.operator, value.index)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getMiddlewareTimesIndexStalestUpdateBlockCall
{
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
operator: tuple.0,
index: tuple.1,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getMiddlewareTimesIndexStalestUpdateBlockReturn>
for UnderlyingRustTuple<'_>
{
fn from(value: getMiddlewareTimesIndexStalestUpdateBlockReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getMiddlewareTimesIndexStalestUpdateBlockReturn
{
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getMiddlewareTimesIndexStalestUpdateBlockCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = u32;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str =
"getMiddlewareTimesIndexStalestUpdateBlock(address,uint32)";
const SELECTOR: [u8; 4] = [24u8, 116u8, 229u8, 174u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.index,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: getMiddlewareTimesIndexStalestUpdateBlockReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: getMiddlewareTimesIndexStalestUpdateBlockReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct isFrozenCall {
#[allow(missing_docs)]
pub staker: alloy::sol_types::private::Address,
}
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct isFrozenReturn {
#[allow(missing_docs)]
pub _0: bool,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<isFrozenCall> for UnderlyingRustTuple<'_> {
fn from(value: isFrozenCall) -> Self {
(value.staker,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for isFrozenCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { staker: tuple.0 }
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (bool,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<isFrozenReturn> for UnderlyingRustTuple<'_> {
fn from(value: isFrozenReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for isFrozenReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for isFrozenCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = bool;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "isFrozen(address)";
const SELECTOR: [u8; 4] = [229u8, 131u8, 152u8, 54u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.staker,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: isFrozenReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: isFrozenReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct latestUpdateBlockCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub serviceContract: alloy::sol_types::private::Address,
}
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct latestUpdateBlockReturn {
#[allow(missing_docs)]
pub _0: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Address,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<latestUpdateBlockCall> for UnderlyingRustTuple<'_> {
fn from(value: latestUpdateBlockCall) -> Self {
(value.operator, value.serviceContract)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for latestUpdateBlockCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
operator: tuple.0,
serviceContract: tuple.1,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<latestUpdateBlockReturn> for UnderlyingRustTuple<'_> {
fn from(value: latestUpdateBlockReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for latestUpdateBlockReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for latestUpdateBlockCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = u32;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "latestUpdateBlock(address,address)";
const SELECTOR: [u8; 4] = [218u8, 22u8, 226u8, 155u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.serviceContract,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: latestUpdateBlockReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: latestUpdateBlockReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct middlewareTimesLengthCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
}
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct middlewareTimesLengthReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<middlewareTimesLengthCall> for UnderlyingRustTuple<'_> {
fn from(value: middlewareTimesLengthCall) -> Self {
(value.operator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for middlewareTimesLengthCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operator: tuple.0 }
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<middlewareTimesLengthReturn> for UnderlyingRustTuple<'_> {
fn from(value: middlewareTimesLengthReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for middlewareTimesLengthReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for middlewareTimesLengthCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::primitives::aliases::U256;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "middlewareTimesLength(address)";
const SELECTOR: [u8; 4] = [164u8, 157u8, 183u8, 50u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: middlewareTimesLengthReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: middlewareTimesLengthReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct operatorToMiddlewareTimesCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub arrayIndex: alloy::sol_types::private::primitives::aliases::U256,
}
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct operatorToMiddlewareTimesReturn {
#[allow(missing_docs)]
pub _0: <MiddlewareTimes as alloy::sol_types::SolType>::RustType,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<operatorToMiddlewareTimesCall> for UnderlyingRustTuple<'_> {
fn from(value: operatorToMiddlewareTimesCall) -> Self {
(value.operator, value.arrayIndex)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for operatorToMiddlewareTimesCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
operator: tuple.0,
arrayIndex: tuple.1,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (MiddlewareTimes,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> =
(<MiddlewareTimes as alloy::sol_types::SolType>::RustType,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<operatorToMiddlewareTimesReturn> for UnderlyingRustTuple<'_> {
fn from(value: operatorToMiddlewareTimesReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for operatorToMiddlewareTimesReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for operatorToMiddlewareTimesCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<256>,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = <MiddlewareTimes as alloy::sol_types::SolType>::RustType;
type ReturnTuple<'a> = (MiddlewareTimes,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "operatorToMiddlewareTimes(address,uint256)";
const SELECTOR: [u8; 4] = [40u8, 38u8, 112u8, 252u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self.arrayIndex,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(<MiddlewareTimes as alloy_sol_types::SolType>::tokenize(ret),)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: operatorToMiddlewareTimesReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: operatorToMiddlewareTimesReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct operatorWhitelistedContractsLinkedListEntryCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub node: alloy::sol_types::private::Address,
}
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct operatorWhitelistedContractsLinkedListEntryReturn {
#[allow(missing_docs)]
pub _0: bool,
#[allow(missing_docs)]
pub _1: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub _2: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Address,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<operatorWhitelistedContractsLinkedListEntryCall>
for UnderlyingRustTuple<'_>
{
fn from(value: operatorWhitelistedContractsLinkedListEntryCall) -> Self {
(value.operator, value.node)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for operatorWhitelistedContractsLinkedListEntryCall
{
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
operator: tuple.0,
node: tuple.1,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Bool,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
bool,
alloy::sol_types::private::primitives::aliases::U256,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<operatorWhitelistedContractsLinkedListEntryReturn>
for UnderlyingRustTuple<'_>
{
fn from(value: operatorWhitelistedContractsLinkedListEntryReturn) -> Self {
(value._0, value._1, value._2)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for operatorWhitelistedContractsLinkedListEntryReturn
{
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
_0: tuple.0,
_1: tuple.1,
_2: tuple.2,
}
}
}
}
impl operatorWhitelistedContractsLinkedListEntryReturn {
fn _tokenize(
&self,
) -> <operatorWhitelistedContractsLinkedListEntryCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
>{
(
<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
&self._0,
),
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self._1,
),
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self._2,
),
)
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for operatorWhitelistedContractsLinkedListEntryCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = operatorWhitelistedContractsLinkedListEntryReturn;
type ReturnTuple<'a> = (
alloy::sol_types::sol_data::Bool,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str =
"operatorWhitelistedContractsLinkedListEntry(address,address)";
const SELECTOR: [u8; 4] = [133u8, 95u8, 204u8, 74u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.node,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
operatorWhitelistedContractsLinkedListEntryReturn::_tokenize(ret)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(Into::into)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Into::into)
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct operatorWhitelistedContractsLinkedListSizeCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
}
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct operatorWhitelistedContractsLinkedListSizeReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<operatorWhitelistedContractsLinkedListSizeCall>
for UnderlyingRustTuple<'_>
{
fn from(value: operatorWhitelistedContractsLinkedListSizeCall) -> Self {
(value.operator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for operatorWhitelistedContractsLinkedListSizeCall
{
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operator: tuple.0 }
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<operatorWhitelistedContractsLinkedListSizeReturn>
for UnderlyingRustTuple<'_>
{
fn from(value: operatorWhitelistedContractsLinkedListSizeReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for operatorWhitelistedContractsLinkedListSizeReturn
{
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for operatorWhitelistedContractsLinkedListSizeCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::primitives::aliases::U256;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "operatorWhitelistedContractsLinkedListSize(address)";
const SELECTOR: [u8; 4] = [233u8, 33u8, 212u8, 250u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: operatorWhitelistedContractsLinkedListSizeReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: operatorWhitelistedContractsLinkedListSizeReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct optIntoSlashingCall {
#[allow(missing_docs)]
pub contractAddress: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct optIntoSlashingReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<optIntoSlashingCall> for UnderlyingRustTuple<'_> {
fn from(value: optIntoSlashingCall) -> Self {
(value.contractAddress,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for optIntoSlashingCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
contractAddress: tuple.0,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<optIntoSlashingReturn> for UnderlyingRustTuple<'_> {
fn from(value: optIntoSlashingReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for optIntoSlashingReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl optIntoSlashingReturn {
fn _tokenize(
&self,
) -> <optIntoSlashingCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for optIntoSlashingCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = optIntoSlashingReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "optIntoSlashing(address)";
const SELECTOR: [u8; 4] = [247u8, 59u8, 117u8, 25u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.contractAddress,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
optIntoSlashingReturn::_tokenize(ret)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(Into::into)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Into::into)
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct recordFirstStakeUpdateCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub serveUntilBlock: u32,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct recordFirstStakeUpdateReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, u32);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<recordFirstStakeUpdateCall> for UnderlyingRustTuple<'_> {
fn from(value: recordFirstStakeUpdateCall) -> Self {
(value.operator, value.serveUntilBlock)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for recordFirstStakeUpdateCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
operator: tuple.0,
serveUntilBlock: tuple.1,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<recordFirstStakeUpdateReturn> for UnderlyingRustTuple<'_> {
fn from(value: recordFirstStakeUpdateReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for recordFirstStakeUpdateReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl recordFirstStakeUpdateReturn {
fn _tokenize(
&self,
) -> <recordFirstStakeUpdateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
{
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for recordFirstStakeUpdateCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = recordFirstStakeUpdateReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "recordFirstStakeUpdate(address,uint32)";
const SELECTOR: [u8; 4] = [23u8, 93u8, 50u8, 5u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.serveUntilBlock,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
recordFirstStakeUpdateReturn::_tokenize(ret)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(Into::into)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Into::into)
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct recordLastStakeUpdateAndRevokeSlashingAbilityCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub serveUntilBlock: u32,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct recordLastStakeUpdateAndRevokeSlashingAbilityReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, u32);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<recordLastStakeUpdateAndRevokeSlashingAbilityCall>
for UnderlyingRustTuple<'_>
{
fn from(value: recordLastStakeUpdateAndRevokeSlashingAbilityCall) -> Self {
(value.operator, value.serveUntilBlock)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for recordLastStakeUpdateAndRevokeSlashingAbilityCall
{
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
operator: tuple.0,
serveUntilBlock: tuple.1,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<recordLastStakeUpdateAndRevokeSlashingAbilityReturn>
for UnderlyingRustTuple<'_>
{
fn from(value: recordLastStakeUpdateAndRevokeSlashingAbilityReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for recordLastStakeUpdateAndRevokeSlashingAbilityReturn
{
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl recordLastStakeUpdateAndRevokeSlashingAbilityReturn {
fn _tokenize(
&self,
) -> <recordLastStakeUpdateAndRevokeSlashingAbilityCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
>{
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for recordLastStakeUpdateAndRevokeSlashingAbilityCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = recordLastStakeUpdateAndRevokeSlashingAbilityReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str =
"recordLastStakeUpdateAndRevokeSlashingAbility(address,uint32)";
const SELECTOR: [u8; 4] = [15u8, 250u8, 187u8, 206u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.serveUntilBlock,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
recordLastStakeUpdateAndRevokeSlashingAbilityReturn::_tokenize(ret)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(Into::into)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Into::into)
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct recordStakeUpdateCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub updateBlock: u32,
#[allow(missing_docs)]
pub serveUntilBlock: u32,
#[allow(missing_docs)]
pub insertAfter: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct recordStakeUpdateReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
alloy::sol_types::sol_data::Uint<32>,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
u32,
u32,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<recordStakeUpdateCall> for UnderlyingRustTuple<'_> {
fn from(value: recordStakeUpdateCall) -> Self {
(
value.operator,
value.updateBlock,
value.serveUntilBlock,
value.insertAfter,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for recordStakeUpdateCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
operator: tuple.0,
updateBlock: tuple.1,
serveUntilBlock: tuple.2,
insertAfter: tuple.3,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<recordStakeUpdateReturn> for UnderlyingRustTuple<'_> {
fn from(value: recordStakeUpdateReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for recordStakeUpdateReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl recordStakeUpdateReturn {
fn _tokenize(
&self,
) -> <recordStakeUpdateCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for recordStakeUpdateCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
alloy::sol_types::sol_data::Uint<32>,
alloy::sol_types::sol_data::Uint<256>,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = recordStakeUpdateReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "recordStakeUpdate(address,uint32,uint32,uint256)";
const SELECTOR: [u8; 4] = [199u8, 71u8, 7u8, 91u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.updateBlock,
),
<alloy::sol_types::sol_data::Uint<32> as alloy_sol_types::SolType>::tokenize(
&self.serveUntilBlock,
),
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self.insertAfter,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
recordStakeUpdateReturn::_tokenize(ret)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(Into::into)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Into::into)
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct resetFrozenStatusCall {
#[allow(missing_docs)]
pub frozenAddresses: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct resetFrozenStatusReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> =
(alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> =
(alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<resetFrozenStatusCall> for UnderlyingRustTuple<'_> {
fn from(value: resetFrozenStatusCall) -> Self {
(value.frozenAddresses,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for resetFrozenStatusCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
frozenAddresses: tuple.0,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<resetFrozenStatusReturn> for UnderlyingRustTuple<'_> {
fn from(value: resetFrozenStatusReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for resetFrozenStatusReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl resetFrozenStatusReturn {
fn _tokenize(
&self,
) -> <resetFrozenStatusCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for resetFrozenStatusCall {
type Parameters<'a> =
(alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = resetFrozenStatusReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "resetFrozenStatus(address[])";
const SELECTOR: [u8; 4] = [124u8, 247u8, 43u8, 186u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(<alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::Address,
> as alloy_sol_types::SolType>::tokenize(
&self.frozenAddresses,
),)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
resetFrozenStatusReturn::_tokenize(ret)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(Into::into)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Into::into)
}
}
};
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct strategyManagerCall;
#[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct strategyManagerReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<strategyManagerCall> for UnderlyingRustTuple<'_> {
fn from(value: strategyManagerCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for strategyManagerCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<strategyManagerReturn> for UnderlyingRustTuple<'_> {
fn from(value: strategyManagerReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for strategyManagerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for strategyManagerCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "strategyManager()";
const SELECTOR: [u8; 4] = [57u8, 183u8, 14u8, 56u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
|r| {
let r: strategyManagerReturn = r.into();
r._0
},
)
}
#[inline]
fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(|r| {
let r: strategyManagerReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
pub enum ISlasherCalls {
#[allow(missing_docs)]
canSlash(canSlashCall),
#[allow(missing_docs)]
canWithdraw(canWithdrawCall),
#[allow(missing_docs)]
contractCanSlashOperatorUntilBlock(contractCanSlashOperatorUntilBlockCall),
#[allow(missing_docs)]
delegation(delegationCall),
#[allow(missing_docs)]
freezeOperator(freezeOperatorCall),
#[allow(missing_docs)]
getCorrectValueForInsertAfter(getCorrectValueForInsertAfterCall),
#[allow(missing_docs)]
getMiddlewareTimesIndexServeUntilBlock(getMiddlewareTimesIndexServeUntilBlockCall),
#[allow(missing_docs)]
getMiddlewareTimesIndexStalestUpdateBlock(getMiddlewareTimesIndexStalestUpdateBlockCall),
#[allow(missing_docs)]
isFrozen(isFrozenCall),
#[allow(missing_docs)]
latestUpdateBlock(latestUpdateBlockCall),
#[allow(missing_docs)]
middlewareTimesLength(middlewareTimesLengthCall),
#[allow(missing_docs)]
operatorToMiddlewareTimes(operatorToMiddlewareTimesCall),
#[allow(missing_docs)]
operatorWhitelistedContractsLinkedListEntry(
operatorWhitelistedContractsLinkedListEntryCall,
),
#[allow(missing_docs)]
operatorWhitelistedContractsLinkedListSize(operatorWhitelistedContractsLinkedListSizeCall),
#[allow(missing_docs)]
optIntoSlashing(optIntoSlashingCall),
#[allow(missing_docs)]
recordFirstStakeUpdate(recordFirstStakeUpdateCall),
#[allow(missing_docs)]
recordLastStakeUpdateAndRevokeSlashingAbility(
recordLastStakeUpdateAndRevokeSlashingAbilityCall,
),
#[allow(missing_docs)]
recordStakeUpdate(recordStakeUpdateCall),
#[allow(missing_docs)]
resetFrozenStatus(resetFrozenStatusCall),
#[allow(missing_docs)]
strategyManager(strategyManagerCall),
}
#[automatically_derived]
impl ISlasherCalls {
pub const SELECTORS: &'static [[u8; 4usize]] = &[
[15u8, 250u8, 187u8, 206u8],
[23u8, 93u8, 50u8, 5u8],
[24u8, 116u8, 229u8, 174u8],
[40u8, 38u8, 112u8, 252u8],
[56u8, 200u8, 238u8, 100u8],
[57u8, 183u8, 14u8, 56u8],
[111u8, 12u8, 47u8, 116u8],
[114u8, 62u8, 89u8, 199u8],
[114u8, 89u8, 164u8, 92u8],
[124u8, 247u8, 43u8, 186u8],
[129u8, 5u8, 224u8, 67u8],
[133u8, 95u8, 204u8, 74u8],
[164u8, 157u8, 183u8, 50u8],
[199u8, 71u8, 7u8, 91u8],
[217u8, 129u8, 40u8, 192u8],
[218u8, 22u8, 226u8, 155u8],
[223u8, 92u8, 247u8, 35u8],
[229u8, 131u8, 152u8, 54u8],
[233u8, 33u8, 212u8, 250u8],
[247u8, 59u8, 117u8, 25u8],
];
}
#[automatically_derived]
impl alloy_sol_types::SolInterface for ISlasherCalls {
const NAME: &'static str = "ISlasherCalls";
const MIN_DATA_LENGTH: usize = 0usize;
const COUNT: usize = 20usize;
#[inline]
fn selector(&self) -> [u8; 4] {
match self {
Self::canSlash(_) => <canSlashCall as alloy_sol_types::SolCall>::SELECTOR,
Self::canWithdraw(_) => {
<canWithdrawCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::contractCanSlashOperatorUntilBlock(_) => {
<contractCanSlashOperatorUntilBlockCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::delegation(_) => {
<delegationCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::freezeOperator(_) => {
<freezeOperatorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getCorrectValueForInsertAfter(_) => {
<getCorrectValueForInsertAfterCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getMiddlewareTimesIndexServeUntilBlock(_) => {
<getMiddlewareTimesIndexServeUntilBlockCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getMiddlewareTimesIndexStalestUpdateBlock(_) => {
<getMiddlewareTimesIndexStalestUpdateBlockCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::isFrozen(_) => <isFrozenCall as alloy_sol_types::SolCall>::SELECTOR,
Self::latestUpdateBlock(_) => {
<latestUpdateBlockCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::middlewareTimesLength(_) => {
<middlewareTimesLengthCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::operatorToMiddlewareTimes(_) => {
<operatorToMiddlewareTimesCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::operatorWhitelistedContractsLinkedListEntry(_) => {
<operatorWhitelistedContractsLinkedListEntryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::operatorWhitelistedContractsLinkedListSize(_) => {
<operatorWhitelistedContractsLinkedListSizeCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::optIntoSlashing(_) => {
<optIntoSlashingCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::recordFirstStakeUpdate(_) => {
<recordFirstStakeUpdateCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::recordLastStakeUpdateAndRevokeSlashingAbility(_) => {
<recordLastStakeUpdateAndRevokeSlashingAbilityCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::recordStakeUpdate(_) => {
<recordStakeUpdateCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::resetFrozenStatus(_) => {
<resetFrozenStatusCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::strategyManager(_) => {
<strategyManagerCall as alloy_sol_types::SolCall>::SELECTOR
}
}
}
#[inline]
fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
Self::SELECTORS.get(i).copied()
}
#[inline]
fn valid_selector(selector: [u8; 4]) -> bool {
Self::SELECTORS.binary_search(&selector).is_ok()
}
#[inline]
#[allow(non_snake_case)]
fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<ISlasherCalls>] = &[
{
fn recordLastStakeUpdateAndRevokeSlashingAbility(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<recordLastStakeUpdateAndRevokeSlashingAbilityCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
ISlasherCalls::recordLastStakeUpdateAndRevokeSlashingAbility,
)
}
recordLastStakeUpdateAndRevokeSlashingAbility
},
{
fn recordFirstStakeUpdate(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<recordFirstStakeUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(ISlasherCalls::recordFirstStakeUpdate)
}
recordFirstStakeUpdate
},
{
fn getMiddlewareTimesIndexStalestUpdateBlock(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<getMiddlewareTimesIndexStalestUpdateBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
ISlasherCalls::getMiddlewareTimesIndexStalestUpdateBlock,
)
}
getMiddlewareTimesIndexStalestUpdateBlock
},
{
fn operatorToMiddlewareTimes(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<operatorToMiddlewareTimesCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(ISlasherCalls::operatorToMiddlewareTimes)
}
operatorToMiddlewareTimes
},
{
fn freezeOperator(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<freezeOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(ISlasherCalls::freezeOperator)
}
freezeOperator
},
{
fn strategyManager(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<strategyManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(ISlasherCalls::strategyManager)
}
strategyManager
},
{
fn contractCanSlashOperatorUntilBlock(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<contractCanSlashOperatorUntilBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(ISlasherCalls::contractCanSlashOperatorUntilBlock)
}
contractCanSlashOperatorUntilBlock
},
{
fn getCorrectValueForInsertAfter(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<getCorrectValueForInsertAfterCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(ISlasherCalls::getCorrectValueForInsertAfter)
}
getCorrectValueForInsertAfter
},
{
fn getMiddlewareTimesIndexServeUntilBlock(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<getMiddlewareTimesIndexServeUntilBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(ISlasherCalls::getMiddlewareTimesIndexServeUntilBlock)
}
getMiddlewareTimesIndexServeUntilBlock
},
{
fn resetFrozenStatus(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<resetFrozenStatusCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(ISlasherCalls::resetFrozenStatus)
}
resetFrozenStatus
},
{
fn canWithdraw(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<canWithdrawCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(ISlasherCalls::canWithdraw)
}
canWithdraw
},
{
fn operatorWhitelistedContractsLinkedListEntry(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<operatorWhitelistedContractsLinkedListEntryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
ISlasherCalls::operatorWhitelistedContractsLinkedListEntry,
)
}
operatorWhitelistedContractsLinkedListEntry
},
{
fn middlewareTimesLength(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<middlewareTimesLengthCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(ISlasherCalls::middlewareTimesLength)
}
middlewareTimesLength
},
{
fn recordStakeUpdate(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<recordStakeUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(ISlasherCalls::recordStakeUpdate)
}
recordStakeUpdate
},
{
fn canSlash(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<canSlashCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(ISlasherCalls::canSlash)
}
canSlash
},
{
fn latestUpdateBlock(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<latestUpdateBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(ISlasherCalls::latestUpdateBlock)
}
latestUpdateBlock
},
{
fn delegation(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<delegationCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(ISlasherCalls::delegation)
}
delegation
},
{
fn isFrozen(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<isFrozenCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(ISlasherCalls::isFrozen)
}
isFrozen
},
{
fn operatorWhitelistedContractsLinkedListSize(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<operatorWhitelistedContractsLinkedListSizeCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
ISlasherCalls::operatorWhitelistedContractsLinkedListSize,
)
}
operatorWhitelistedContractsLinkedListSize
},
{
fn optIntoSlashing(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<optIntoSlashingCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(ISlasherCalls::optIntoSlashing)
}
optIntoSlashing
},
];
let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
return Err(alloy_sol_types::Error::unknown_selector(
<Self as alloy_sol_types::SolInterface>::NAME,
selector,
));
};
DECODE_SHIMS[idx](data)
}
#[inline]
#[allow(non_snake_case)]
fn abi_decode_raw_validate(
selector: [u8; 4],
data: &[u8],
) -> alloy_sol_types::Result<Self> {
static DECODE_VALIDATE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<ISlasherCalls>] =
&[
{
fn recordLastStakeUpdateAndRevokeSlashingAbility(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<recordLastStakeUpdateAndRevokeSlashingAbilityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
ISlasherCalls::recordLastStakeUpdateAndRevokeSlashingAbility,
)
}
recordLastStakeUpdateAndRevokeSlashingAbility
},
{
fn recordFirstStakeUpdate(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<recordFirstStakeUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::recordFirstStakeUpdate)
}
recordFirstStakeUpdate
},
{
fn getMiddlewareTimesIndexStalestUpdateBlock(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<getMiddlewareTimesIndexStalestUpdateBlockCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
ISlasherCalls::getMiddlewareTimesIndexStalestUpdateBlock,
)
}
getMiddlewareTimesIndexStalestUpdateBlock
},
{
fn operatorToMiddlewareTimes(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<operatorToMiddlewareTimesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::operatorToMiddlewareTimes)
}
operatorToMiddlewareTimes
},
{
fn freezeOperator(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<freezeOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::freezeOperator)
}
freezeOperator
},
{
fn strategyManager(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<strategyManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::strategyManager)
}
strategyManager
},
{
fn contractCanSlashOperatorUntilBlock(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<contractCanSlashOperatorUntilBlockCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::contractCanSlashOperatorUntilBlock)
}
contractCanSlashOperatorUntilBlock
},
{
fn getCorrectValueForInsertAfter(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<getCorrectValueForInsertAfterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::getCorrectValueForInsertAfter)
}
getCorrectValueForInsertAfter
},
{
fn getMiddlewareTimesIndexServeUntilBlock(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<getMiddlewareTimesIndexServeUntilBlockCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::getMiddlewareTimesIndexServeUntilBlock)
}
getMiddlewareTimesIndexServeUntilBlock
},
{
fn resetFrozenStatus(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<resetFrozenStatusCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::resetFrozenStatus)
}
resetFrozenStatus
},
{
fn canWithdraw(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<canWithdrawCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::canWithdraw)
}
canWithdraw
},
{
fn operatorWhitelistedContractsLinkedListEntry(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<operatorWhitelistedContractsLinkedListEntryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
ISlasherCalls::operatorWhitelistedContractsLinkedListEntry,
)
}
operatorWhitelistedContractsLinkedListEntry
},
{
fn middlewareTimesLength(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<middlewareTimesLengthCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::middlewareTimesLength)
}
middlewareTimesLength
},
{
fn recordStakeUpdate(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<recordStakeUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::recordStakeUpdate)
}
recordStakeUpdate
},
{
fn canSlash(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<canSlashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::canSlash)
}
canSlash
},
{
fn latestUpdateBlock(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<latestUpdateBlockCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::latestUpdateBlock)
}
latestUpdateBlock
},
{
fn delegation(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<delegationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::delegation)
}
delegation
},
{
fn isFrozen(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<isFrozenCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::isFrozen)
}
isFrozen
},
{
fn operatorWhitelistedContractsLinkedListSize(
data: &[u8],
) -> alloy_sol_types::Result<ISlasherCalls> {
<operatorWhitelistedContractsLinkedListSizeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
ISlasherCalls::operatorWhitelistedContractsLinkedListSize,
)
}
operatorWhitelistedContractsLinkedListSize
},
{
fn optIntoSlashing(data: &[u8]) -> alloy_sol_types::Result<ISlasherCalls> {
<optIntoSlashingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(ISlasherCalls::optIntoSlashing)
}
optIntoSlashing
},
];
let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
return Err(alloy_sol_types::Error::unknown_selector(
<Self as alloy_sol_types::SolInterface>::NAME,
selector,
));
};
DECODE_VALIDATE_SHIMS[idx](data)
}
#[inline]
fn abi_encoded_size(&self) -> usize {
match self {
Self::canSlash(inner) => {
<canSlashCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::canWithdraw(inner) => {
<canWithdrawCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::contractCanSlashOperatorUntilBlock(inner) => {
<contractCanSlashOperatorUntilBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::delegation(inner) => {
<delegationCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::freezeOperator(inner) => {
<freezeOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getCorrectValueForInsertAfter(inner) => {
<getCorrectValueForInsertAfterCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getMiddlewareTimesIndexServeUntilBlock(inner) => {
<getMiddlewareTimesIndexServeUntilBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getMiddlewareTimesIndexStalestUpdateBlock(inner) => {
<getMiddlewareTimesIndexStalestUpdateBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::isFrozen(inner) => {
<isFrozenCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::latestUpdateBlock(inner) => {
<latestUpdateBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::middlewareTimesLength(inner) => {
<middlewareTimesLengthCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::operatorToMiddlewareTimes(inner) => {
<operatorToMiddlewareTimesCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::operatorWhitelistedContractsLinkedListEntry(inner) => {
<operatorWhitelistedContractsLinkedListEntryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::operatorWhitelistedContractsLinkedListSize(inner) => {
<operatorWhitelistedContractsLinkedListSizeCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::optIntoSlashing(inner) => {
<optIntoSlashingCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::recordFirstStakeUpdate(inner) => {
<recordFirstStakeUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::recordLastStakeUpdateAndRevokeSlashingAbility(inner) => {
<recordLastStakeUpdateAndRevokeSlashingAbilityCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::recordStakeUpdate(inner) => {
<recordStakeUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::resetFrozenStatus(inner) => {
<resetFrozenStatusCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::strategyManager(inner) => {
<strategyManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
}
}
#[inline]
fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
match self {
Self::canSlash(inner) => {
<canSlashCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::canWithdraw(inner) => {
<canWithdrawCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::contractCanSlashOperatorUntilBlock(inner) => {
<contractCanSlashOperatorUntilBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::delegation(inner) => {
<delegationCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::freezeOperator(inner) => {
<freezeOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getCorrectValueForInsertAfter(inner) => {
<getCorrectValueForInsertAfterCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getMiddlewareTimesIndexServeUntilBlock(inner) => {
<getMiddlewareTimesIndexServeUntilBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getMiddlewareTimesIndexStalestUpdateBlock(inner) => {
<getMiddlewareTimesIndexStalestUpdateBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::isFrozen(inner) => {
<isFrozenCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::latestUpdateBlock(inner) => {
<latestUpdateBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::middlewareTimesLength(inner) => {
<middlewareTimesLengthCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::operatorToMiddlewareTimes(inner) => {
<operatorToMiddlewareTimesCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::operatorWhitelistedContractsLinkedListEntry(inner) => {
<operatorWhitelistedContractsLinkedListEntryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::operatorWhitelistedContractsLinkedListSize(inner) => {
<operatorWhitelistedContractsLinkedListSizeCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::optIntoSlashing(inner) => {
<optIntoSlashingCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::recordFirstStakeUpdate(inner) => {
<recordFirstStakeUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::recordLastStakeUpdateAndRevokeSlashingAbility(inner) => {
<recordLastStakeUpdateAndRevokeSlashingAbilityCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::recordStakeUpdate(inner) => {
<recordStakeUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::resetFrozenStatus(inner) => {
<resetFrozenStatusCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::strategyManager(inner) => {
<strategyManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
}
}
}
#[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, Hash)]
pub enum ISlasherEvents {
#[allow(missing_docs)]
FrozenStatusReset(FrozenStatusReset),
#[allow(missing_docs)]
MiddlewareTimesAdded(MiddlewareTimesAdded),
#[allow(missing_docs)]
OperatorFrozen(OperatorFrozen),
#[allow(missing_docs)]
OptedIntoSlashing(OptedIntoSlashing),
#[allow(missing_docs)]
SlashingAbilityRevoked(SlashingAbilityRevoked),
}
#[automatically_derived]
impl ISlasherEvents {
pub const SELECTORS: &'static [[u8; 32usize]] = &[
[
27u8, 98u8, 186u8, 100u8, 199u8, 45u8, 1u8, 228u8, 26u8, 43u8, 140u8, 70u8, 230u8,
174u8, 239u8, 247u8, 40u8, 239u8, 58u8, 68u8, 56u8, 207u8, 28u8, 172u8, 61u8,
146u8, 238u8, 18u8, 24u8, 157u8, 86u8, 73u8,
],
[
68u8, 74u8, 132u8, 245u8, 18u8, 129u8, 106u8, 231u8, 190u8, 142u8, 216u8, 166u8,
106u8, 168u8, 142u8, 54u8, 46u8, 181u8, 77u8, 9u8, 136u8, 232u8, 58u8, 204u8,
157u8, 129u8, 116u8, 102u8, 34u8, 179u8, 186u8, 81u8,
],
[
154u8, 161u8, 177u8, 57u8, 31u8, 53u8, 198u8, 114u8, 237u8, 31u8, 59u8, 126u8,
206u8, 99u8, 47u8, 69u8, 19u8, 230u8, 24u8, 54u8, 107u8, 239u8, 122u8, 47u8, 103u8,
183u8, 198u8, 188u8, 31u8, 45u8, 43u8, 20u8,
],
[
212u8, 206u8, 240u8, 175u8, 39u8, 128u8, 13u8, 70u8, 111u8, 202u8, 205u8, 133u8,
119u8, 152u8, 87u8, 55u8, 139u8, 133u8, 203u8, 97u8, 86u8, 144u8, 5u8, 255u8, 20u8,
100u8, 250u8, 110u8, 92u8, 237u8, 105u8, 216u8,
],
[
239u8, 169u8, 251u8, 56u8, 232u8, 19u8, 213u8, 60u8, 21u8, 237u8, 245u8, 1u8,
224u8, 56u8, 82u8, 132u8, 58u8, 63u8, 237u8, 105u8, 25u8, 96u8, 82u8, 51u8, 145u8,
215u8, 26u8, 9u8, 43u8, 54u8, 39u8, 216u8,
],
];
}
#[automatically_derived]
impl alloy_sol_types::SolEventInterface for ISlasherEvents {
const NAME: &'static str = "ISlasherEvents";
const COUNT: usize = 5usize;
fn decode_raw_log(
topics: &[alloy_sol_types::Word],
data: &[u8],
) -> alloy_sol_types::Result<Self> {
match topics.first().copied() {
Some(<FrozenStatusReset as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<FrozenStatusReset as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
.map(Self::FrozenStatusReset)
}
Some(<MiddlewareTimesAdded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<MiddlewareTimesAdded as alloy_sol_types::SolEvent>::decode_raw_log(
topics, data,
)
.map(Self::MiddlewareTimesAdded)
}
Some(<OperatorFrozen as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<OperatorFrozen as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
.map(Self::OperatorFrozen)
}
Some(<OptedIntoSlashing as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<OptedIntoSlashing as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
.map(Self::OptedIntoSlashing)
}
Some(<SlashingAbilityRevoked as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<SlashingAbilityRevoked as alloy_sol_types::SolEvent>::decode_raw_log(
topics, data,
)
.map(Self::SlashingAbilityRevoked)
}
_ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
name: <Self as alloy_sol_types::SolEventInterface>::NAME,
log: alloy_sol_types::private::Box::new(
alloy_sol_types::private::LogData::new_unchecked(
topics.to_vec(),
data.to_vec().into(),
),
),
}),
}
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for ISlasherEvents {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
match self {
Self::FrozenStatusReset(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::MiddlewareTimesAdded(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::OperatorFrozen(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::OptedIntoSlashing(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::SlashingAbilityRevoked(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
}
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
match self {
Self::FrozenStatusReset(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::MiddlewareTimesAdded(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::OperatorFrozen(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::OptedIntoSlashing(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::SlashingAbilityRevoked(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
}
}
}
use alloy::contract as alloy_contract;
#[inline]
pub const fn new<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
>(
address: alloy_sol_types::private::Address,
provider: P,
) -> ISlasherInstance<P, N> {
ISlasherInstance::<P, N>::new(address, provider)
}
#[inline]
pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
provider: P,
) -> impl ::core::future::Future<Output = alloy_contract::Result<ISlasherInstance<P, N>>> {
ISlasherInstance::<P, N>::deploy(provider)
}
#[inline]
pub fn deploy_builder<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
>(
provider: P,
) -> alloy_contract::RawCallBuilder<P, N> {
ISlasherInstance::<P, N>::deploy_builder(provider)
}
#[derive(Clone)]
pub struct ISlasherInstance<P, N = alloy_contract::private::Ethereum> {
address: alloy_sol_types::private::Address,
provider: P,
_network: ::core::marker::PhantomData<N>,
}
#[automatically_derived]
impl<P, N> ::core::fmt::Debug for ISlasherInstance<P, N> {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
f.debug_tuple("ISlasherInstance")
.field(&self.address)
.finish()
}
}
#[automatically_derived]
impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
ISlasherInstance<P, N>
{
#[inline]
pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
Self {
address,
provider,
_network: ::core::marker::PhantomData,
}
}
#[inline]
pub async fn deploy(provider: P) -> alloy_contract::Result<ISlasherInstance<P, N>> {
let call_builder = Self::deploy_builder(provider);
let contract_address = call_builder.deploy().await?;
Ok(Self::new(contract_address, call_builder.provider))
}
#[inline]
pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
alloy_contract::RawCallBuilder::new_raw_deploy(
provider,
::core::clone::Clone::clone(&BYTECODE),
)
}
#[inline]
pub const fn address(&self) -> &alloy_sol_types::private::Address {
&self.address
}
#[inline]
pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
self.address = address;
}
pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
self.set_address(address);
self
}
#[inline]
pub const fn provider(&self) -> &P {
&self.provider
}
}
impl<P: ::core::clone::Clone, N> ISlasherInstance<&P, N> {
#[inline]
pub fn with_cloned_provider(self) -> ISlasherInstance<P, N> {
ISlasherInstance {
address: self.address,
provider: ::core::clone::Clone::clone(&self.provider),
_network: ::core::marker::PhantomData,
}
}
}
#[automatically_derived]
impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
ISlasherInstance<P, N>
{
pub fn call_builder<C: alloy_sol_types::SolCall>(
&self,
call: &C,
) -> alloy_contract::SolCallBuilder<&P, C, N> {
alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
}
pub fn canSlash(
&self,
toBeSlashed: alloy::sol_types::private::Address,
slashingContract: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, canSlashCall, N> {
self.call_builder(&canSlashCall {
toBeSlashed,
slashingContract,
})
}
pub fn canWithdraw(
&self,
operator: alloy::sol_types::private::Address,
withdrawalStartBlock: u32,
middlewareTimesIndex: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, canWithdrawCall, N> {
self.call_builder(&canWithdrawCall {
operator,
withdrawalStartBlock,
middlewareTimesIndex,
})
}
pub fn contractCanSlashOperatorUntilBlock(
&self,
operator: alloy::sol_types::private::Address,
serviceContract: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, contractCanSlashOperatorUntilBlockCall, N> {
self.call_builder(&contractCanSlashOperatorUntilBlockCall {
operator,
serviceContract,
})
}
pub fn delegation(&self) -> alloy_contract::SolCallBuilder<&P, delegationCall, N> {
self.call_builder(&delegationCall)
}
pub fn freezeOperator(
&self,
toBeFrozen: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, freezeOperatorCall, N> {
self.call_builder(&freezeOperatorCall { toBeFrozen })
}
pub fn getCorrectValueForInsertAfter(
&self,
operator: alloy::sol_types::private::Address,
updateBlock: u32,
) -> alloy_contract::SolCallBuilder<&P, getCorrectValueForInsertAfterCall, N> {
self.call_builder(&getCorrectValueForInsertAfterCall {
operator,
updateBlock,
})
}
pub fn getMiddlewareTimesIndexServeUntilBlock(
&self,
operator: alloy::sol_types::private::Address,
index: u32,
) -> alloy_contract::SolCallBuilder<&P, getMiddlewareTimesIndexServeUntilBlockCall, N>
{
self.call_builder(&getMiddlewareTimesIndexServeUntilBlockCall { operator, index })
}
pub fn getMiddlewareTimesIndexStalestUpdateBlock(
&self,
operator: alloy::sol_types::private::Address,
index: u32,
) -> alloy_contract::SolCallBuilder<&P, getMiddlewareTimesIndexStalestUpdateBlockCall, N>
{
self.call_builder(&getMiddlewareTimesIndexStalestUpdateBlockCall { operator, index })
}
pub fn isFrozen(
&self,
staker: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, isFrozenCall, N> {
self.call_builder(&isFrozenCall { staker })
}
pub fn latestUpdateBlock(
&self,
operator: alloy::sol_types::private::Address,
serviceContract: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, latestUpdateBlockCall, N> {
self.call_builder(&latestUpdateBlockCall {
operator,
serviceContract,
})
}
pub fn middlewareTimesLength(
&self,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, middlewareTimesLengthCall, N> {
self.call_builder(&middlewareTimesLengthCall { operator })
}
pub fn operatorToMiddlewareTimes(
&self,
operator: alloy::sol_types::private::Address,
arrayIndex: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, operatorToMiddlewareTimesCall, N> {
self.call_builder(&operatorToMiddlewareTimesCall {
operator,
arrayIndex,
})
}
pub fn operatorWhitelistedContractsLinkedListEntry(
&self,
operator: alloy::sol_types::private::Address,
node: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, operatorWhitelistedContractsLinkedListEntryCall, N>
{
self.call_builder(&operatorWhitelistedContractsLinkedListEntryCall { operator, node })
}
pub fn operatorWhitelistedContractsLinkedListSize(
&self,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, operatorWhitelistedContractsLinkedListSizeCall, N>
{
self.call_builder(&operatorWhitelistedContractsLinkedListSizeCall { operator })
}
pub fn optIntoSlashing(
&self,
contractAddress: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, optIntoSlashingCall, N> {
self.call_builder(&optIntoSlashingCall { contractAddress })
}
pub fn recordFirstStakeUpdate(
&self,
operator: alloy::sol_types::private::Address,
serveUntilBlock: u32,
) -> alloy_contract::SolCallBuilder<&P, recordFirstStakeUpdateCall, N> {
self.call_builder(&recordFirstStakeUpdateCall {
operator,
serveUntilBlock,
})
}
pub fn recordLastStakeUpdateAndRevokeSlashingAbility(
&self,
operator: alloy::sol_types::private::Address,
serveUntilBlock: u32,
) -> alloy_contract::SolCallBuilder<&P, recordLastStakeUpdateAndRevokeSlashingAbilityCall, N>
{
self.call_builder(&recordLastStakeUpdateAndRevokeSlashingAbilityCall {
operator,
serveUntilBlock,
})
}
pub fn recordStakeUpdate(
&self,
operator: alloy::sol_types::private::Address,
updateBlock: u32,
serveUntilBlock: u32,
insertAfter: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, recordStakeUpdateCall, N> {
self.call_builder(&recordStakeUpdateCall {
operator,
updateBlock,
serveUntilBlock,
insertAfter,
})
}
pub fn resetFrozenStatus(
&self,
frozenAddresses: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
) -> alloy_contract::SolCallBuilder<&P, resetFrozenStatusCall, N> {
self.call_builder(&resetFrozenStatusCall { frozenAddresses })
}
pub fn strategyManager(
&self,
) -> alloy_contract::SolCallBuilder<&P, strategyManagerCall, N> {
self.call_builder(&strategyManagerCall)
}
}
#[automatically_derived]
impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
ISlasherInstance<P, N>
{
pub fn event_filter<E: alloy_sol_types::SolEvent>(
&self,
) -> alloy_contract::Event<&P, E, N> {
alloy_contract::Event::new_sol(&self.provider, &self.address)
}
pub fn FrozenStatusReset_filter(&self) -> alloy_contract::Event<&P, FrozenStatusReset, N> {
self.event_filter::<FrozenStatusReset>()
}
pub fn MiddlewareTimesAdded_filter(
&self,
) -> alloy_contract::Event<&P, MiddlewareTimesAdded, N> {
self.event_filter::<MiddlewareTimesAdded>()
}
pub fn OperatorFrozen_filter(&self) -> alloy_contract::Event<&P, OperatorFrozen, N> {
self.event_filter::<OperatorFrozen>()
}
pub fn OptedIntoSlashing_filter(&self) -> alloy_contract::Event<&P, OptedIntoSlashing, N> {
self.event_filter::<OptedIntoSlashing>()
}
pub fn SlashingAbilityRevoked_filter(
&self,
) -> alloy_contract::Event<&P, SlashingAbilityRevoked, N> {
self.event_filter::<SlashingAbilityRevoked>()
}
}
}