#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style,
clippy::empty_structs_with_brackets
)]
pub mod IEigenPodManager {
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 CurrentlyPaused;
#[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<CurrentlyPaused> for UnderlyingRustTuple<'_> {
fn from(value: CurrentlyPaused) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for CurrentlyPaused {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for CurrentlyPaused {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "CurrentlyPaused()";
const SELECTOR: [u8; 4] = [132u8, 10u8, 72u8, 213u8];
#[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 abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Self::new)
}
}
};
#[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 EigenPodAlreadyExists;
#[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<EigenPodAlreadyExists> for UnderlyingRustTuple<'_> {
fn from(value: EigenPodAlreadyExists) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for EigenPodAlreadyExists {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for EigenPodAlreadyExists {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "EigenPodAlreadyExists()";
const SELECTOR: [u8; 4] = [12u8, 106u8, 20u8, 132u8];
#[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 abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Self::new)
}
}
};
#[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 InputAddressZero;
#[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<InputAddressZero> for UnderlyingRustTuple<'_> {
fn from(value: InputAddressZero) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for InputAddressZero {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InputAddressZero {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InputAddressZero()";
const SELECTOR: [u8; 4] = [115u8, 99u8, 33u8, 118u8];
#[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 abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Self::new)
}
}
};
#[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 InvalidNewPausedStatus;
#[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<InvalidNewPausedStatus> for UnderlyingRustTuple<'_> {
fn from(value: InvalidNewPausedStatus) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidNewPausedStatus {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InvalidNewPausedStatus {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InvalidNewPausedStatus()";
const SELECTOR: [u8; 4] = [198u8, 29u8, 202u8, 93u8];
#[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 abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Self::new)
}
}
};
#[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 InvalidStrategy;
#[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<InvalidStrategy> for UnderlyingRustTuple<'_> {
fn from(value: InvalidStrategy) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidStrategy {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InvalidStrategy {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InvalidStrategy()";
const SELECTOR: [u8; 4] = [78u8, 35u8, 110u8, 154u8];
#[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 abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Self::new)
}
}
};
#[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 LegacyWithdrawalsNotCompleted;
#[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<LegacyWithdrawalsNotCompleted> for UnderlyingRustTuple<'_> {
fn from(value: LegacyWithdrawalsNotCompleted) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for LegacyWithdrawalsNotCompleted {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for LegacyWithdrawalsNotCompleted {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "LegacyWithdrawalsNotCompleted()";
const SELECTOR: [u8; 4] = [75u8, 105u8, 43u8, 207u8];
#[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 abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Self::new)
}
}
};
#[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 OnlyDelegationManager;
#[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<OnlyDelegationManager> for UnderlyingRustTuple<'_> {
fn from(value: OnlyDelegationManager) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyDelegationManager {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for OnlyDelegationManager {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "OnlyDelegationManager()";
const SELECTOR: [u8; 4] = [247u8, 57u8, 88u8, 155u8];
#[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 abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Self::new)
}
}
};
#[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 OnlyEigenPod;
#[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<OnlyEigenPod> for UnderlyingRustTuple<'_> {
fn from(value: OnlyEigenPod) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyEigenPod {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for OnlyEigenPod {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "OnlyEigenPod()";
const SELECTOR: [u8; 4] = [37u8, 194u8, 218u8, 226u8];
#[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 abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Self::new)
}
}
};
#[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 OnlyPauser;
#[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<OnlyPauser> for UnderlyingRustTuple<'_> {
fn from(value: OnlyPauser) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyPauser {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for OnlyPauser {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "OnlyPauser()";
const SELECTOR: [u8; 4] = [117u8, 223u8, 81u8, 220u8];
#[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 abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Self::new)
}
}
};
#[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 OnlyUnpauser;
#[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<OnlyUnpauser> for UnderlyingRustTuple<'_> {
fn from(value: OnlyUnpauser) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyUnpauser {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for OnlyUnpauser {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "OnlyUnpauser()";
const SELECTOR: [u8; 4] = [121u8, 72u8, 33u8, 255u8];
#[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 abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Self::new)
}
}
};
#[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 SharesNegative;
#[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<SharesNegative> for UnderlyingRustTuple<'_> {
fn from(value: SharesNegative) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for SharesNegative {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for SharesNegative {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "SharesNegative()";
const SELECTOR: [u8; 4] = [239u8, 20u8, 125u8, 225u8];
#[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 abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Self::new)
}
}
};
#[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 SharesNotMultipleOfGwei;
#[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<SharesNotMultipleOfGwei> for UnderlyingRustTuple<'_> {
fn from(value: SharesNotMultipleOfGwei) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for SharesNotMultipleOfGwei {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for SharesNotMultipleOfGwei {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "SharesNotMultipleOfGwei()";
const SELECTOR: [u8; 4] = [143u8, 160u8, 229u8, 118u8];
#[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 abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
data,
)
.map(Self::new)
}
}
};
#[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 BeaconChainETHDeposited {
#[allow(missing_docs)]
pub podOwner: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub amount: 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;
#[automatically_derived]
impl alloy_sol_types::SolEvent for BeaconChainETHDeposited {
type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
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 = "BeaconChainETHDeposited(address,uint256)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
53u8, 168u8, 92u8, 171u8, 198u8, 3u8, 244u8, 138u8, 187u8, 43u8, 113u8, 217u8,
251u8, 216u8, 173u8, 234u8, 124u8, 68u8, 157u8, 127u8, 11u8, 233u8, 0u8, 174u8,
122u8, 41u8, 134u8, 234u8, 54u8, 156u8, 61u8, 13u8,
]);
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 {
podOwner: topics.1,
amount: 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<256> as alloy_sol_types::SolType>::tokenize(
&self.amount,
),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(Self::SIGNATURE_HASH.into(), self.podOwner.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.podOwner,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for BeaconChainETHDeposited {
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<&BeaconChainETHDeposited> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &BeaconChainETHDeposited) -> 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 BeaconChainETHWithdrawalCompleted {
#[allow(missing_docs)]
pub podOwner: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub shares: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub nonce: alloy::sol_types::private::primitives::aliases::U96,
#[allow(missing_docs)]
pub delegatedAddress: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub withdrawer: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub withdrawalRoot: alloy::sol_types::private::FixedBytes<32>,
}
#[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 BeaconChainETHWithdrawalCompleted {
type DataTuple<'a> = (
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<96>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::FixedBytes<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,
);
const SIGNATURE: &'static str =
"BeaconChainETHWithdrawalCompleted(address,uint256,uint96,address,address,bytes32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
166u8, 186u8, 177u8, 213u8, 90u8, 54u8, 31u8, 206u8, 162u8, 238u8, 226u8,
188u8, 148u8, 145u8, 228u8, 240u8, 30u8, 108u8, 243u8, 51u8, 223u8, 3u8, 201u8,
196u8, 242u8, 193u8, 68u8, 70u8, 100u8, 41u8, 247u8, 214u8,
]);
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 {
podOwner: topics.1,
shares: data.0,
nonce: data.1,
delegatedAddress: data.2,
withdrawer: data.3,
withdrawalRoot: data.4,
}
}
#[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<
256,
> as alloy_sol_types::SolType>::tokenize(&self.shares),
<alloy::sol_types::sol_data::Uint<
96,
> as alloy_sol_types::SolType>::tokenize(&self.nonce),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.delegatedAddress,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.withdrawer,
),
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.withdrawalRoot),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(Self::SIGNATURE_HASH.into(), self.podOwner.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.podOwner,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for BeaconChainETHWithdrawalCompleted {
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<&BeaconChainETHWithdrawalCompleted> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &BeaconChainETHWithdrawalCompleted) -> 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 BeaconChainSlashingFactorDecreased {
#[allow(missing_docs)]
pub staker: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub prevBeaconChainSlashingFactor: u64,
#[allow(missing_docs)]
pub newBeaconChainSlashingFactor: u64,
}
#[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 BeaconChainSlashingFactorDecreased {
type DataTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Uint<64>,
);
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 =
"BeaconChainSlashingFactorDecreased(address,uint64,uint64)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
177u8, 96u8, 171u8, 133u8, 137u8, 191u8, 71u8, 220u8, 4u8, 234u8, 17u8, 181u8,
13u8, 70u8, 103u8, 141u8, 33u8, 89u8, 12u8, 234u8, 46u8, 211u8, 228u8, 84u8,
231u8, 189u8, 62u8, 65u8, 81u8, 15u8, 152u8, 207u8,
]);
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 {
staker: data.0,
prevBeaconChainSlashingFactor: data.1,
newBeaconChainSlashingFactor: data.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<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.staker,
),
<alloy::sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
&self.prevBeaconChainSlashingFactor,
),
<alloy::sol_types::sol_data::Uint<64> as alloy_sol_types::SolType>::tokenize(
&self.newBeaconChainSlashingFactor,
),
)
}
#[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 BeaconChainSlashingFactorDecreased {
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<&BeaconChainSlashingFactorDecreased> for alloy_sol_types::private::LogData {
#[inline]
fn from(
this: &BeaconChainSlashingFactorDecreased,
) -> 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 BurnableETHSharesIncreased {
#[allow(missing_docs)]
pub shares: 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;
#[automatically_derived]
impl alloy_sol_types::SolEvent for BurnableETHSharesIncreased {
type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
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 = "BurnableETHSharesIncreased(uint256)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
30u8, 208u8, 75u8, 127u8, 210u8, 98u8, 192u8, 217u8, 229u8, 15u8, 160u8, 41u8,
87u8, 243u8, 42u8, 129u8, 161u8, 81u8, 240u8, 59u8, 170u8, 163u8, 103u8, 250u8,
238u8, 220u8, 117u8, 33u8, 176u8, 1u8, 196u8, 164u8,
]);
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 { shares: 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<256> as alloy_sol_types::SolType>::tokenize(
&self.shares,
),
)
}
#[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 BurnableETHSharesIncreased {
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<&BurnableETHSharesIncreased> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &BurnableETHSharesIncreased) -> 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 NewTotalShares {
#[allow(missing_docs)]
pub podOwner: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub newTotalShares: alloy::sol_types::private::primitives::aliases::I256,
}
#[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 NewTotalShares {
type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,);
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 = "NewTotalShares(address,int256)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
212u8, 222u8, 247u8, 109u8, 109u8, 43u8, 237u8, 111u8, 20u8, 213u8, 205u8,
154u8, 247u8, 60u8, 194u8, 145u8, 61u8, 97u8, 141u8, 0u8, 237u8, 222u8, 66u8,
67u8, 46u8, 129u8, 192u8, 155u8, 254u8, 7u8, 112u8, 152u8,
]);
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 {
podOwner: topics.1,
newTotalShares: 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::Int<256> as alloy_sol_types::SolType>::tokenize(
&self.newTotalShares,
),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(Self::SIGNATURE_HASH.into(), self.podOwner.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.podOwner,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for NewTotalShares {
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<&NewTotalShares> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &NewTotalShares) -> 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 Paused {
#[allow(missing_docs)]
pub account: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub newPausedStatus: 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;
#[automatically_derived]
impl alloy_sol_types::SolEvent for Paused {
type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
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 = "Paused(address,uint256)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
171u8, 64u8, 163u8, 116u8, 188u8, 81u8, 222u8, 55u8, 34u8, 0u8, 168u8, 188u8,
152u8, 26u8, 248u8, 201u8, 236u8, 220u8, 8u8, 223u8, 218u8, 239u8, 11u8, 182u8,
224u8, 159u8, 136u8, 243u8, 198u8, 22u8, 239u8, 61u8,
]);
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 {
account: topics.1,
newPausedStatus: 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<256> as alloy_sol_types::SolType>::tokenize(
&self.newPausedStatus,
),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(Self::SIGNATURE_HASH.into(), self.account.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.account,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for Paused {
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<&Paused> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &Paused) -> 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 PodDeployed {
#[allow(missing_docs)]
pub eigenPod: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub podOwner: 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 PodDeployed {
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 = "PodDeployed(address,address)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
33u8, 201u8, 157u8, 13u8, 176u8, 34u8, 19u8, 195u8, 47u8, 255u8, 91u8, 5u8,
207u8, 10u8, 113u8, 138u8, 181u8, 248u8, 88u8, 128u8, 43u8, 145u8, 73u8, 143u8,
128u8, 216u8, 34u8, 112u8, 40u8, 157u8, 133u8, 106u8,
]);
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 {
eigenPod: topics.1,
podOwner: 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.eigenPod.clone(),
self.podOwner.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.eigenPod,
);
out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.podOwner,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for PodDeployed {
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<&PodDeployed> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &PodDeployed) -> 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 PodSharesUpdated {
#[allow(missing_docs)]
pub podOwner: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub sharesDelta: alloy::sol_types::private::primitives::aliases::I256,
}
#[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 PodSharesUpdated {
type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,);
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 = "PodSharesUpdated(address,int256)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
78u8, 43u8, 121u8, 29u8, 237u8, 204u8, 217u8, 251u8, 48u8, 20u8, 27u8, 8u8,
140u8, 171u8, 245u8, 193u8, 74u8, 137u8, 18u8, 181u8, 47u8, 89u8, 55u8, 92u8,
149u8, 192u8, 16u8, 112u8, 11u8, 140u8, 97u8, 147u8,
]);
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 {
podOwner: topics.1,
sharesDelta: 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::Int<256> as alloy_sol_types::SolType>::tokenize(
&self.sharesDelta,
),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(Self::SIGNATURE_HASH.into(), self.podOwner.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.podOwner,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for PodSharesUpdated {
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<&PodSharesUpdated> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &PodSharesUpdated) -> 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 Unpaused {
#[allow(missing_docs)]
pub account: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub newPausedStatus: 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;
#[automatically_derived]
impl alloy_sol_types::SolEvent for Unpaused {
type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
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 = "Unpaused(address,uint256)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 =
alloy_sol_types::private::B256::new([
53u8, 130u8, 209u8, 130u8, 142u8, 38u8, 191u8, 86u8, 189u8, 128u8, 21u8, 2u8,
188u8, 2u8, 26u8, 192u8, 188u8, 138u8, 251u8, 87u8, 200u8, 38u8, 228u8, 152u8,
107u8, 69u8, 89u8, 60u8, 143u8, 173u8, 56u8, 156u8,
]);
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 {
account: topics.1,
newPausedStatus: 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<256> as alloy_sol_types::SolType>::tokenize(
&self.newPausedStatus,
),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(Self::SIGNATURE_HASH.into(), self.account.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.account,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for Unpaused {
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<&Unpaused> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &Unpaused) -> 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 addSharesCall {
#[allow(missing_docs)]
pub staker: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub strategy: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub shares: 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 addSharesReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub _1: 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,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
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<addSharesCall> for UnderlyingRustTuple<'_> {
fn from(value: addSharesCall) -> Self {
(value.staker, value.strategy, value.shares)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for addSharesCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
staker: tuple.0,
strategy: tuple.1,
shares: tuple.2,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
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<addSharesReturn> for UnderlyingRustTuple<'_> {
fn from(value: addSharesReturn) -> Self {
(value._0, value._1)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for addSharesReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
_0: tuple.0,
_1: tuple.1,
}
}
}
}
impl addSharesReturn {
fn _tokenize(&self) -> <addSharesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self._0,
),
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self._1,
),
)
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for addSharesCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
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 = addSharesReturn;
type ReturnTuple<'a> = (
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 = "addShares(address,address,uint256)";
const SELECTOR: [u8; 4] = [80u8, 255u8, 114u8, 37u8];
#[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,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.strategy,
),
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self.shares,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
addSharesReturn::_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 beaconChainETHStrategyCall;
#[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 beaconChainETHStrategyReturn {
#[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<beaconChainETHStrategyCall> for UnderlyingRustTuple<'_> {
fn from(value: beaconChainETHStrategyCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for beaconChainETHStrategyCall {
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<beaconChainETHStrategyReturn> for UnderlyingRustTuple<'_> {
fn from(value: beaconChainETHStrategyReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for beaconChainETHStrategyReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for beaconChainETHStrategyCall {
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 = "beaconChainETHStrategy()";
const SELECTOR: [u8; 4] = [145u8, 4u8, 195u8, 25u8];
#[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: beaconChainETHStrategyReturn = 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: beaconChainETHStrategyReturn = 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 beaconChainSlashingFactorCall {
#[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 beaconChainSlashingFactorReturn {
#[allow(missing_docs)]
pub _0: u64,
}
#[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<beaconChainSlashingFactorCall> for UnderlyingRustTuple<'_> {
fn from(value: beaconChainSlashingFactorCall) -> Self {
(value.staker,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for beaconChainSlashingFactorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { staker: tuple.0 }
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64,);
#[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<beaconChainSlashingFactorReturn> for UnderlyingRustTuple<'_> {
fn from(value: beaconChainSlashingFactorReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for beaconChainSlashingFactorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for beaconChainSlashingFactorCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = u64;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "beaconChainSlashingFactor(address)";
const SELECTOR: [u8; 4] = [163u8, 215u8, 94u8, 9u8];
#[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::Uint<64> 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: beaconChainSlashingFactorReturn = 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: beaconChainSlashingFactorReturn = 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 burnableETHSharesCall;
#[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 burnableETHSharesReturn {
#[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> = ();
#[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<burnableETHSharesCall> for UnderlyingRustTuple<'_> {
fn from(value: burnableETHSharesCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnableETHSharesCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[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<burnableETHSharesReturn> for UnderlyingRustTuple<'_> {
fn from(value: burnableETHSharesReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for burnableETHSharesReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for burnableETHSharesCall {
type Parameters<'a> = ();
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 = "burnableETHShares()";
const SELECTOR: [u8; 4] = [245u8, 212u8, 254u8, 211u8];
#[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::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: burnableETHSharesReturn = 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: burnableETHSharesReturn = 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 createPodCall;
#[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 createPodReturn {
#[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<createPodCall> for UnderlyingRustTuple<'_> {
fn from(value: createPodCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for createPodCall {
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<createPodReturn> for UnderlyingRustTuple<'_> {
fn from(value: createPodReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for createPodReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for createPodCall {
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 = "createPod()";
const SELECTOR: [u8; 4] = [132u8, 216u8, 16u8, 98u8];
#[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: createPodReturn = 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: createPodReturn = 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 eigenPodBeaconCall;
#[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 eigenPodBeaconReturn {
#[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<eigenPodBeaconCall> for UnderlyingRustTuple<'_> {
fn from(value: eigenPodBeaconCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for eigenPodBeaconCall {
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<eigenPodBeaconReturn> for UnderlyingRustTuple<'_> {
fn from(value: eigenPodBeaconReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for eigenPodBeaconReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for eigenPodBeaconCall {
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 = "eigenPodBeacon()";
const SELECTOR: [u8; 4] = [41u8, 43u8, 123u8, 43u8];
#[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: eigenPodBeaconReturn = 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: eigenPodBeaconReturn = 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 ethPOSCall;
#[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 ethPOSReturn {
#[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<ethPOSCall> for UnderlyingRustTuple<'_> {
fn from(value: ethPOSCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ethPOSCall {
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<ethPOSReturn> for UnderlyingRustTuple<'_> {
fn from(value: ethPOSReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ethPOSReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for ethPOSCall {
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 = "ethPOS()";
const SELECTOR: [u8; 4] = [116u8, 205u8, 215u8, 152u8];
#[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: ethPOSReturn = 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: ethPOSReturn = 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 getPodCall {
#[allow(missing_docs)]
pub podOwner: 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 getPodReturn {
#[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> = (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<getPodCall> for UnderlyingRustTuple<'_> {
fn from(value: getPodCall) -> Self {
(value.podOwner,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPodCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { podOwner: tuple.0 }
}
}
}
{
#[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<getPodReturn> for UnderlyingRustTuple<'_> {
fn from(value: getPodReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for getPodReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getPodCall {
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::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 = "getPod(address)";
const SELECTOR: [u8; 4] = [163u8, 132u8, 6u8, 163u8];
#[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.podOwner,
),
)
}
#[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: getPodReturn = 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: getPodReturn = 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 hasPodCall {
#[allow(missing_docs)]
pub podOwner: 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 hasPodReturn {
#[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<hasPodCall> for UnderlyingRustTuple<'_> {
fn from(value: hasPodCall) -> Self {
(value.podOwner,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasPodCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { podOwner: 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<hasPodReturn> for UnderlyingRustTuple<'_> {
fn from(value: hasPodReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasPodReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for hasPodCall {
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 = "hasPod(address)";
const SELECTOR: [u8; 4] = [246u8, 132u8, 141u8, 36u8];
#[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.podOwner,
),
)
}
#[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: hasPodReturn = 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: hasPodReturn = 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 increaseBurnableSharesCall {
#[allow(missing_docs)]
pub strategy: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub addedSharesToBurn: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct increaseBurnableSharesReturn {}
#[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<increaseBurnableSharesCall> for UnderlyingRustTuple<'_> {
fn from(value: increaseBurnableSharesCall) -> Self {
(value.strategy, value.addedSharesToBurn)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseBurnableSharesCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
strategy: tuple.0,
addedSharesToBurn: 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<increaseBurnableSharesReturn> for UnderlyingRustTuple<'_> {
fn from(value: increaseBurnableSharesReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseBurnableSharesReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl increaseBurnableSharesReturn {
fn _tokenize(
&self,
) -> <increaseBurnableSharesCall as alloy_sol_types::SolCall>::ReturnToken<'_>
{
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for increaseBurnableSharesCall {
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 = increaseBurnableSharesReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "increaseBurnableShares(address,uint256)";
const SELECTOR: [u8; 4] = [222u8, 190u8, 30u8, 171u8];
#[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.strategy,
),
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self.addedSharesToBurn,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
increaseBurnableSharesReturn::_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 numPodsCall;
#[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 numPodsReturn {
#[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> = ();
#[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<numPodsCall> for UnderlyingRustTuple<'_> {
fn from(value: numPodsCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for numPodsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[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<numPodsReturn> for UnderlyingRustTuple<'_> {
fn from(value: numPodsReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for numPodsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for numPodsCall {
type Parameters<'a> = ();
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 = "numPods()";
const SELECTOR: [u8; 4] = [166u8, 165u8, 9u8, 190u8];
#[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::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: numPodsReturn = 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: numPodsReturn = 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 ownerToPodCall {
#[allow(missing_docs)]
pub podOwner: 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 ownerToPodReturn {
#[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> = (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<ownerToPodCall> for UnderlyingRustTuple<'_> {
fn from(value: ownerToPodCall) -> Self {
(value.podOwner,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerToPodCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { podOwner: tuple.0 }
}
}
}
{
#[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<ownerToPodReturn> for UnderlyingRustTuple<'_> {
fn from(value: ownerToPodReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerToPodReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for ownerToPodCall {
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::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 = "ownerToPod(address)";
const SELECTOR: [u8; 4] = [155u8, 160u8, 98u8, 117u8];
#[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.podOwner,
),
)
}
#[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: ownerToPodReturn = 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: ownerToPodReturn = 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 pauseCall {
#[allow(missing_docs)]
pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pauseReturn {}
#[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<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<pauseCall> for UnderlyingRustTuple<'_> {
fn from(value: pauseCall) -> Self {
(value.newPausedStatus,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
newPausedStatus: 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<pauseReturn> for UnderlyingRustTuple<'_> {
fn from(value: pauseReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl pauseReturn {
fn _tokenize(&self) -> <pauseCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for pauseCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = pauseReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "pause(uint256)";
const SELECTOR: [u8; 4] = [19u8, 100u8, 57u8, 221u8];
#[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::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self.newPausedStatus,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
pauseReturn::_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 pauseAllCall;
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pauseAllReturn {}
#[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<pauseAllCall> for UnderlyingRustTuple<'_> {
fn from(value: pauseAllCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseAllCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[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<pauseAllReturn> for UnderlyingRustTuple<'_> {
fn from(value: pauseAllReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauseAllReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl pauseAllReturn {
fn _tokenize(&self) -> <pauseAllCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for pauseAllCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = pauseAllReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "pauseAll()";
const SELECTOR: [u8; 4] = [89u8, 92u8, 106u8, 103u8];
#[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<'_> {
pauseAllReturn::_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 paused_0Call {
#[allow(missing_docs)]
pub index: u8,
}
#[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 paused_0Return {
#[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::Uint<8>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u8,);
#[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<paused_0Call> for UnderlyingRustTuple<'_> {
fn from(value: paused_0Call) -> Self {
(value.index,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_0Call {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { index: 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<paused_0Return> for UnderlyingRustTuple<'_> {
fn from(value: paused_0Return) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_0Return {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for paused_0Call {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<8>,);
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 = "paused(uint8)";
const SELECTOR: [u8; 4] = [90u8, 200u8, 106u8, 183u8];
#[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::Uint<8> as alloy_sol_types::SolType>::tokenize(
&self.index,
),
)
}
#[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: paused_0Return = 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: paused_0Return = 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 paused_1Call;
#[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 paused_1Return {
#[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> = ();
#[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<paused_1Call> for UnderlyingRustTuple<'_> {
fn from(value: paused_1Call) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_1Call {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[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<paused_1Return> for UnderlyingRustTuple<'_> {
fn from(value: paused_1Return) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for paused_1Return {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for paused_1Call {
type Parameters<'a> = ();
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 = "paused()";
const SELECTOR: [u8; 4] = [92u8, 151u8, 90u8, 187u8];
#[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::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: paused_1Return = 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: paused_1Return = 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 pauserRegistryCall;
#[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 pauserRegistryReturn {
#[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<pauserRegistryCall> for UnderlyingRustTuple<'_> {
fn from(value: pauserRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauserRegistryCall {
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<pauserRegistryReturn> for UnderlyingRustTuple<'_> {
fn from(value: pauserRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for pauserRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for pauserRegistryCall {
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 = "pauserRegistry()";
const SELECTOR: [u8; 4] = [136u8, 111u8, 17u8, 149u8];
#[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: pauserRegistryReturn = 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: pauserRegistryReturn = 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 podOwnerDepositSharesCall {
#[allow(missing_docs)]
pub podOwner: 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 podOwnerDepositSharesReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::primitives::aliases::I256,
}
#[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<podOwnerDepositSharesCall> for UnderlyingRustTuple<'_> {
fn from(value: podOwnerDepositSharesCall) -> Self {
(value.podOwner,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for podOwnerDepositSharesCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { podOwner: tuple.0 }
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Int<256>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::I256,);
#[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<podOwnerDepositSharesReturn> for UnderlyingRustTuple<'_> {
fn from(value: podOwnerDepositSharesReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for podOwnerDepositSharesReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for podOwnerDepositSharesCall {
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::I256;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Int<256>,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "podOwnerDepositShares(address)";
const SELECTOR: [u8; 4] = [212u8, 142u8, 136u8, 148u8];
#[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.podOwner,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Int<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: podOwnerDepositSharesReturn = 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: podOwnerDepositSharesReturn = 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 recordBeaconChainETHBalanceUpdateCall {
#[allow(missing_docs)]
pub podOwner: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub prevRestakedBalanceWei: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub balanceDeltaWei: alloy::sol_types::private::primitives::aliases::I256,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct recordBeaconChainETHBalanceUpdateReturn {}
#[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>,
alloy::sol_types::sol_data::Int<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::primitives::aliases::U256,
alloy::sol_types::private::primitives::aliases::I256,
);
#[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<recordBeaconChainETHBalanceUpdateCall> for UnderlyingRustTuple<'_> {
fn from(value: recordBeaconChainETHBalanceUpdateCall) -> Self {
(
value.podOwner,
value.prevRestakedBalanceWei,
value.balanceDeltaWei,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for recordBeaconChainETHBalanceUpdateCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
podOwner: tuple.0,
prevRestakedBalanceWei: tuple.1,
balanceDeltaWei: tuple.2,
}
}
}
}
{
#[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<recordBeaconChainETHBalanceUpdateReturn> for UnderlyingRustTuple<'_> {
fn from(value: recordBeaconChainETHBalanceUpdateReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for recordBeaconChainETHBalanceUpdateReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl recordBeaconChainETHBalanceUpdateReturn {
fn _tokenize(
&self,
) -> <recordBeaconChainETHBalanceUpdateCall as alloy_sol_types::SolCall>::ReturnToken<'_>
{
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for recordBeaconChainETHBalanceUpdateCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Int<256>,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = recordBeaconChainETHBalanceUpdateReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str =
"recordBeaconChainETHBalanceUpdate(address,uint256,int256)";
const SELECTOR: [u8; 4] = [161u8, 202u8, 120u8, 11u8];
#[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.podOwner,
),
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self.prevRestakedBalanceWei,
),
<alloy::sol_types::sol_data::Int<256> as alloy_sol_types::SolType>::tokenize(
&self.balanceDeltaWei,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
recordBeaconChainETHBalanceUpdateReturn::_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 removeDepositSharesCall {
#[allow(missing_docs)]
pub staker: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub strategy: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub depositSharesToRemove: 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 removeDepositSharesReturn {
#[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::Address,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
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<removeDepositSharesCall> for UnderlyingRustTuple<'_> {
fn from(value: removeDepositSharesCall) -> Self {
(value.staker, value.strategy, value.depositSharesToRemove)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeDepositSharesCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
staker: tuple.0,
strategy: tuple.1,
depositSharesToRemove: tuple.2,
}
}
}
}
{
#[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<removeDepositSharesReturn> for UnderlyingRustTuple<'_> {
fn from(value: removeDepositSharesReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeDepositSharesReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for removeDepositSharesCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
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 = 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 = "removeDepositShares(address,address,uint256)";
const SELECTOR: [u8; 4] = [114u8, 74u8, 244u8, 35u8];
#[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,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.strategy,
),
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self.depositSharesToRemove,
),
)
}
#[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: removeDepositSharesReturn = 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: removeDepositSharesReturn = 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 stakeCall {
#[allow(missing_docs)]
pub pubkey: alloy::sol_types::private::Bytes,
#[allow(missing_docs)]
pub signature: alloy::sol_types::private::Bytes,
#[allow(missing_docs)]
pub depositDataRoot: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct stakeReturn {}
#[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::Bytes,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::FixedBytes<32>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Bytes,
alloy::sol_types::private::Bytes,
alloy::sol_types::private::FixedBytes<32>,
);
#[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<stakeCall> for UnderlyingRustTuple<'_> {
fn from(value: stakeCall) -> Self {
(value.pubkey, value.signature, value.depositDataRoot)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for stakeCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
pubkey: tuple.0,
signature: tuple.1,
depositDataRoot: tuple.2,
}
}
}
}
{
#[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<stakeReturn> for UnderlyingRustTuple<'_> {
fn from(value: stakeReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for stakeReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl stakeReturn {
fn _tokenize(&self) -> <stakeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for stakeCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::FixedBytes<32>,
);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = stakeReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "stake(bytes,bytes,bytes32)";
const SELECTOR: [u8; 4] = [155u8, 78u8, 70u8, 52u8];
#[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::Bytes as alloy_sol_types::SolType>::tokenize(
&self.pubkey,
),
<alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
&self.signature,
),
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.depositDataRoot),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
stakeReturn::_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 stakerDepositSharesCall {
#[allow(missing_docs)]
pub user: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub strategy: 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 stakerDepositSharesReturn {
#[allow(missing_docs)]
pub depositShares: 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<stakerDepositSharesCall> for UnderlyingRustTuple<'_> {
fn from(value: stakerDepositSharesCall) -> Self {
(value.user, value.strategy)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for stakerDepositSharesCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
user: tuple.0,
strategy: 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<stakerDepositSharesReturn> for UnderlyingRustTuple<'_> {
fn from(value: stakerDepositSharesReturn) -> Self {
(value.depositShares,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for stakerDepositSharesReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
depositShares: tuple.0,
}
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for stakerDepositSharesCall {
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 = 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 = "stakerDepositShares(address,address)";
const SELECTOR: [u8; 4] = [254u8, 36u8, 58u8, 23u8];
#[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.user,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.strategy,
),
)
}
#[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: stakerDepositSharesReturn = r.into();
r.depositShares
},
)
}
#[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: stakerDepositSharesReturn = r.into();
r.depositShares
})
}
}
};
#[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 unpauseCall {
#[allow(missing_docs)]
pub newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct unpauseReturn {}
#[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<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<unpauseCall> for UnderlyingRustTuple<'_> {
fn from(value: unpauseCall) -> Self {
(value.newPausedStatus,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
newPausedStatus: 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<unpauseReturn> for UnderlyingRustTuple<'_> {
fn from(value: unpauseReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for unpauseReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl unpauseReturn {
fn _tokenize(&self) -> <unpauseCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for unpauseCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = unpauseReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "unpause(uint256)";
const SELECTOR: [u8; 4] = [250u8, 188u8, 28u8, 188u8];
#[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::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self.newPausedStatus,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
unpauseReturn::_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 versionCall;
#[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 versionReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::String,
}
#[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<versionCall> for UnderlyingRustTuple<'_> {
fn from(value: versionCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
#[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<versionReturn> for UnderlyingRustTuple<'_> {
fn from(value: versionReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for versionCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::String;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "version()";
const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
#[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::String 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: versionReturn = 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: versionReturn = 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 withdrawSharesAsTokensCall {
#[allow(missing_docs)]
pub staker: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub strategy: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub token: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub shares: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct withdrawSharesAsTokensReturn {}
#[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,
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::Address,
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<withdrawSharesAsTokensCall> for UnderlyingRustTuple<'_> {
fn from(value: withdrawSharesAsTokensCall) -> Self {
(value.staker, value.strategy, value.token, value.shares)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawSharesAsTokensCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
staker: tuple.0,
strategy: tuple.1,
token: tuple.2,
shares: 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<withdrawSharesAsTokensReturn> for UnderlyingRustTuple<'_> {
fn from(value: withdrawSharesAsTokensReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawSharesAsTokensReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl withdrawSharesAsTokensReturn {
fn _tokenize(
&self,
) -> <withdrawSharesAsTokensCall as alloy_sol_types::SolCall>::ReturnToken<'_>
{
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for withdrawSharesAsTokensCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
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 = withdrawSharesAsTokensReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str =
"withdrawSharesAsTokens(address,address,address,uint256)";
const SELECTOR: [u8; 4] = [46u8, 174u8, 65u8, 140u8];
#[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,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.strategy,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.token,
),
<alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
&self.shares,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
withdrawSharesAsTokensReturn::_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)]
pub enum IEigenPodManagerCalls {
#[allow(missing_docs)]
addShares(addSharesCall),
#[allow(missing_docs)]
beaconChainETHStrategy(beaconChainETHStrategyCall),
#[allow(missing_docs)]
beaconChainSlashingFactor(beaconChainSlashingFactorCall),
#[allow(missing_docs)]
burnableETHShares(burnableETHSharesCall),
#[allow(missing_docs)]
createPod(createPodCall),
#[allow(missing_docs)]
eigenPodBeacon(eigenPodBeaconCall),
#[allow(missing_docs)]
ethPOS(ethPOSCall),
#[allow(missing_docs)]
getPod(getPodCall),
#[allow(missing_docs)]
hasPod(hasPodCall),
#[allow(missing_docs)]
increaseBurnableShares(increaseBurnableSharesCall),
#[allow(missing_docs)]
numPods(numPodsCall),
#[allow(missing_docs)]
ownerToPod(ownerToPodCall),
#[allow(missing_docs)]
pause(pauseCall),
#[allow(missing_docs)]
pauseAll(pauseAllCall),
#[allow(missing_docs)]
paused_0(paused_0Call),
#[allow(missing_docs)]
paused_1(paused_1Call),
#[allow(missing_docs)]
pauserRegistry(pauserRegistryCall),
#[allow(missing_docs)]
podOwnerDepositShares(podOwnerDepositSharesCall),
#[allow(missing_docs)]
recordBeaconChainETHBalanceUpdate(recordBeaconChainETHBalanceUpdateCall),
#[allow(missing_docs)]
removeDepositShares(removeDepositSharesCall),
#[allow(missing_docs)]
stake(stakeCall),
#[allow(missing_docs)]
stakerDepositShares(stakerDepositSharesCall),
#[allow(missing_docs)]
unpause(unpauseCall),
#[allow(missing_docs)]
version(versionCall),
#[allow(missing_docs)]
withdrawSharesAsTokens(withdrawSharesAsTokensCall),
}
#[automatically_derived]
impl IEigenPodManagerCalls {
pub const SELECTORS: &'static [[u8; 4usize]] = &[
[19u8, 100u8, 57u8, 221u8],
[41u8, 43u8, 123u8, 43u8],
[46u8, 174u8, 65u8, 140u8],
[80u8, 255u8, 114u8, 37u8],
[84u8, 253u8, 77u8, 80u8],
[89u8, 92u8, 106u8, 103u8],
[90u8, 200u8, 106u8, 183u8],
[92u8, 151u8, 90u8, 187u8],
[114u8, 74u8, 244u8, 35u8],
[116u8, 205u8, 215u8, 152u8],
[132u8, 216u8, 16u8, 98u8],
[136u8, 111u8, 17u8, 149u8],
[145u8, 4u8, 195u8, 25u8],
[155u8, 78u8, 70u8, 52u8],
[155u8, 160u8, 98u8, 117u8],
[161u8, 202u8, 120u8, 11u8],
[163u8, 132u8, 6u8, 163u8],
[163u8, 215u8, 94u8, 9u8],
[166u8, 165u8, 9u8, 190u8],
[212u8, 142u8, 136u8, 148u8],
[222u8, 190u8, 30u8, 171u8],
[245u8, 212u8, 254u8, 211u8],
[246u8, 132u8, 141u8, 36u8],
[250u8, 188u8, 28u8, 188u8],
[254u8, 36u8, 58u8, 23u8],
];
}
#[automatically_derived]
impl alloy_sol_types::SolInterface for IEigenPodManagerCalls {
const NAME: &'static str = "IEigenPodManagerCalls";
const MIN_DATA_LENGTH: usize = 0usize;
const COUNT: usize = 25usize;
#[inline]
fn selector(&self) -> [u8; 4] {
match self {
Self::addShares(_) => <addSharesCall as alloy_sol_types::SolCall>::SELECTOR,
Self::beaconChainETHStrategy(_) => {
<beaconChainETHStrategyCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::beaconChainSlashingFactor(_) => {
<beaconChainSlashingFactorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::burnableETHShares(_) => {
<burnableETHSharesCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::createPod(_) => <createPodCall as alloy_sol_types::SolCall>::SELECTOR,
Self::eigenPodBeacon(_) => {
<eigenPodBeaconCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::ethPOS(_) => <ethPOSCall as alloy_sol_types::SolCall>::SELECTOR,
Self::getPod(_) => <getPodCall as alloy_sol_types::SolCall>::SELECTOR,
Self::hasPod(_) => <hasPodCall as alloy_sol_types::SolCall>::SELECTOR,
Self::increaseBurnableShares(_) => {
<increaseBurnableSharesCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::numPods(_) => <numPodsCall as alloy_sol_types::SolCall>::SELECTOR,
Self::ownerToPod(_) => <ownerToPodCall as alloy_sol_types::SolCall>::SELECTOR,
Self::pause(_) => <pauseCall as alloy_sol_types::SolCall>::SELECTOR,
Self::pauseAll(_) => <pauseAllCall as alloy_sol_types::SolCall>::SELECTOR,
Self::paused_0(_) => <paused_0Call as alloy_sol_types::SolCall>::SELECTOR,
Self::paused_1(_) => <paused_1Call as alloy_sol_types::SolCall>::SELECTOR,
Self::pauserRegistry(_) => {
<pauserRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::podOwnerDepositShares(_) => {
<podOwnerDepositSharesCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::recordBeaconChainETHBalanceUpdate(_) => {
<recordBeaconChainETHBalanceUpdateCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::removeDepositShares(_) => {
<removeDepositSharesCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::stake(_) => <stakeCall as alloy_sol_types::SolCall>::SELECTOR,
Self::stakerDepositShares(_) => {
<stakerDepositSharesCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::unpause(_) => <unpauseCall as alloy_sol_types::SolCall>::SELECTOR,
Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
Self::withdrawSharesAsTokens(_) => {
<withdrawSharesAsTokensCall 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<IEigenPodManagerCalls>] = &[
{
fn pause(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<pauseCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::pause)
}
pause
},
{
fn eigenPodBeacon(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<eigenPodBeaconCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::eigenPodBeacon)
}
eigenPodBeacon
},
{
fn withdrawSharesAsTokens(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<withdrawSharesAsTokensCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IEigenPodManagerCalls::withdrawSharesAsTokens)
}
withdrawSharesAsTokens
},
{
fn addShares(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<addSharesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::addShares)
}
addShares
},
{
fn version(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::version)
}
version
},
{
fn pauseAll(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<pauseAllCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::pauseAll)
}
pauseAll
},
{
fn paused_0(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<paused_0Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::paused_0)
}
paused_0
},
{
fn paused_1(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<paused_1Call as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::paused_1)
}
paused_1
},
{
fn removeDepositShares(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<removeDepositSharesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::removeDepositShares)
}
removeDepositShares
},
{
fn ethPOS(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<ethPOSCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::ethPOS)
}
ethPOS
},
{
fn createPod(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<createPodCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::createPod)
}
createPod
},
{
fn pauserRegistry(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<pauserRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::pauserRegistry)
}
pauserRegistry
},
{
fn beaconChainETHStrategy(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<beaconChainETHStrategyCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IEigenPodManagerCalls::beaconChainETHStrategy)
}
beaconChainETHStrategy
},
{
fn stake(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<stakeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::stake)
}
stake
},
{
fn ownerToPod(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<ownerToPodCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::ownerToPod)
}
ownerToPod
},
{
fn recordBeaconChainETHBalanceUpdate(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<recordBeaconChainETHBalanceUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
IEigenPodManagerCalls::recordBeaconChainETHBalanceUpdate,
)
}
recordBeaconChainETHBalanceUpdate
},
{
fn getPod(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<getPodCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::getPod)
}
getPod
},
{
fn beaconChainSlashingFactor(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<beaconChainSlashingFactorCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IEigenPodManagerCalls::beaconChainSlashingFactor)
}
beaconChainSlashingFactor
},
{
fn numPods(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<numPodsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::numPods)
}
numPods
},
{
fn podOwnerDepositShares(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<podOwnerDepositSharesCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IEigenPodManagerCalls::podOwnerDepositShares)
}
podOwnerDepositShares
},
{
fn increaseBurnableShares(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<increaseBurnableSharesCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IEigenPodManagerCalls::increaseBurnableShares)
}
increaseBurnableShares
},
{
fn burnableETHShares(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<burnableETHSharesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::burnableETHShares)
}
burnableETHShares
},
{
fn hasPod(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<hasPodCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::hasPod)
}
hasPod
},
{
fn unpause(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<unpauseCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::unpause)
}
unpause
},
{
fn stakerDepositShares(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<stakerDepositSharesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IEigenPodManagerCalls::stakerDepositShares)
}
stakerDepositShares
},
];
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<
IEigenPodManagerCalls,
>] = &[
{
fn pause(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<pauseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::pause)
}
pause
},
{
fn eigenPodBeacon(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<eigenPodBeaconCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerCalls::eigenPodBeacon)
}
eigenPodBeacon
},
{
fn withdrawSharesAsTokens(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<withdrawSharesAsTokensCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerCalls::withdrawSharesAsTokens)
}
withdrawSharesAsTokens
},
{
fn addShares(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<addSharesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::addShares)
}
addShares
},
{
fn version(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::version)
}
version
},
{
fn pauseAll(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<pauseAllCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::pauseAll)
}
pauseAll
},
{
fn paused_0(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<paused_0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::paused_0)
}
paused_0
},
{
fn paused_1(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<paused_1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::paused_1)
}
paused_1
},
{
fn removeDepositShares(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<removeDepositSharesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerCalls::removeDepositShares)
}
removeDepositShares
},
{
fn ethPOS(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<ethPOSCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::ethPOS)
}
ethPOS
},
{
fn createPod(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<createPodCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::createPod)
}
createPod
},
{
fn pauserRegistry(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<pauserRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerCalls::pauserRegistry)
}
pauserRegistry
},
{
fn beaconChainETHStrategy(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<beaconChainETHStrategyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerCalls::beaconChainETHStrategy)
}
beaconChainETHStrategy
},
{
fn stake(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<stakeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::stake)
}
stake
},
{
fn ownerToPod(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<ownerToPodCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::ownerToPod)
}
ownerToPod
},
{
fn recordBeaconChainETHBalanceUpdate(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<recordBeaconChainETHBalanceUpdateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
IEigenPodManagerCalls::recordBeaconChainETHBalanceUpdate,
)
}
recordBeaconChainETHBalanceUpdate
},
{
fn getPod(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<getPodCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::getPod)
}
getPod
},
{
fn beaconChainSlashingFactor(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<beaconChainSlashingFactorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerCalls::beaconChainSlashingFactor)
}
beaconChainSlashingFactor
},
{
fn numPods(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<numPodsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::numPods)
}
numPods
},
{
fn podOwnerDepositShares(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<podOwnerDepositSharesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerCalls::podOwnerDepositShares)
}
podOwnerDepositShares
},
{
fn increaseBurnableShares(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<increaseBurnableSharesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerCalls::increaseBurnableShares)
}
increaseBurnableShares
},
{
fn burnableETHShares(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<burnableETHSharesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerCalls::burnableETHShares)
}
burnableETHShares
},
{
fn hasPod(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<hasPodCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::hasPod)
}
hasPod
},
{
fn unpause(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<unpauseCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
.map(IEigenPodManagerCalls::unpause)
}
unpause
},
{
fn stakerDepositShares(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerCalls> {
<stakerDepositSharesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerCalls::stakerDepositShares)
}
stakerDepositShares
},
];
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::addShares(inner) => {
<addSharesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::beaconChainETHStrategy(inner) => {
<beaconChainETHStrategyCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::beaconChainSlashingFactor(inner) => {
<beaconChainSlashingFactorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::burnableETHShares(inner) => {
<burnableETHSharesCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::createPod(inner) => {
<createPodCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::eigenPodBeacon(inner) => {
<eigenPodBeaconCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::ethPOS(inner) => {
<ethPOSCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::getPod(inner) => {
<getPodCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::hasPod(inner) => {
<hasPodCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::increaseBurnableShares(inner) => {
<increaseBurnableSharesCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::numPods(inner) => {
<numPodsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::ownerToPod(inner) => {
<ownerToPodCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::pause(inner) => {
<pauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::pauseAll(inner) => {
<pauseAllCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::paused_0(inner) => {
<paused_0Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::paused_1(inner) => {
<paused_1Call as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::pauserRegistry(inner) => {
<pauserRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::podOwnerDepositShares(inner) => {
<podOwnerDepositSharesCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::recordBeaconChainETHBalanceUpdate(inner) => {
<recordBeaconChainETHBalanceUpdateCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::removeDepositShares(inner) => {
<removeDepositSharesCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::stake(inner) => {
<stakeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::stakerDepositShares(inner) => {
<stakerDepositSharesCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::unpause(inner) => {
<unpauseCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::version(inner) => {
<versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::withdrawSharesAsTokens(inner) => {
<withdrawSharesAsTokensCall 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::addShares(inner) => {
<addSharesCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::beaconChainETHStrategy(inner) => {
<beaconChainETHStrategyCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::beaconChainSlashingFactor(inner) => {
<beaconChainSlashingFactorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::burnableETHShares(inner) => {
<burnableETHSharesCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::createPod(inner) => {
<createPodCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::eigenPodBeacon(inner) => {
<eigenPodBeaconCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::ethPOS(inner) => {
<ethPOSCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
Self::getPod(inner) => {
<getPodCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
Self::hasPod(inner) => {
<hasPodCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
Self::increaseBurnableShares(inner) => {
<increaseBurnableSharesCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::numPods(inner) => {
<numPodsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
Self::ownerToPod(inner) => {
<ownerToPodCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::pause(inner) => {
<pauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
Self::pauseAll(inner) => {
<pauseAllCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::paused_0(inner) => {
<paused_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::paused_1(inner) => {
<paused_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::pauserRegistry(inner) => {
<pauserRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::podOwnerDepositShares(inner) => {
<podOwnerDepositSharesCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::recordBeaconChainETHBalanceUpdate(inner) => {
<recordBeaconChainETHBalanceUpdateCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::removeDepositShares(inner) => {
<removeDepositSharesCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::stake(inner) => {
<stakeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
Self::stakerDepositShares(inner) => {
<stakerDepositSharesCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::unpause(inner) => {
<unpauseCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
Self::version(inner) => {
<versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
Self::withdrawSharesAsTokens(inner) => {
<withdrawSharesAsTokensCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
}
}
}
#[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, Hash)]
pub enum IEigenPodManagerErrors {
#[allow(missing_docs)]
CurrentlyPaused(CurrentlyPaused),
#[allow(missing_docs)]
EigenPodAlreadyExists(EigenPodAlreadyExists),
#[allow(missing_docs)]
InputAddressZero(InputAddressZero),
#[allow(missing_docs)]
InvalidNewPausedStatus(InvalidNewPausedStatus),
#[allow(missing_docs)]
InvalidStrategy(InvalidStrategy),
#[allow(missing_docs)]
LegacyWithdrawalsNotCompleted(LegacyWithdrawalsNotCompleted),
#[allow(missing_docs)]
OnlyDelegationManager(OnlyDelegationManager),
#[allow(missing_docs)]
OnlyEigenPod(OnlyEigenPod),
#[allow(missing_docs)]
OnlyPauser(OnlyPauser),
#[allow(missing_docs)]
OnlyUnpauser(OnlyUnpauser),
#[allow(missing_docs)]
SharesNegative(SharesNegative),
#[allow(missing_docs)]
SharesNotMultipleOfGwei(SharesNotMultipleOfGwei),
}
#[automatically_derived]
impl IEigenPodManagerErrors {
pub const SELECTORS: &'static [[u8; 4usize]] = &[
[12u8, 106u8, 20u8, 132u8],
[37u8, 194u8, 218u8, 226u8],
[75u8, 105u8, 43u8, 207u8],
[78u8, 35u8, 110u8, 154u8],
[115u8, 99u8, 33u8, 118u8],
[117u8, 223u8, 81u8, 220u8],
[121u8, 72u8, 33u8, 255u8],
[132u8, 10u8, 72u8, 213u8],
[143u8, 160u8, 229u8, 118u8],
[198u8, 29u8, 202u8, 93u8],
[239u8, 20u8, 125u8, 225u8],
[247u8, 57u8, 88u8, 155u8],
];
}
#[automatically_derived]
impl alloy_sol_types::SolInterface for IEigenPodManagerErrors {
const NAME: &'static str = "IEigenPodManagerErrors";
const MIN_DATA_LENGTH: usize = 0usize;
const COUNT: usize = 12usize;
#[inline]
fn selector(&self) -> [u8; 4] {
match self {
Self::CurrentlyPaused(_) => {
<CurrentlyPaused as alloy_sol_types::SolError>::SELECTOR
}
Self::EigenPodAlreadyExists(_) => {
<EigenPodAlreadyExists as alloy_sol_types::SolError>::SELECTOR
}
Self::InputAddressZero(_) => {
<InputAddressZero as alloy_sol_types::SolError>::SELECTOR
}
Self::InvalidNewPausedStatus(_) => {
<InvalidNewPausedStatus as alloy_sol_types::SolError>::SELECTOR
}
Self::InvalidStrategy(_) => {
<InvalidStrategy as alloy_sol_types::SolError>::SELECTOR
}
Self::LegacyWithdrawalsNotCompleted(_) => {
<LegacyWithdrawalsNotCompleted as alloy_sol_types::SolError>::SELECTOR
}
Self::OnlyDelegationManager(_) => {
<OnlyDelegationManager as alloy_sol_types::SolError>::SELECTOR
}
Self::OnlyEigenPod(_) => <OnlyEigenPod as alloy_sol_types::SolError>::SELECTOR,
Self::OnlyPauser(_) => <OnlyPauser as alloy_sol_types::SolError>::SELECTOR,
Self::OnlyUnpauser(_) => <OnlyUnpauser as alloy_sol_types::SolError>::SELECTOR,
Self::SharesNegative(_) => <SharesNegative as alloy_sol_types::SolError>::SELECTOR,
Self::SharesNotMultipleOfGwei(_) => {
<SharesNotMultipleOfGwei as alloy_sol_types::SolError>::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<IEigenPodManagerErrors>] =
&[
{
fn EigenPodAlreadyExists(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors>
{
<EigenPodAlreadyExists as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IEigenPodManagerErrors::EigenPodAlreadyExists)
}
EigenPodAlreadyExists
},
{
fn OnlyEigenPod(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors>
{
<OnlyEigenPod as alloy_sol_types::SolError>::abi_decode_raw(data)
.map(IEigenPodManagerErrors::OnlyEigenPod)
}
OnlyEigenPod
},
{
fn LegacyWithdrawalsNotCompleted(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors>
{
<LegacyWithdrawalsNotCompleted as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IEigenPodManagerErrors::LegacyWithdrawalsNotCompleted)
}
LegacyWithdrawalsNotCompleted
},
{
fn InvalidStrategy(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors>
{
<InvalidStrategy as alloy_sol_types::SolError>::abi_decode_raw(data)
.map(IEigenPodManagerErrors::InvalidStrategy)
}
InvalidStrategy
},
{
fn InputAddressZero(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors>
{
<InputAddressZero as alloy_sol_types::SolError>::abi_decode_raw(data)
.map(IEigenPodManagerErrors::InputAddressZero)
}
InputAddressZero
},
{
fn OnlyPauser(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors>
{
<OnlyPauser as alloy_sol_types::SolError>::abi_decode_raw(data)
.map(IEigenPodManagerErrors::OnlyPauser)
}
OnlyPauser
},
{
fn OnlyUnpauser(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors>
{
<OnlyUnpauser as alloy_sol_types::SolError>::abi_decode_raw(data)
.map(IEigenPodManagerErrors::OnlyUnpauser)
}
OnlyUnpauser
},
{
fn CurrentlyPaused(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors>
{
<CurrentlyPaused as alloy_sol_types::SolError>::abi_decode_raw(data)
.map(IEigenPodManagerErrors::CurrentlyPaused)
}
CurrentlyPaused
},
{
fn SharesNotMultipleOfGwei(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors>
{
<SharesNotMultipleOfGwei as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IEigenPodManagerErrors::SharesNotMultipleOfGwei)
}
SharesNotMultipleOfGwei
},
{
fn InvalidNewPausedStatus(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors>
{
<InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IEigenPodManagerErrors::InvalidNewPausedStatus)
}
InvalidNewPausedStatus
},
{
fn SharesNegative(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors>
{
<SharesNegative as alloy_sol_types::SolError>::abi_decode_raw(data)
.map(IEigenPodManagerErrors::SharesNegative)
}
SharesNegative
},
{
fn OnlyDelegationManager(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors>
{
<OnlyDelegationManager as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IEigenPodManagerErrors::OnlyDelegationManager)
}
OnlyDelegationManager
},
];
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<
IEigenPodManagerErrors,
>] = &[
{
fn EigenPodAlreadyExists(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors> {
<EigenPodAlreadyExists as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerErrors::EigenPodAlreadyExists)
}
EigenPodAlreadyExists
},
{
fn OnlyEigenPod(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors> {
<OnlyEigenPod as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
.map(IEigenPodManagerErrors::OnlyEigenPod)
}
OnlyEigenPod
},
{
fn LegacyWithdrawalsNotCompleted(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors> {
<LegacyWithdrawalsNotCompleted as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerErrors::LegacyWithdrawalsNotCompleted)
}
LegacyWithdrawalsNotCompleted
},
{
fn InvalidStrategy(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors> {
<InvalidStrategy as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerErrors::InvalidStrategy)
}
InvalidStrategy
},
{
fn InputAddressZero(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors> {
<InputAddressZero as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerErrors::InputAddressZero)
}
InputAddressZero
},
{
fn OnlyPauser(data: &[u8]) -> alloy_sol_types::Result<IEigenPodManagerErrors> {
<OnlyPauser as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
.map(IEigenPodManagerErrors::OnlyPauser)
}
OnlyPauser
},
{
fn OnlyUnpauser(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors> {
<OnlyUnpauser as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
.map(IEigenPodManagerErrors::OnlyUnpauser)
}
OnlyUnpauser
},
{
fn CurrentlyPaused(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors> {
<CurrentlyPaused as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerErrors::CurrentlyPaused)
}
CurrentlyPaused
},
{
fn SharesNotMultipleOfGwei(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors> {
<SharesNotMultipleOfGwei as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerErrors::SharesNotMultipleOfGwei)
}
SharesNotMultipleOfGwei
},
{
fn InvalidNewPausedStatus(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors> {
<InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerErrors::InvalidNewPausedStatus)
}
InvalidNewPausedStatus
},
{
fn SharesNegative(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors> {
<SharesNegative as alloy_sol_types::SolError>::abi_decode_raw_validate(data)
.map(IEigenPodManagerErrors::SharesNegative)
}
SharesNegative
},
{
fn OnlyDelegationManager(
data: &[u8],
) -> alloy_sol_types::Result<IEigenPodManagerErrors> {
<OnlyDelegationManager as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IEigenPodManagerErrors::OnlyDelegationManager)
}
OnlyDelegationManager
},
];
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::CurrentlyPaused(inner) => {
<CurrentlyPaused as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::EigenPodAlreadyExists(inner) => {
<EigenPodAlreadyExists as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::InputAddressZero(inner) => {
<InputAddressZero as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::InvalidNewPausedStatus(inner) => {
<InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::InvalidStrategy(inner) => {
<InvalidStrategy as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::LegacyWithdrawalsNotCompleted(inner) => {
<LegacyWithdrawalsNotCompleted as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::OnlyDelegationManager(inner) => {
<OnlyDelegationManager as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::OnlyEigenPod(inner) => {
<OnlyEigenPod as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::OnlyPauser(inner) => {
<OnlyPauser as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::OnlyUnpauser(inner) => {
<OnlyUnpauser as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::SharesNegative(inner) => {
<SharesNegative as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::SharesNotMultipleOfGwei(inner) => {
<SharesNotMultipleOfGwei as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
}
}
#[inline]
fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
match self {
Self::CurrentlyPaused(inner) => {
<CurrentlyPaused as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
}
Self::EigenPodAlreadyExists(inner) => {
<EigenPodAlreadyExists as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
}
Self::InputAddressZero(inner) => {
<InputAddressZero as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
}
Self::InvalidNewPausedStatus(inner) => {
<InvalidNewPausedStatus as alloy_sol_types::SolError>::abi_encode_raw(
inner, out,
)
}
Self::InvalidStrategy(inner) => {
<InvalidStrategy as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
}
Self::LegacyWithdrawalsNotCompleted(inner) => {
<LegacyWithdrawalsNotCompleted as alloy_sol_types::SolError>::abi_encode_raw(
inner, out,
)
}
Self::OnlyDelegationManager(inner) => {
<OnlyDelegationManager as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
}
Self::OnlyEigenPod(inner) => {
<OnlyEigenPod as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
}
Self::OnlyPauser(inner) => {
<OnlyPauser as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
}
Self::OnlyUnpauser(inner) => {
<OnlyUnpauser as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
}
Self::SharesNegative(inner) => {
<SharesNegative as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
}
Self::SharesNotMultipleOfGwei(inner) => {
<SharesNotMultipleOfGwei as alloy_sol_types::SolError>::abi_encode_raw(
inner, out,
)
}
}
}
}
#[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, Hash)]
pub enum IEigenPodManagerEvents {
#[allow(missing_docs)]
BeaconChainETHDeposited(BeaconChainETHDeposited),
#[allow(missing_docs)]
BeaconChainETHWithdrawalCompleted(BeaconChainETHWithdrawalCompleted),
#[allow(missing_docs)]
BeaconChainSlashingFactorDecreased(BeaconChainSlashingFactorDecreased),
#[allow(missing_docs)]
BurnableETHSharesIncreased(BurnableETHSharesIncreased),
#[allow(missing_docs)]
NewTotalShares(NewTotalShares),
#[allow(missing_docs)]
Paused(Paused),
#[allow(missing_docs)]
PodDeployed(PodDeployed),
#[allow(missing_docs)]
PodSharesUpdated(PodSharesUpdated),
#[allow(missing_docs)]
Unpaused(Unpaused),
}
#[automatically_derived]
impl IEigenPodManagerEvents {
pub const SELECTORS: &'static [[u8; 32usize]] = &[
[
30u8, 208u8, 75u8, 127u8, 210u8, 98u8, 192u8, 217u8, 229u8, 15u8, 160u8, 41u8,
87u8, 243u8, 42u8, 129u8, 161u8, 81u8, 240u8, 59u8, 170u8, 163u8, 103u8, 250u8,
238u8, 220u8, 117u8, 33u8, 176u8, 1u8, 196u8, 164u8,
],
[
33u8, 201u8, 157u8, 13u8, 176u8, 34u8, 19u8, 195u8, 47u8, 255u8, 91u8, 5u8, 207u8,
10u8, 113u8, 138u8, 181u8, 248u8, 88u8, 128u8, 43u8, 145u8, 73u8, 143u8, 128u8,
216u8, 34u8, 112u8, 40u8, 157u8, 133u8, 106u8,
],
[
53u8, 130u8, 209u8, 130u8, 142u8, 38u8, 191u8, 86u8, 189u8, 128u8, 21u8, 2u8,
188u8, 2u8, 26u8, 192u8, 188u8, 138u8, 251u8, 87u8, 200u8, 38u8, 228u8, 152u8,
107u8, 69u8, 89u8, 60u8, 143u8, 173u8, 56u8, 156u8,
],
[
53u8, 168u8, 92u8, 171u8, 198u8, 3u8, 244u8, 138u8, 187u8, 43u8, 113u8, 217u8,
251u8, 216u8, 173u8, 234u8, 124u8, 68u8, 157u8, 127u8, 11u8, 233u8, 0u8, 174u8,
122u8, 41u8, 134u8, 234u8, 54u8, 156u8, 61u8, 13u8,
],
[
78u8, 43u8, 121u8, 29u8, 237u8, 204u8, 217u8, 251u8, 48u8, 20u8, 27u8, 8u8, 140u8,
171u8, 245u8, 193u8, 74u8, 137u8, 18u8, 181u8, 47u8, 89u8, 55u8, 92u8, 149u8,
192u8, 16u8, 112u8, 11u8, 140u8, 97u8, 147u8,
],
[
166u8, 186u8, 177u8, 213u8, 90u8, 54u8, 31u8, 206u8, 162u8, 238u8, 226u8, 188u8,
148u8, 145u8, 228u8, 240u8, 30u8, 108u8, 243u8, 51u8, 223u8, 3u8, 201u8, 196u8,
242u8, 193u8, 68u8, 70u8, 100u8, 41u8, 247u8, 214u8,
],
[
171u8, 64u8, 163u8, 116u8, 188u8, 81u8, 222u8, 55u8, 34u8, 0u8, 168u8, 188u8,
152u8, 26u8, 248u8, 201u8, 236u8, 220u8, 8u8, 223u8, 218u8, 239u8, 11u8, 182u8,
224u8, 159u8, 136u8, 243u8, 198u8, 22u8, 239u8, 61u8,
],
[
177u8, 96u8, 171u8, 133u8, 137u8, 191u8, 71u8, 220u8, 4u8, 234u8, 17u8, 181u8,
13u8, 70u8, 103u8, 141u8, 33u8, 89u8, 12u8, 234u8, 46u8, 211u8, 228u8, 84u8, 231u8,
189u8, 62u8, 65u8, 81u8, 15u8, 152u8, 207u8,
],
[
212u8, 222u8, 247u8, 109u8, 109u8, 43u8, 237u8, 111u8, 20u8, 213u8, 205u8, 154u8,
247u8, 60u8, 194u8, 145u8, 61u8, 97u8, 141u8, 0u8, 237u8, 222u8, 66u8, 67u8, 46u8,
129u8, 192u8, 155u8, 254u8, 7u8, 112u8, 152u8,
],
];
}
#[automatically_derived]
impl alloy_sol_types::SolEventInterface for IEigenPodManagerEvents {
const NAME: &'static str = "IEigenPodManagerEvents";
const COUNT: usize = 9usize;
fn decode_raw_log(
topics: &[alloy_sol_types::Word],
data: &[u8],
) -> alloy_sol_types::Result<Self> {
match topics.first().copied() {
Some(
<BeaconChainETHDeposited as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<BeaconChainETHDeposited as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::BeaconChainETHDeposited)
}
Some(
<BeaconChainETHWithdrawalCompleted as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<BeaconChainETHWithdrawalCompleted as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::BeaconChainETHWithdrawalCompleted)
}
Some(
<BeaconChainSlashingFactorDecreased as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<BeaconChainSlashingFactorDecreased as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::BeaconChainSlashingFactorDecreased)
}
Some(
<BurnableETHSharesIncreased as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<BurnableETHSharesIncreased as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::BurnableETHSharesIncreased)
}
Some(<NewTotalShares as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<NewTotalShares as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::NewTotalShares)
}
Some(<Paused as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<Paused as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
.map(Self::Paused)
}
Some(<PodDeployed as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<PodDeployed as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::PodDeployed)
}
Some(<PodSharesUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<PodSharesUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::PodSharesUpdated)
}
Some(<Unpaused as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<Unpaused as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
.map(Self::Unpaused)
}
_ => {
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 IEigenPodManagerEvents {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
match self {
Self::BeaconChainETHDeposited(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::BeaconChainETHWithdrawalCompleted(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::BeaconChainSlashingFactorDecreased(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::BurnableETHSharesIncreased(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::NewTotalShares(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::Paused(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
Self::PodDeployed(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::PodSharesUpdated(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::Unpaused(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
}
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
match self {
Self::BeaconChainETHDeposited(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::BeaconChainETHWithdrawalCompleted(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::BeaconChainSlashingFactorDecreased(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::BurnableETHSharesIncreased(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::NewTotalShares(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::Paused(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner),
Self::PodDeployed(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::PodSharesUpdated(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::Unpaused(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,
) -> IEigenPodManagerInstance<P, N> {
IEigenPodManagerInstance::<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<IEigenPodManagerInstance<P, N>>>
{
IEigenPodManagerInstance::<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> {
IEigenPodManagerInstance::<P, N>::deploy_builder(provider)
}
#[derive(Clone)]
pub struct IEigenPodManagerInstance<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 IEigenPodManagerInstance<P, N> {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
f.debug_tuple("IEigenPodManagerInstance")
.field(&self.address)
.finish()
}
}
#[automatically_derived]
impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
IEigenPodManagerInstance<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<IEigenPodManagerInstance<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> IEigenPodManagerInstance<&P, N> {
#[inline]
pub fn with_cloned_provider(self) -> IEigenPodManagerInstance<P, N> {
IEigenPodManagerInstance {
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>
IEigenPodManagerInstance<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 addShares(
&self,
staker: alloy::sol_types::private::Address,
strategy: alloy::sol_types::private::Address,
shares: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, addSharesCall, N> {
self.call_builder(&addSharesCall {
staker,
strategy,
shares,
})
}
pub fn beaconChainETHStrategy(
&self,
) -> alloy_contract::SolCallBuilder<&P, beaconChainETHStrategyCall, N> {
self.call_builder(&beaconChainETHStrategyCall)
}
pub fn beaconChainSlashingFactor(
&self,
staker: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, beaconChainSlashingFactorCall, N> {
self.call_builder(&beaconChainSlashingFactorCall { staker })
}
pub fn burnableETHShares(
&self,
) -> alloy_contract::SolCallBuilder<&P, burnableETHSharesCall, N> {
self.call_builder(&burnableETHSharesCall)
}
pub fn createPod(&self) -> alloy_contract::SolCallBuilder<&P, createPodCall, N> {
self.call_builder(&createPodCall)
}
pub fn eigenPodBeacon(&self) -> alloy_contract::SolCallBuilder<&P, eigenPodBeaconCall, N> {
self.call_builder(&eigenPodBeaconCall)
}
pub fn ethPOS(&self) -> alloy_contract::SolCallBuilder<&P, ethPOSCall, N> {
self.call_builder(ðPOSCall)
}
pub fn getPod(
&self,
podOwner: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, getPodCall, N> {
self.call_builder(&getPodCall { podOwner })
}
pub fn hasPod(
&self,
podOwner: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, hasPodCall, N> {
self.call_builder(&hasPodCall { podOwner })
}
pub fn increaseBurnableShares(
&self,
strategy: alloy::sol_types::private::Address,
addedSharesToBurn: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, increaseBurnableSharesCall, N> {
self.call_builder(&increaseBurnableSharesCall {
strategy,
addedSharesToBurn,
})
}
pub fn numPods(&self) -> alloy_contract::SolCallBuilder<&P, numPodsCall, N> {
self.call_builder(&numPodsCall)
}
pub fn ownerToPod(
&self,
podOwner: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, ownerToPodCall, N> {
self.call_builder(&ownerToPodCall { podOwner })
}
pub fn pause(
&self,
newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, pauseCall, N> {
self.call_builder(&pauseCall { newPausedStatus })
}
pub fn pauseAll(&self) -> alloy_contract::SolCallBuilder<&P, pauseAllCall, N> {
self.call_builder(&pauseAllCall)
}
pub fn paused_0(&self, index: u8) -> alloy_contract::SolCallBuilder<&P, paused_0Call, N> {
self.call_builder(&paused_0Call { index })
}
pub fn paused_1(&self) -> alloy_contract::SolCallBuilder<&P, paused_1Call, N> {
self.call_builder(&paused_1Call)
}
pub fn pauserRegistry(&self) -> alloy_contract::SolCallBuilder<&P, pauserRegistryCall, N> {
self.call_builder(&pauserRegistryCall)
}
pub fn podOwnerDepositShares(
&self,
podOwner: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, podOwnerDepositSharesCall, N> {
self.call_builder(&podOwnerDepositSharesCall { podOwner })
}
pub fn recordBeaconChainETHBalanceUpdate(
&self,
podOwner: alloy::sol_types::private::Address,
prevRestakedBalanceWei: alloy::sol_types::private::primitives::aliases::U256,
balanceDeltaWei: alloy::sol_types::private::primitives::aliases::I256,
) -> alloy_contract::SolCallBuilder<&P, recordBeaconChainETHBalanceUpdateCall, N> {
self.call_builder(&recordBeaconChainETHBalanceUpdateCall {
podOwner,
prevRestakedBalanceWei,
balanceDeltaWei,
})
}
pub fn removeDepositShares(
&self,
staker: alloy::sol_types::private::Address,
strategy: alloy::sol_types::private::Address,
depositSharesToRemove: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, removeDepositSharesCall, N> {
self.call_builder(&removeDepositSharesCall {
staker,
strategy,
depositSharesToRemove,
})
}
pub fn stake(
&self,
pubkey: alloy::sol_types::private::Bytes,
signature: alloy::sol_types::private::Bytes,
depositDataRoot: alloy::sol_types::private::FixedBytes<32>,
) -> alloy_contract::SolCallBuilder<&P, stakeCall, N> {
self.call_builder(&stakeCall {
pubkey,
signature,
depositDataRoot,
})
}
pub fn stakerDepositShares(
&self,
user: alloy::sol_types::private::Address,
strategy: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, stakerDepositSharesCall, N> {
self.call_builder(&stakerDepositSharesCall { user, strategy })
}
pub fn unpause(
&self,
newPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, unpauseCall, N> {
self.call_builder(&unpauseCall { newPausedStatus })
}
pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
self.call_builder(&versionCall)
}
pub fn withdrawSharesAsTokens(
&self,
staker: alloy::sol_types::private::Address,
strategy: alloy::sol_types::private::Address,
token: alloy::sol_types::private::Address,
shares: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, withdrawSharesAsTokensCall, N> {
self.call_builder(&withdrawSharesAsTokensCall {
staker,
strategy,
token,
shares,
})
}
}
#[automatically_derived]
impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
IEigenPodManagerInstance<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 BeaconChainETHDeposited_filter(
&self,
) -> alloy_contract::Event<&P, BeaconChainETHDeposited, N> {
self.event_filter::<BeaconChainETHDeposited>()
}
pub fn BeaconChainETHWithdrawalCompleted_filter(
&self,
) -> alloy_contract::Event<&P, BeaconChainETHWithdrawalCompleted, N> {
self.event_filter::<BeaconChainETHWithdrawalCompleted>()
}
pub fn BeaconChainSlashingFactorDecreased_filter(
&self,
) -> alloy_contract::Event<&P, BeaconChainSlashingFactorDecreased, N> {
self.event_filter::<BeaconChainSlashingFactorDecreased>()
}
pub fn BurnableETHSharesIncreased_filter(
&self,
) -> alloy_contract::Event<&P, BurnableETHSharesIncreased, N> {
self.event_filter::<BurnableETHSharesIncreased>()
}
pub fn NewTotalShares_filter(&self) -> alloy_contract::Event<&P, NewTotalShares, N> {
self.event_filter::<NewTotalShares>()
}
pub fn Paused_filter(&self) -> alloy_contract::Event<&P, Paused, N> {
self.event_filter::<Paused>()
}
pub fn PodDeployed_filter(&self) -> alloy_contract::Event<&P, PodDeployed, N> {
self.event_filter::<PodDeployed>()
}
pub fn PodSharesUpdated_filter(&self) -> alloy_contract::Event<&P, PodSharesUpdated, N> {
self.event_filter::<PodSharesUpdated>()
}
pub fn Unpaused_filter(&self) -> alloy_contract::Event<&P, Unpaused, N> {
self.event_filter::<Unpaused>()
}
}
}