#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style,
clippy::empty_structs_with_brackets
)]
pub mod OperatorRegistryEpochGovernance {
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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct AdminAddressZero;
#[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)]
#[allow(dead_code)]
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<AdminAddressZero> for UnderlyingRustTuple<'_> {
fn from(value: AdminAddressZero) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for AdminAddressZero {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for AdminAddressZero {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "AdminAddressZero()";
const SELECTOR: [u8; 4] = [57u8, 191u8, 221u8, 181u8];
#[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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct AlreadyQueuedForDeregister {
#[allow(missing_docs)]
pub operator: 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)]
#[allow(dead_code)]
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<AlreadyQueuedForDeregister>
for UnderlyingRustTuple<'_> {
fn from(value: AlreadyQueuedForDeregister) -> Self {
(value.operator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for AlreadyQueuedForDeregister {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operator: tuple.0 }
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for AlreadyQueuedForDeregister {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "AlreadyQueuedForDeregister(address)";
const SELECTOR: [u8; 4] = [14u8, 126u8, 27u8, 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.operator,
),
)
}
#[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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct BootstrapPhaseEnded;
#[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)]
#[allow(dead_code)]
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<BootstrapPhaseEnded> for UnderlyingRustTuple<'_> {
fn from(value: BootstrapPhaseEnded) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for BootstrapPhaseEnded {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for BootstrapPhaseEnded {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "BootstrapPhaseEnded()";
const SELECTOR: [u8; 4] = [26u8, 185u8, 250u8, 134u8];
#[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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct DeregisterEpochNotReached {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub currentEpoch: u32,
#[allow(missing_docs)]
pub approvedEpoch: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<32>,
alloy::sol_types::sol_data::Uint<32>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, u32, u32);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<DeregisterEpochNotReached>
for UnderlyingRustTuple<'_> {
fn from(value: DeregisterEpochNotReached) -> Self {
(value.operator, value.currentEpoch, value.approvedEpoch)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for DeregisterEpochNotReached {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
operator: tuple.0,
currentEpoch: tuple.1,
approvedEpoch: tuple.2,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for DeregisterEpochNotReached {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "DeregisterEpochNotReached(address,uint32,uint32)";
const SELECTOR: [u8; 4] = [128u8, 185u8, 13u8, 205u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::SolType>::tokenize(&self.currentEpoch),
<alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::SolType>::tokenize(&self.approvedEpoch),
)
}
#[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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct DeregisterNotApproved {
#[allow(missing_docs)]
pub operator: 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)]
#[allow(dead_code)]
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<DeregisterNotApproved> for UnderlyingRustTuple<'_> {
fn from(value: DeregisterNotApproved) -> Self {
(value.operator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for DeregisterNotApproved {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operator: tuple.0 }
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for DeregisterNotApproved {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "DeregisterNotApproved(address)";
const SELECTOR: [u8; 4] = [149u8, 132u8, 17u8, 70u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn 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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct EpochNotReady {
#[allow(missing_docs)]
pub startBlock: u64,
#[allow(missing_docs)]
pub durationBlocks: u32,
#[allow(missing_docs)]
pub currentBlock: 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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Uint<32>,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
u64,
u32,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<EpochNotReady> for UnderlyingRustTuple<'_> {
fn from(value: EpochNotReady) -> Self {
(value.startBlock, value.durationBlocks, value.currentBlock)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for EpochNotReady {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
startBlock: tuple.0,
durationBlocks: tuple.1,
currentBlock: tuple.2,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for EpochNotReady {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "EpochNotReady(uint64,uint32,uint256)";
const SELECTOR: [u8; 4] = [153u8, 14u8, 149u8, 230u8];
#[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<
64,
> as alloy_sol_types::SolType>::tokenize(&self.startBlock),
<alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::SolType>::tokenize(&self.durationBlocks),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self.currentBlock),
)
}
#[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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct InvalidAddress;
#[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)]
#[allow(dead_code)]
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<InvalidAddress> for UnderlyingRustTuple<'_> {
fn from(value: InvalidAddress) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAddress {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InvalidAddress {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InvalidAddress()";
const SELECTOR: [u8; 4] = [230u8, 196u8, 36u8, 123u8];
#[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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct InvalidEpochDuration;
#[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)]
#[allow(dead_code)]
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<InvalidEpochDuration> for UnderlyingRustTuple<'_> {
fn from(value: InvalidEpochDuration) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidEpochDuration {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InvalidEpochDuration {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InvalidEpochDuration()";
const SELECTOR: [u8; 4] = [209u8, 235u8, 241u8, 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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct NoPendingChanges;
#[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)]
#[allow(dead_code)]
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<NoPendingChanges> for UnderlyingRustTuple<'_> {
fn from(value: NoPendingChanges) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for NoPendingChanges {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for NoPendingChanges {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "NoPendingChanges()";
const SELECTOR: [u8; 4] = [128u8, 47u8, 54u8, 84u8];
#[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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct NotAdminOrOwner;
#[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)]
#[allow(dead_code)]
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<NotAdminOrOwner> for UnderlyingRustTuple<'_> {
fn from(value: NotAdminOrOwner) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotAdminOrOwner {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for NotAdminOrOwner {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "NotAdminOrOwner()";
const SELECTOR: [u8; 4] = [123u8, 182u8, 42u8, 33u8];
#[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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct NotRegistered {
#[allow(missing_docs)]
pub operator: 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)]
#[allow(dead_code)]
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<NotRegistered> for UnderlyingRustTuple<'_> {
fn from(value: NotRegistered) -> Self {
(value.operator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotRegistered {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operator: tuple.0 }
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for NotRegistered {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "NotRegistered(address)";
const SELECTOR: [u8; 4] = [191u8, 198u8, 195u8, 55u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn 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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct OnlyOperatorRegistry;
#[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)]
#[allow(dead_code)]
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<OnlyOperatorRegistry> for UnderlyingRustTuple<'_> {
fn from(value: OnlyOperatorRegistry) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyOperatorRegistry {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for OnlyOperatorRegistry {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "OnlyOperatorRegistry()";
const SELECTOR: [u8; 4] = [164u8, 95u8, 145u8, 106u8];
#[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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct OperatorRegistryUnset;
#[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)]
#[allow(dead_code)]
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<OperatorRegistryUnset> for UnderlyingRustTuple<'_> {
fn from(value: OperatorRegistryUnset) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorRegistryUnset {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for OperatorRegistryUnset {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "OperatorRegistryUnset()";
const SELECTOR: [u8; 4] = [168u8, 62u8, 129u8, 186u8];
#[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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct EpochAdvanced {
#[allow(missing_docs)]
pub epoch: u32,
#[allow(missing_docs)]
pub startBlock: u64,
#[allow(missing_docs)]
pub durationBlocks: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for EpochAdvanced {
type DataTuple<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Uint<32>,
);
type DataToken<'a> = <Self::DataTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (
alloy_sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Uint<32>,
);
const SIGNATURE: &'static str = "EpochAdvanced(uint32,uint64,uint32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
216u8, 80u8, 93u8, 106u8, 213u8, 115u8, 64u8, 90u8, 158u8, 96u8, 185u8,
62u8, 44u8, 50u8, 128u8, 161u8, 232u8, 225u8, 254u8, 160u8, 123u8, 68u8,
5u8, 130u8, 230u8, 69u8, 121u8, 116u8, 159u8, 177u8, 10u8, 24u8,
]);
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 {
epoch: topics.1,
startBlock: data.0,
durationBlocks: data.1,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(
alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
),
);
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
(
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.startBlock),
<alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::SolType>::tokenize(&self.durationBlocks),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(Self::SIGNATURE_HASH.into(), self.epoch.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::Uint<
32,
> as alloy_sol_types::EventTopic>::encode_topic(&self.epoch);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for EpochAdvanced {
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<&EpochAdvanced> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &EpochAdvanced) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct EpochDurationBlocksQueued {
#[allow(missing_docs)]
pub newDuration: u32,
#[allow(missing_docs)]
pub effectiveEpoch: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for EpochDurationBlocksQueued {
type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type DataToken<'a> = <Self::DataTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (
alloy_sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Uint<32>,
);
const SIGNATURE: &'static str = "EpochDurationBlocksQueued(uint32,uint32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
209u8, 59u8, 207u8, 109u8, 83u8, 166u8, 248u8, 188u8, 162u8, 108u8,
181u8, 63u8, 216u8, 32u8, 145u8, 123u8, 186u8, 102u8, 244u8, 111u8, 72u8,
71u8, 145u8, 127u8, 80u8, 26u8, 41u8, 215u8, 221u8, 107u8, 174u8, 96u8,
]);
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 {
newDuration: data.0,
effectiveEpoch: topics.1,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(
alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
),
);
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
(
<alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::SolType>::tokenize(&self.newDuration),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(Self::SIGNATURE_HASH.into(), self.effectiveEpoch.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::Uint<
32,
> as alloy_sol_types::EventTopic>::encode_topic(&self.effectiveEpoch);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for EpochDurationBlocksQueued {
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<&EpochDurationBlocksQueued> for alloy_sol_types::private::LogData {
#[inline]
fn from(
this: &EpochDurationBlocksQueued,
) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct Initialized {
#[allow(missing_docs)]
pub version: u8,
}
#[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 Initialized {
type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
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 = "Initialized(uint8)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 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 { version: 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<
8,
> as alloy_sol_types::SolType>::tokenize(&self.version),
)
}
#[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 Initialized {
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<&Initialized> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct OperatorDeregistrationQueued {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub effectiveEpoch: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for OperatorDeregistrationQueued {
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::Uint<32>,
);
const SIGNATURE: &'static str = "OperatorDeregistrationQueued(address,uint32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
203u8, 46u8, 89u8, 166u8, 67u8, 138u8, 176u8, 226u8, 49u8, 91u8, 138u8,
228u8, 253u8, 40u8, 32u8, 138u8, 114u8, 30u8, 143u8, 191u8, 205u8, 207u8,
66u8, 37u8, 153u8, 65u8, 201u8, 117u8, 77u8, 64u8, 142u8, 238u8,
]);
const ANONYMOUS: bool = false;
#[allow(unused_variables)]
#[inline]
fn new(
topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
) -> Self {
Self {
operator: topics.1,
effectiveEpoch: topics.2,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(
alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
),
);
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
()
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(
Self::SIGNATURE_HASH.into(),
self.operator.clone(),
self.effectiveEpoch.clone(),
)
}
#[inline]
fn encode_topics_raw(
&self,
out: &mut [alloy_sol_types::abi::token::WordToken],
) -> alloy_sol_types::Result<()> {
if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
return Err(alloy_sol_types::Error::Overrun);
}
out[0usize] = alloy_sol_types::abi::token::WordToken(
Self::SIGNATURE_HASH,
);
out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.operator,
);
out[2usize] = <alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::EventTopic>::encode_topic(&self.effectiveEpoch);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for OperatorDeregistrationQueued {
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<&OperatorDeregistrationQueued> for alloy_sol_types::private::LogData {
#[inline]
fn from(
this: &OperatorDeregistrationQueued,
) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct OwnershipTransferred {
#[allow(missing_docs)]
pub previousOwner: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub newOwner: 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 OwnershipTransferred {
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 = "OwnershipTransferred(address,address)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
]);
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 {
previousOwner: topics.1,
newOwner: 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.previousOwner.clone(),
self.newOwner.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.previousOwner,
);
out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.newOwner,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
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<&OwnershipTransferred> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct TaskGeneratorAdditionQueued {
#[allow(missing_docs)]
pub generator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub effectiveEpoch: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for TaskGeneratorAdditionQueued {
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::Uint<32>,
);
const SIGNATURE: &'static str = "TaskGeneratorAdditionQueued(address,uint32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
228u8, 142u8, 15u8, 16u8, 233u8, 34u8, 164u8, 125u8, 245u8, 189u8, 74u8,
210u8, 152u8, 91u8, 155u8, 149u8, 30u8, 242u8, 249u8, 52u8, 23u8, 15u8,
113u8, 84u8, 115u8, 66u8, 151u8, 152u8, 174u8, 146u8, 44u8, 77u8,
]);
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 {
generator: topics.1,
effectiveEpoch: 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.generator.clone(),
self.effectiveEpoch.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.generator,
);
out[2usize] = <alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::EventTopic>::encode_topic(&self.effectiveEpoch);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for TaskGeneratorAdditionQueued {
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<&TaskGeneratorAdditionQueued> for alloy_sol_types::private::LogData {
#[inline]
fn from(
this: &TaskGeneratorAdditionQueued,
) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct TaskGeneratorRemovalQueued {
#[allow(missing_docs)]
pub generator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub effectiveEpoch: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for TaskGeneratorRemovalQueued {
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::Uint<32>,
);
const SIGNATURE: &'static str = "TaskGeneratorRemovalQueued(address,uint32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
37u8, 93u8, 18u8, 157u8, 99u8, 160u8, 246u8, 112u8, 192u8, 103u8, 98u8,
91u8, 48u8, 84u8, 110u8, 177u8, 124u8, 186u8, 67u8, 74u8, 14u8, 76u8,
214u8, 181u8, 198u8, 9u8, 174u8, 37u8, 238u8, 70u8, 26u8, 140u8,
]);
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 {
generator: topics.1,
effectiveEpoch: 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.generator.clone(),
self.effectiveEpoch.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.generator,
);
out[2usize] = <alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::EventTopic>::encode_topic(&self.effectiveEpoch);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for TaskGeneratorRemovalQueued {
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<&TaskGeneratorRemovalQueued> for alloy_sol_types::private::LogData {
#[inline]
fn from(
this: &TaskGeneratorRemovalQueued,
) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct WhitelistAdditionQueued {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub effectiveEpoch: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for WhitelistAdditionQueued {
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::Uint<32>,
);
const SIGNATURE: &'static str = "WhitelistAdditionQueued(address,uint32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
35u8, 242u8, 61u8, 232u8, 28u8, 148u8, 4u8, 200u8, 39u8, 50u8, 248u8,
67u8, 61u8, 194u8, 77u8, 59u8, 42u8, 72u8, 148u8, 136u8, 71u8, 10u8,
125u8, 119u8, 141u8, 90u8, 48u8, 91u8, 19u8, 217u8, 235u8, 167u8,
]);
const ANONYMOUS: bool = false;
#[allow(unused_variables)]
#[inline]
fn new(
topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
) -> Self {
Self {
operator: topics.1,
effectiveEpoch: topics.2,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(
alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
),
);
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
()
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(
Self::SIGNATURE_HASH.into(),
self.operator.clone(),
self.effectiveEpoch.clone(),
)
}
#[inline]
fn encode_topics_raw(
&self,
out: &mut [alloy_sol_types::abi::token::WordToken],
) -> alloy_sol_types::Result<()> {
if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
return Err(alloy_sol_types::Error::Overrun);
}
out[0usize] = alloy_sol_types::abi::token::WordToken(
Self::SIGNATURE_HASH,
);
out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.operator,
);
out[2usize] = <alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::EventTopic>::encode_topic(&self.effectiveEpoch);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for WhitelistAdditionQueued {
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<&WhitelistAdditionQueued> for alloy_sol_types::private::LogData {
#[inline]
fn from(
this: &WhitelistAdditionQueued,
) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct WhitelistRemovalQueued {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub effectiveEpoch: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for WhitelistRemovalQueued {
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::Uint<32>,
);
const SIGNATURE: &'static str = "WhitelistRemovalQueued(address,uint32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
154u8, 192u8, 205u8, 78u8, 66u8, 221u8, 11u8, 150u8, 167u8, 93u8, 140u8,
118u8, 60u8, 229u8, 198u8, 237u8, 13u8, 228u8, 143u8, 110u8, 243u8, 28u8,
70u8, 161u8, 182u8, 70u8, 160u8, 174u8, 249u8, 140u8, 84u8, 28u8,
]);
const ANONYMOUS: bool = false;
#[allow(unused_variables)]
#[inline]
fn new(
topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
) -> Self {
Self {
operator: topics.1,
effectiveEpoch: topics.2,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(
alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
),
);
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
()
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(
Self::SIGNATURE_HASH.into(),
self.operator.clone(),
self.effectiveEpoch.clone(),
)
}
#[inline]
fn encode_topics_raw(
&self,
out: &mut [alloy_sol_types::abi::token::WordToken],
) -> alloy_sol_types::Result<()> {
if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
return Err(alloy_sol_types::Error::Overrun);
}
out[0usize] = alloy_sol_types::abi::token::WordToken(
Self::SIGNATURE_HASH,
);
out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.operator,
);
out[2usize] = <alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::EventTopic>::encode_topic(&self.effectiveEpoch);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for WhitelistRemovalQueued {
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<&WhitelistRemovalQueued> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &WhitelistRemovalQueued) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct constructorCall {}
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
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<constructorCall> for UnderlyingRustTuple<'_> {
fn from(value: constructorCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolConstructor for constructorCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct ADMIN_ROLECall;
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct ADMIN_ROLEReturn {
#[allow(missing_docs)]
pub _0: 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;
{
#[doc(hidden)]
#[allow(dead_code)]
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<ADMIN_ROLECall> for UnderlyingRustTuple<'_> {
fn from(value: ADMIN_ROLECall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ADMIN_ROLECall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (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<ADMIN_ROLEReturn> for UnderlyingRustTuple<'_> {
fn from(value: ADMIN_ROLEReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ADMIN_ROLEReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for ADMIN_ROLECall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "ADMIN_ROLE()";
const SELECTOR: [u8; 4] = [117u8, 178u8, 56u8, 252u8];
#[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::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: ADMIN_ROLEReturn = 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: ADMIN_ROLEReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addMultipleToTaskGeneratorsCall {
#[allow(missing_docs)]
pub generators: alloy::sol_types::private::Vec<
alloy::sol_types::private::Address,
>,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addMultipleToTaskGeneratorsReturn {}
#[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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<addMultipleToTaskGeneratorsCall>
for UnderlyingRustTuple<'_> {
fn from(value: addMultipleToTaskGeneratorsCall) -> Self {
(value.generators,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for addMultipleToTaskGeneratorsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { generators: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<addMultipleToTaskGeneratorsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: addMultipleToTaskGeneratorsReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for addMultipleToTaskGeneratorsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl addMultipleToTaskGeneratorsReturn {
fn _tokenize(
&self,
) -> <addMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for addMultipleToTaskGeneratorsCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = addMultipleToTaskGeneratorsReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "addMultipleToTaskGenerators(address[])";
const SELECTOR: [u8; 4] = [175u8, 131u8, 68u8, 7u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::Address,
> as alloy_sol_types::SolType>::tokenize(&self.generators),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
addMultipleToTaskGeneratorsReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addMultipleToWhitelistCall {
#[allow(missing_docs)]
pub operators: alloy::sol_types::private::Vec<
alloy::sol_types::private::Address,
>,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addMultipleToWhitelistReturn {}
#[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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<addMultipleToWhitelistCall>
for UnderlyingRustTuple<'_> {
fn from(value: addMultipleToWhitelistCall) -> Self {
(value.operators,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for addMultipleToWhitelistCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operators: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<addMultipleToWhitelistReturn>
for UnderlyingRustTuple<'_> {
fn from(value: addMultipleToWhitelistReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for addMultipleToWhitelistReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl addMultipleToWhitelistReturn {
fn _tokenize(
&self,
) -> <addMultipleToWhitelistCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for addMultipleToWhitelistCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = addMultipleToWhitelistReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "addMultipleToWhitelist(address[])";
const SELECTOR: [u8; 4] = [132u8, 1u8, 248u8, 209u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::Address,
> as alloy_sol_types::SolType>::tokenize(&self.operators),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
addMultipleToWhitelistReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addTaskGeneratorCall {
#[allow(missing_docs)]
pub generator: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addTaskGeneratorReturn {}
#[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)]
#[allow(dead_code)]
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<addTaskGeneratorCall>
for UnderlyingRustTuple<'_> {
fn from(value: addTaskGeneratorCall) -> Self {
(value.generator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for addTaskGeneratorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { generator: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<addTaskGeneratorReturn>
for UnderlyingRustTuple<'_> {
fn from(value: addTaskGeneratorReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for addTaskGeneratorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl addTaskGeneratorReturn {
fn _tokenize(
&self,
) -> <addTaskGeneratorCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for addTaskGeneratorCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = addTaskGeneratorReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "addTaskGenerator(address)";
const SELECTOR: [u8; 4] = [105u8, 183u8, 226u8, 62u8];
#[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.generator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
addTaskGeneratorReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addToWhitelistCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addToWhitelistReturn {}
#[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)]
#[allow(dead_code)]
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<addToWhitelistCall> for UnderlyingRustTuple<'_> {
fn from(value: addToWhitelistCall) -> Self {
(value.operator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for addToWhitelistCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operator: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<addToWhitelistReturn>
for UnderlyingRustTuple<'_> {
fn from(value: addToWhitelistReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for addToWhitelistReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl addToWhitelistReturn {
fn _tokenize(
&self,
) -> <addToWhitelistCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for addToWhitelistCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = addToWhitelistReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "addToWhitelist(address)";
const SELECTOR: [u8; 4] = [228u8, 50u8, 82u8, 215u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
addToWhitelistReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct applyPendingChangesCall;
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct applyPendingChangesReturn {}
#[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)]
#[allow(dead_code)]
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<applyPendingChangesCall>
for UnderlyingRustTuple<'_> {
fn from(value: applyPendingChangesCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for applyPendingChangesCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<applyPendingChangesReturn>
for UnderlyingRustTuple<'_> {
fn from(value: applyPendingChangesReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for applyPendingChangesReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl applyPendingChangesReturn {
fn _tokenize(
&self,
) -> <applyPendingChangesCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for applyPendingChangesCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = applyPendingChangesReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "applyPendingChanges()";
const SELECTOR: [u8; 4] = [68u8, 215u8, 68u8, 89u8];
#[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<'_> {
applyPendingChangesReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct approvedDeregisterEpochCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct approvedDeregisterEpochReturn {
#[allow(missing_docs)]
pub _0: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
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<approvedDeregisterEpochCall>
for UnderlyingRustTuple<'_> {
fn from(value: approvedDeregisterEpochCall) -> Self {
(value.operator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for approvedDeregisterEpochCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operator: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<approvedDeregisterEpochReturn>
for UnderlyingRustTuple<'_> {
fn from(value: approvedDeregisterEpochReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for approvedDeregisterEpochReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for approvedDeregisterEpochCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = u32;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "approvedDeregisterEpoch(address)";
const SELECTOR: [u8; 4] = [166u8, 210u8, 87u8, 79u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: approvedDeregisterEpochReturn = 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: approvedDeregisterEpochReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct cancelDeregisterApprovalCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct cancelDeregisterApprovalReturn {}
#[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)]
#[allow(dead_code)]
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<cancelDeregisterApprovalCall>
for UnderlyingRustTuple<'_> {
fn from(value: cancelDeregisterApprovalCall) -> Self {
(value.operator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for cancelDeregisterApprovalCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operator: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<cancelDeregisterApprovalReturn>
for UnderlyingRustTuple<'_> {
fn from(value: cancelDeregisterApprovalReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for cancelDeregisterApprovalReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl cancelDeregisterApprovalReturn {
fn _tokenize(
&self,
) -> <cancelDeregisterApprovalCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for cancelDeregisterApprovalCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = cancelDeregisterApprovalReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "cancelDeregisterApproval(address)";
const SELECTOR: [u8; 4] = [146u8, 200u8, 198u8, 50u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
cancelDeregisterApprovalReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct consumeDeregisterApprovalCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct consumeDeregisterApprovalReturn {}
#[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)]
#[allow(dead_code)]
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<consumeDeregisterApprovalCall>
for UnderlyingRustTuple<'_> {
fn from(value: consumeDeregisterApprovalCall) -> Self {
(value.operator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for consumeDeregisterApprovalCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operator: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<consumeDeregisterApprovalReturn>
for UnderlyingRustTuple<'_> {
fn from(value: consumeDeregisterApprovalReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for consumeDeregisterApprovalReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl consumeDeregisterApprovalReturn {
fn _tokenize(
&self,
) -> <consumeDeregisterApprovalCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for consumeDeregisterApprovalCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = consumeDeregisterApprovalReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "consumeDeregisterApproval(address)";
const SELECTOR: [u8; 4] = [78u8, 61u8, 149u8, 177u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
consumeDeregisterApprovalReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct currentEpochCall;
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct currentEpochReturn {
#[allow(missing_docs)]
pub _0: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
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<currentEpochCall> for UnderlyingRustTuple<'_> {
fn from(value: currentEpochCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for currentEpochCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<currentEpochReturn> for UnderlyingRustTuple<'_> {
fn from(value: currentEpochReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for currentEpochReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for currentEpochCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = u32;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "currentEpoch()";
const SELECTOR: [u8; 4] = [118u8, 103u8, 24u8, 8u8];
#[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<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: currentEpochReturn = 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: currentEpochReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct epochDurationBlocksCall;
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct epochDurationBlocksReturn {
#[allow(missing_docs)]
pub _0: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
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<epochDurationBlocksCall>
for UnderlyingRustTuple<'_> {
fn from(value: epochDurationBlocksCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for epochDurationBlocksCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<epochDurationBlocksReturn>
for UnderlyingRustTuple<'_> {
fn from(value: epochDurationBlocksReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for epochDurationBlocksReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for epochDurationBlocksCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = u32;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "epochDurationBlocks()";
const SELECTOR: [u8; 4] = [113u8, 113u8, 44u8, 41u8];
#[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<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: epochDurationBlocksReturn = 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: epochDurationBlocksReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct epochStartBlockCall;
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct epochStartBlockReturn {
#[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)]
#[allow(dead_code)]
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<epochStartBlockCall> for UnderlyingRustTuple<'_> {
fn from(value: epochStartBlockCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for epochStartBlockCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<epochStartBlockReturn>
for UnderlyingRustTuple<'_> {
fn from(value: epochStartBlockReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for epochStartBlockReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for epochStartBlockCall {
type Parameters<'a> = ();
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 = "epochStartBlock()";
const SELECTOR: [u8; 4] = [62u8, 213u8, 91u8, 123u8];
#[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<
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: epochStartBlockReturn = 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: epochStartBlockReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct grantRoleCall {
#[allow(missing_docs)]
pub role: alloy::sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub account: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct grantRoleReturn {}
#[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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::FixedBytes<32>,
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<grantRoleCall> for UnderlyingRustTuple<'_> {
fn from(value: grantRoleCall) -> Self {
(value.role, value.account)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
role: tuple.0,
account: tuple.1,
}
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<grantRoleReturn> for UnderlyingRustTuple<'_> {
fn from(value: grantRoleReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for grantRoleReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl grantRoleReturn {
fn _tokenize(
&self,
) -> <grantRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for grantRoleCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = grantRoleReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "grantRole(bytes32,address)";
const SELECTOR: [u8; 4] = [47u8, 47u8, 241u8, 93u8];
#[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::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.role),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.account,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
grantRoleReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct hasRoleCall {
#[allow(missing_docs)]
pub role: alloy::sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub account: alloy::sol_types::private::Address,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct hasRoleReturn {
#[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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::FixedBytes<32>,
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<hasRoleCall> for UnderlyingRustTuple<'_> {
fn from(value: hasRoleCall) -> Self {
(value.role, value.account)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
role: tuple.0,
account: tuple.1,
}
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<hasRoleReturn> for UnderlyingRustTuple<'_> {
fn from(value: hasRoleReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for hasRoleReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for hasRoleCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::FixedBytes<32>,
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 = "hasRole(bytes32,address)";
const SELECTOR: [u8; 4] = [145u8, 209u8, 72u8, 84u8];
#[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::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.role),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.account,
),
)
}
#[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: hasRoleReturn = 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: hasRoleReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct initializeCall {
#[allow(missing_docs)]
pub _operatorRegistry: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _owner: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct initializeReturn {}
#[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)]
#[allow(dead_code)]
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<initializeCall> for UnderlyingRustTuple<'_> {
fn from(value: initializeCall) -> Self {
(value._operatorRegistry, value._owner)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
_operatorRegistry: tuple.0,
_owner: tuple.1,
}
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<initializeReturn> for UnderlyingRustTuple<'_> {
fn from(value: initializeReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl initializeReturn {
fn _tokenize(
&self,
) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for initializeCall {
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 = initializeReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "initialize(address,address)";
const SELECTOR: [u8; 4] = [72u8, 92u8, 201u8, 85u8];
#[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._operatorRegistry,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self._owner,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
initializeReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct initializeEpochsCall {
#[allow(missing_docs)]
pub _initialEpochDurationBlocks: u32,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct initializeEpochsReturn {}
#[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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<initializeEpochsCall>
for UnderlyingRustTuple<'_> {
fn from(value: initializeEpochsCall) -> Self {
(value._initialEpochDurationBlocks,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for initializeEpochsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
_initialEpochDurationBlocks: tuple.0,
}
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<initializeEpochsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: initializeEpochsReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for initializeEpochsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl initializeEpochsReturn {
fn _tokenize(
&self,
) -> <initializeEpochsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for initializeEpochsCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = initializeEpochsReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "initializeEpochs(uint32)";
const SELECTOR: [u8; 4] = [30u8, 81u8, 73u8, 90u8];
#[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<
32,
> as alloy_sol_types::SolType>::tokenize(
&self._initialEpochDurationBlocks,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
initializeEpochsReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct initializeV2Call {
#[allow(missing_docs)]
pub admin: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct initializeV2Return {}
#[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)]
#[allow(dead_code)]
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<initializeV2Call> for UnderlyingRustTuple<'_> {
fn from(value: initializeV2Call) -> Self {
(value.admin,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeV2Call {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { admin: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<initializeV2Return> for UnderlyingRustTuple<'_> {
fn from(value: initializeV2Return) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeV2Return {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl initializeV2Return {
fn _tokenize(
&self,
) -> <initializeV2Call as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for initializeV2Call {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = initializeV2Return;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "initializeV2(address)";
const SELECTOR: [u8; 4] = [41u8, 182u8, 236u8, 169u8];
#[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.admin,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
initializeV2Return::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct isEpochAdvanceReadyCall;
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct isEpochAdvanceReadyReturn {
#[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)]
#[allow(dead_code)]
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<isEpochAdvanceReadyCall>
for UnderlyingRustTuple<'_> {
fn from(value: isEpochAdvanceReadyCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for isEpochAdvanceReadyCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<isEpochAdvanceReadyReturn>
for UnderlyingRustTuple<'_> {
fn from(value: isEpochAdvanceReadyReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for isEpochAdvanceReadyReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for isEpochAdvanceReadyCall {
type Parameters<'a> = ();
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 = "isEpochAdvanceReady()";
const SELECTOR: [u8; 4] = [20u8, 130u8, 31u8, 74u8];
#[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::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: isEpochAdvanceReadyReturn = 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: isEpochAdvanceReadyReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct nextEpochAdvanceAtCall;
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct nextEpochAdvanceAtReturn {
#[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)]
#[allow(dead_code)]
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<nextEpochAdvanceAtCall>
for UnderlyingRustTuple<'_> {
fn from(value: nextEpochAdvanceAtCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for nextEpochAdvanceAtCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<nextEpochAdvanceAtReturn>
for UnderlyingRustTuple<'_> {
fn from(value: nextEpochAdvanceAtReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for nextEpochAdvanceAtReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for nextEpochAdvanceAtCall {
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 = "nextEpochAdvanceAt()";
const SELECTOR: [u8; 4] = [148u8, 173u8, 163u8, 232u8];
#[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: nextEpochAdvanceAtReturn = 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: nextEpochAdvanceAtReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct operatorRegistryCall;
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct operatorRegistryReturn {
#[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)]
#[allow(dead_code)]
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<operatorRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: operatorRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for operatorRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<operatorRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: operatorRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for operatorRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for operatorRegistryCall {
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 = "operatorRegistry()";
const SELECTOR: [u8; 4] = [88u8, 194u8, 34u8, 91u8];
#[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: operatorRegistryReturn = 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: operatorRegistryReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct ownerCall;
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct ownerReturn {
#[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)]
#[allow(dead_code)]
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<ownerCall> for UnderlyingRustTuple<'_> {
fn from(value: ownerCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<ownerReturn> for UnderlyingRustTuple<'_> {
fn from(value: ownerReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for ownerCall {
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 = "owner()";
const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
#[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: ownerReturn = 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: ownerReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pendingDeregistersForEpochCall(pub u32);
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pendingDeregistersForEpochReturn {
#[allow(missing_docs)]
pub _0: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<pendingDeregistersForEpochCall>
for UnderlyingRustTuple<'_> {
fn from(value: pendingDeregistersForEpochCall) -> Self {
(value.0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for pendingDeregistersForEpochCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self(tuple.0)
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<pendingDeregistersForEpochReturn>
for UnderlyingRustTuple<'_> {
fn from(value: pendingDeregistersForEpochReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for pendingDeregistersForEpochReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for pendingDeregistersForEpochCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = u32;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "pendingDeregistersForEpoch(uint32)";
const SELECTOR: [u8; 4] = [118u8, 180u8, 206u8, 83u8];
#[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<
32,
> as alloy_sol_types::SolType>::tokenize(&self.0),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: pendingDeregistersForEpochReturn = 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: pendingDeregistersForEpochReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pendingEpochDurationBlocksCall;
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pendingEpochDurationBlocksReturn {
#[allow(missing_docs)]
pub _0: u32,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
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<pendingEpochDurationBlocksCall>
for UnderlyingRustTuple<'_> {
fn from(value: pendingEpochDurationBlocksCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for pendingEpochDurationBlocksCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<pendingEpochDurationBlocksReturn>
for UnderlyingRustTuple<'_> {
fn from(value: pendingEpochDurationBlocksReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for pendingEpochDurationBlocksReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for pendingEpochDurationBlocksCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = u32;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "pendingEpochDurationBlocks()";
const SELECTOR: [u8; 4] = [165u8, 168u8, 101u8, 253u8];
#[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<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: pendingEpochDurationBlocksReturn = 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: pendingEpochDurationBlocksReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pendingTaskGeneratorAdditionsCall {
#[allow(missing_docs)]
pub epoch: u32,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pendingTaskGeneratorAdditionsReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Vec<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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<pendingTaskGeneratorAdditionsCall>
for UnderlyingRustTuple<'_> {
fn from(value: pendingTaskGeneratorAdditionsCall) -> Self {
(value.epoch,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for pendingTaskGeneratorAdditionsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { epoch: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<pendingTaskGeneratorAdditionsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: pendingTaskGeneratorAdditionsReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for pendingTaskGeneratorAdditionsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for pendingTaskGeneratorAdditionsCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Vec<
alloy::sol_types::private::Address,
>;
type ReturnTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "pendingTaskGeneratorAdditions(uint32)";
const SELECTOR: [u8; 4] = [117u8, 146u8, 191u8, 207u8];
#[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<
32,
> as alloy_sol_types::SolType>::tokenize(&self.epoch),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Array<
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: pendingTaskGeneratorAdditionsReturn = 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: pendingTaskGeneratorAdditionsReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pendingTaskGeneratorRemovalsCall {
#[allow(missing_docs)]
pub epoch: u32,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pendingTaskGeneratorRemovalsReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Vec<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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<pendingTaskGeneratorRemovalsCall>
for UnderlyingRustTuple<'_> {
fn from(value: pendingTaskGeneratorRemovalsCall) -> Self {
(value.epoch,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for pendingTaskGeneratorRemovalsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { epoch: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<pendingTaskGeneratorRemovalsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: pendingTaskGeneratorRemovalsReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for pendingTaskGeneratorRemovalsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for pendingTaskGeneratorRemovalsCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Vec<
alloy::sol_types::private::Address,
>;
type ReturnTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "pendingTaskGeneratorRemovals(uint32)";
const SELECTOR: [u8; 4] = [7u8, 65u8, 66u8, 44u8];
#[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<
32,
> as alloy_sol_types::SolType>::tokenize(&self.epoch),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Array<
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: pendingTaskGeneratorRemovalsReturn = 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: pendingTaskGeneratorRemovalsReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pendingWhitelistAdditionsCall {
#[allow(missing_docs)]
pub epoch: u32,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pendingWhitelistAdditionsReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Vec<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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<pendingWhitelistAdditionsCall>
for UnderlyingRustTuple<'_> {
fn from(value: pendingWhitelistAdditionsCall) -> Self {
(value.epoch,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for pendingWhitelistAdditionsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { epoch: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<pendingWhitelistAdditionsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: pendingWhitelistAdditionsReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for pendingWhitelistAdditionsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for pendingWhitelistAdditionsCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Vec<
alloy::sol_types::private::Address,
>;
type ReturnTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "pendingWhitelistAdditions(uint32)";
const SELECTOR: [u8; 4] = [154u8, 91u8, 86u8, 105u8];
#[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<
32,
> as alloy_sol_types::SolType>::tokenize(&self.epoch),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Array<
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: pendingWhitelistAdditionsReturn = 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: pendingWhitelistAdditionsReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pendingWhitelistRemovalsCall {
#[allow(missing_docs)]
pub epoch: u32,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct pendingWhitelistRemovalsReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Vec<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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<pendingWhitelistRemovalsCall>
for UnderlyingRustTuple<'_> {
fn from(value: pendingWhitelistRemovalsCall) -> Self {
(value.epoch,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for pendingWhitelistRemovalsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { epoch: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<pendingWhitelistRemovalsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: pendingWhitelistRemovalsReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for pendingWhitelistRemovalsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for pendingWhitelistRemovalsCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Vec<
alloy::sol_types::private::Address,
>;
type ReturnTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "pendingWhitelistRemovals(uint32)";
const SELECTOR: [u8; 4] = [99u8, 125u8, 132u8, 40u8];
#[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<
32,
> as alloy_sol_types::SolType>::tokenize(&self.epoch),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Array<
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: pendingWhitelistRemovalsReturn = 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: pendingWhitelistRemovalsReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueAddMultipleToTaskGeneratorsCall {
#[allow(missing_docs)]
pub generators: alloy::sol_types::private::Vec<
alloy::sol_types::private::Address,
>,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueAddMultipleToTaskGeneratorsReturn {}
#[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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<queueAddMultipleToTaskGeneratorsCall>
for UnderlyingRustTuple<'_> {
fn from(value: queueAddMultipleToTaskGeneratorsCall) -> Self {
(value.generators,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueAddMultipleToTaskGeneratorsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { generators: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<queueAddMultipleToTaskGeneratorsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: queueAddMultipleToTaskGeneratorsReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueAddMultipleToTaskGeneratorsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl queueAddMultipleToTaskGeneratorsReturn {
fn _tokenize(
&self,
) -> <queueAddMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for queueAddMultipleToTaskGeneratorsCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = queueAddMultipleToTaskGeneratorsReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "queueAddMultipleToTaskGenerators(address[])";
const SELECTOR: [u8; 4] = [61u8, 101u8, 56u8, 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::Array<
alloy::sol_types::sol_data::Address,
> as alloy_sol_types::SolType>::tokenize(&self.generators),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
queueAddMultipleToTaskGeneratorsReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueAddMultipleToWhitelistCall {
#[allow(missing_docs)]
pub operators: alloy::sol_types::private::Vec<
alloy::sol_types::private::Address,
>,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueAddMultipleToWhitelistReturn {}
#[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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<queueAddMultipleToWhitelistCall>
for UnderlyingRustTuple<'_> {
fn from(value: queueAddMultipleToWhitelistCall) -> Self {
(value.operators,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueAddMultipleToWhitelistCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operators: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<queueAddMultipleToWhitelistReturn>
for UnderlyingRustTuple<'_> {
fn from(value: queueAddMultipleToWhitelistReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueAddMultipleToWhitelistReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl queueAddMultipleToWhitelistReturn {
fn _tokenize(
&self,
) -> <queueAddMultipleToWhitelistCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for queueAddMultipleToWhitelistCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = queueAddMultipleToWhitelistReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "queueAddMultipleToWhitelist(address[])";
const SELECTOR: [u8; 4] = [20u8, 65u8, 178u8, 212u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::Address,
> as alloy_sol_types::SolType>::tokenize(&self.operators),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
queueAddMultipleToWhitelistReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueAddTaskGeneratorCall {
#[allow(missing_docs)]
pub generator: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueAddTaskGeneratorReturn {}
#[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)]
#[allow(dead_code)]
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<queueAddTaskGeneratorCall>
for UnderlyingRustTuple<'_> {
fn from(value: queueAddTaskGeneratorCall) -> Self {
(value.generator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueAddTaskGeneratorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { generator: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<queueAddTaskGeneratorReturn>
for UnderlyingRustTuple<'_> {
fn from(value: queueAddTaskGeneratorReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueAddTaskGeneratorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl queueAddTaskGeneratorReturn {
fn _tokenize(
&self,
) -> <queueAddTaskGeneratorCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for queueAddTaskGeneratorCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = queueAddTaskGeneratorReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "queueAddTaskGenerator(address)";
const SELECTOR: [u8; 4] = [34u8, 48u8, 167u8, 174u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.generator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
queueAddTaskGeneratorReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueAddToWhitelistCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueAddToWhitelistReturn {}
#[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)]
#[allow(dead_code)]
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<queueAddToWhitelistCall>
for UnderlyingRustTuple<'_> {
fn from(value: queueAddToWhitelistCall) -> Self {
(value.operator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueAddToWhitelistCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operator: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<queueAddToWhitelistReturn>
for UnderlyingRustTuple<'_> {
fn from(value: queueAddToWhitelistReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueAddToWhitelistReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl queueAddToWhitelistReturn {
fn _tokenize(
&self,
) -> <queueAddToWhitelistCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for queueAddToWhitelistCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = queueAddToWhitelistReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "queueAddToWhitelist(address)";
const SELECTOR: [u8; 4] = [250u8, 203u8, 189u8, 197u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
queueAddToWhitelistReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueDeregisterCall;
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueDeregisterReturn {}
#[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)]
#[allow(dead_code)]
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<queueDeregisterCall> for UnderlyingRustTuple<'_> {
fn from(value: queueDeregisterCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for queueDeregisterCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<queueDeregisterReturn>
for UnderlyingRustTuple<'_> {
fn from(value: queueDeregisterReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueDeregisterReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl queueDeregisterReturn {
fn _tokenize(
&self,
) -> <queueDeregisterCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for queueDeregisterCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = queueDeregisterReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "queueDeregister()";
const SELECTOR: [u8; 4] = [65u8, 235u8, 133u8, 109u8];
#[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<'_> {
queueDeregisterReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueRemoveFromWhitelistCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueRemoveFromWhitelistReturn {}
#[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)]
#[allow(dead_code)]
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<queueRemoveFromWhitelistCall>
for UnderlyingRustTuple<'_> {
fn from(value: queueRemoveFromWhitelistCall) -> Self {
(value.operator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueRemoveFromWhitelistCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operator: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<queueRemoveFromWhitelistReturn>
for UnderlyingRustTuple<'_> {
fn from(value: queueRemoveFromWhitelistReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueRemoveFromWhitelistReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl queueRemoveFromWhitelistReturn {
fn _tokenize(
&self,
) -> <queueRemoveFromWhitelistCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for queueRemoveFromWhitelistCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = queueRemoveFromWhitelistReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "queueRemoveFromWhitelist(address)";
const SELECTOR: [u8; 4] = [77u8, 168u8, 214u8, 47u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
queueRemoveFromWhitelistReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueRemoveTaskGeneratorCall {
#[allow(missing_docs)]
pub generator: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queueRemoveTaskGeneratorReturn {}
#[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)]
#[allow(dead_code)]
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<queueRemoveTaskGeneratorCall>
for UnderlyingRustTuple<'_> {
fn from(value: queueRemoveTaskGeneratorCall) -> Self {
(value.generator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueRemoveTaskGeneratorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { generator: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<queueRemoveTaskGeneratorReturn>
for UnderlyingRustTuple<'_> {
fn from(value: queueRemoveTaskGeneratorReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queueRemoveTaskGeneratorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl queueRemoveTaskGeneratorReturn {
fn _tokenize(
&self,
) -> <queueRemoveTaskGeneratorCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for queueRemoveTaskGeneratorCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = queueRemoveTaskGeneratorReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "queueRemoveTaskGenerator(address)";
const SELECTOR: [u8; 4] = [92u8, 143u8, 112u8, 71u8];
#[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.generator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
queueRemoveTaskGeneratorReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct removeFromWhitelistCall {
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct removeFromWhitelistReturn {}
#[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)]
#[allow(dead_code)]
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<removeFromWhitelistCall>
for UnderlyingRustTuple<'_> {
fn from(value: removeFromWhitelistCall) -> Self {
(value.operator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for removeFromWhitelistCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { operator: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<removeFromWhitelistReturn>
for UnderlyingRustTuple<'_> {
fn from(value: removeFromWhitelistReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for removeFromWhitelistReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl removeFromWhitelistReturn {
fn _tokenize(
&self,
) -> <removeFromWhitelistCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for removeFromWhitelistCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = removeFromWhitelistReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "removeFromWhitelist(address)";
const SELECTOR: [u8; 4] = [138u8, 177u8, 214u8, 129u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
removeFromWhitelistReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct removeTaskGeneratorCall {
#[allow(missing_docs)]
pub generator: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct removeTaskGeneratorReturn {}
#[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)]
#[allow(dead_code)]
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<removeTaskGeneratorCall>
for UnderlyingRustTuple<'_> {
fn from(value: removeTaskGeneratorCall) -> Self {
(value.generator,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for removeTaskGeneratorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { generator: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<removeTaskGeneratorReturn>
for UnderlyingRustTuple<'_> {
fn from(value: removeTaskGeneratorReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for removeTaskGeneratorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl removeTaskGeneratorReturn {
fn _tokenize(
&self,
) -> <removeTaskGeneratorCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for removeTaskGeneratorCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = removeTaskGeneratorReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "removeTaskGenerator(address)";
const SELECTOR: [u8; 4] = [241u8, 74u8, 253u8, 124u8];
#[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.generator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
removeTaskGeneratorReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct renounceOwnershipCall;
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct renounceOwnershipReturn {}
#[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)]
#[allow(dead_code)]
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<renounceOwnershipCall>
for UnderlyingRustTuple<'_> {
fn from(value: renounceOwnershipCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for renounceOwnershipCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<renounceOwnershipReturn>
for UnderlyingRustTuple<'_> {
fn from(value: renounceOwnershipReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for renounceOwnershipReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl renounceOwnershipReturn {
fn _tokenize(
&self,
) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for renounceOwnershipCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = renounceOwnershipReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "renounceOwnership()";
const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
#[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<'_> {
renounceOwnershipReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct revokeRoleCall {
#[allow(missing_docs)]
pub role: alloy::sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub account: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct revokeRoleReturn {}
#[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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::FixedBytes<32>,
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<revokeRoleCall> for UnderlyingRustTuple<'_> {
fn from(value: revokeRoleCall) -> Self {
(value.role, value.account)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
role: tuple.0,
account: tuple.1,
}
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<revokeRoleReturn> for UnderlyingRustTuple<'_> {
fn from(value: revokeRoleReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeRoleReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl revokeRoleReturn {
fn _tokenize(
&self,
) -> <revokeRoleCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for revokeRoleCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = revokeRoleReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "revokeRole(bytes32,address)";
const SELECTOR: [u8; 4] = [213u8, 71u8, 116u8, 31u8];
#[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::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.role),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.account,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
revokeRoleReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setEpochDurationBlocksCall {
#[allow(missing_docs)]
pub newDuration: u32,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setEpochDurationBlocksReturn {}
#[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)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u32,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setEpochDurationBlocksCall>
for UnderlyingRustTuple<'_> {
fn from(value: setEpochDurationBlocksCall) -> Self {
(value.newDuration,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setEpochDurationBlocksCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { newDuration: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<setEpochDurationBlocksReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setEpochDurationBlocksReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setEpochDurationBlocksReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setEpochDurationBlocksReturn {
fn _tokenize(
&self,
) -> <setEpochDurationBlocksCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setEpochDurationBlocksCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<32>,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setEpochDurationBlocksReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setEpochDurationBlocks(uint32)";
const SELECTOR: [u8; 4] = [218u8, 62u8, 212u8, 100u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Uint<
32,
> as alloy_sol_types::SolType>::tokenize(&self.newDuration),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setEpochDurationBlocksReturn::_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)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct transferOwnershipCall {
#[allow(missing_docs)]
pub newOwner: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct transferOwnershipReturn {}
#[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)]
#[allow(dead_code)]
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<transferOwnershipCall>
for UnderlyingRustTuple<'_> {
fn from(value: transferOwnershipCall) -> Self {
(value.newOwner,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for transferOwnershipCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { newOwner: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
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<transferOwnershipReturn>
for UnderlyingRustTuple<'_> {
fn from(value: transferOwnershipReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for transferOwnershipReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl transferOwnershipReturn {
fn _tokenize(
&self,
) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for transferOwnershipCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = transferOwnershipReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "transferOwnership(address)";
const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
#[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.newOwner,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
transferOwnershipReturn::_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(Clone)]
#[derive(serde::Serialize, serde::Deserialize)]
#[derive()]
pub enum OperatorRegistryEpochGovernanceCalls {
#[allow(missing_docs)]
ADMIN_ROLE(ADMIN_ROLECall),
#[allow(missing_docs)]
addMultipleToTaskGenerators(addMultipleToTaskGeneratorsCall),
#[allow(missing_docs)]
addMultipleToWhitelist(addMultipleToWhitelistCall),
#[allow(missing_docs)]
addTaskGenerator(addTaskGeneratorCall),
#[allow(missing_docs)]
addToWhitelist(addToWhitelistCall),
#[allow(missing_docs)]
applyPendingChanges(applyPendingChangesCall),
#[allow(missing_docs)]
approvedDeregisterEpoch(approvedDeregisterEpochCall),
#[allow(missing_docs)]
cancelDeregisterApproval(cancelDeregisterApprovalCall),
#[allow(missing_docs)]
consumeDeregisterApproval(consumeDeregisterApprovalCall),
#[allow(missing_docs)]
currentEpoch(currentEpochCall),
#[allow(missing_docs)]
epochDurationBlocks(epochDurationBlocksCall),
#[allow(missing_docs)]
epochStartBlock(epochStartBlockCall),
#[allow(missing_docs)]
grantRole(grantRoleCall),
#[allow(missing_docs)]
hasRole(hasRoleCall),
#[allow(missing_docs)]
initialize(initializeCall),
#[allow(missing_docs)]
initializeEpochs(initializeEpochsCall),
#[allow(missing_docs)]
initializeV2(initializeV2Call),
#[allow(missing_docs)]
isEpochAdvanceReady(isEpochAdvanceReadyCall),
#[allow(missing_docs)]
nextEpochAdvanceAt(nextEpochAdvanceAtCall),
#[allow(missing_docs)]
operatorRegistry(operatorRegistryCall),
#[allow(missing_docs)]
owner(ownerCall),
#[allow(missing_docs)]
pendingDeregistersForEpoch(pendingDeregistersForEpochCall),
#[allow(missing_docs)]
pendingEpochDurationBlocks(pendingEpochDurationBlocksCall),
#[allow(missing_docs)]
pendingTaskGeneratorAdditions(pendingTaskGeneratorAdditionsCall),
#[allow(missing_docs)]
pendingTaskGeneratorRemovals(pendingTaskGeneratorRemovalsCall),
#[allow(missing_docs)]
pendingWhitelistAdditions(pendingWhitelistAdditionsCall),
#[allow(missing_docs)]
pendingWhitelistRemovals(pendingWhitelistRemovalsCall),
#[allow(missing_docs)]
queueAddMultipleToTaskGenerators(queueAddMultipleToTaskGeneratorsCall),
#[allow(missing_docs)]
queueAddMultipleToWhitelist(queueAddMultipleToWhitelistCall),
#[allow(missing_docs)]
queueAddTaskGenerator(queueAddTaskGeneratorCall),
#[allow(missing_docs)]
queueAddToWhitelist(queueAddToWhitelistCall),
#[allow(missing_docs)]
queueDeregister(queueDeregisterCall),
#[allow(missing_docs)]
queueRemoveFromWhitelist(queueRemoveFromWhitelistCall),
#[allow(missing_docs)]
queueRemoveTaskGenerator(queueRemoveTaskGeneratorCall),
#[allow(missing_docs)]
removeFromWhitelist(removeFromWhitelistCall),
#[allow(missing_docs)]
removeTaskGenerator(removeTaskGeneratorCall),
#[allow(missing_docs)]
renounceOwnership(renounceOwnershipCall),
#[allow(missing_docs)]
revokeRole(revokeRoleCall),
#[allow(missing_docs)]
setEpochDurationBlocks(setEpochDurationBlocksCall),
#[allow(missing_docs)]
transferOwnership(transferOwnershipCall),
}
impl OperatorRegistryEpochGovernanceCalls {
pub const SELECTORS: &'static [[u8; 4usize]] = &[
[7u8, 65u8, 66u8, 44u8],
[20u8, 65u8, 178u8, 212u8],
[20u8, 130u8, 31u8, 74u8],
[30u8, 81u8, 73u8, 90u8],
[34u8, 48u8, 167u8, 174u8],
[41u8, 182u8, 236u8, 169u8],
[47u8, 47u8, 241u8, 93u8],
[61u8, 101u8, 56u8, 37u8],
[62u8, 213u8, 91u8, 123u8],
[65u8, 235u8, 133u8, 109u8],
[68u8, 215u8, 68u8, 89u8],
[72u8, 92u8, 201u8, 85u8],
[77u8, 168u8, 214u8, 47u8],
[78u8, 61u8, 149u8, 177u8],
[88u8, 194u8, 34u8, 91u8],
[92u8, 143u8, 112u8, 71u8],
[99u8, 125u8, 132u8, 40u8],
[105u8, 183u8, 226u8, 62u8],
[113u8, 80u8, 24u8, 166u8],
[113u8, 113u8, 44u8, 41u8],
[117u8, 146u8, 191u8, 207u8],
[117u8, 178u8, 56u8, 252u8],
[118u8, 103u8, 24u8, 8u8],
[118u8, 180u8, 206u8, 83u8],
[132u8, 1u8, 248u8, 209u8],
[138u8, 177u8, 214u8, 129u8],
[141u8, 165u8, 203u8, 91u8],
[145u8, 209u8, 72u8, 84u8],
[146u8, 200u8, 198u8, 50u8],
[148u8, 173u8, 163u8, 232u8],
[154u8, 91u8, 86u8, 105u8],
[165u8, 168u8, 101u8, 253u8],
[166u8, 210u8, 87u8, 79u8],
[175u8, 131u8, 68u8, 7u8],
[213u8, 71u8, 116u8, 31u8],
[218u8, 62u8, 212u8, 100u8],
[228u8, 50u8, 82u8, 215u8],
[241u8, 74u8, 253u8, 124u8],
[242u8, 253u8, 227u8, 139u8],
[250u8, 203u8, 189u8, 197u8],
];
pub const VARIANT_NAMES: &'static [&'static str] = &[
::core::stringify!(pendingTaskGeneratorRemovals),
::core::stringify!(queueAddMultipleToWhitelist),
::core::stringify!(isEpochAdvanceReady),
::core::stringify!(initializeEpochs),
::core::stringify!(queueAddTaskGenerator),
::core::stringify!(initializeV2),
::core::stringify!(grantRole),
::core::stringify!(queueAddMultipleToTaskGenerators),
::core::stringify!(epochStartBlock),
::core::stringify!(queueDeregister),
::core::stringify!(applyPendingChanges),
::core::stringify!(initialize),
::core::stringify!(queueRemoveFromWhitelist),
::core::stringify!(consumeDeregisterApproval),
::core::stringify!(operatorRegistry),
::core::stringify!(queueRemoveTaskGenerator),
::core::stringify!(pendingWhitelistRemovals),
::core::stringify!(addTaskGenerator),
::core::stringify!(renounceOwnership),
::core::stringify!(epochDurationBlocks),
::core::stringify!(pendingTaskGeneratorAdditions),
::core::stringify!(ADMIN_ROLE),
::core::stringify!(currentEpoch),
::core::stringify!(pendingDeregistersForEpoch),
::core::stringify!(addMultipleToWhitelist),
::core::stringify!(removeFromWhitelist),
::core::stringify!(owner),
::core::stringify!(hasRole),
::core::stringify!(cancelDeregisterApproval),
::core::stringify!(nextEpochAdvanceAt),
::core::stringify!(pendingWhitelistAdditions),
::core::stringify!(pendingEpochDurationBlocks),
::core::stringify!(approvedDeregisterEpoch),
::core::stringify!(addMultipleToTaskGenerators),
::core::stringify!(revokeRole),
::core::stringify!(setEpochDurationBlocks),
::core::stringify!(addToWhitelist),
::core::stringify!(removeTaskGenerator),
::core::stringify!(transferOwnership),
::core::stringify!(queueAddToWhitelist),
];
pub const SIGNATURES: &'static [&'static str] = &[
<pendingTaskGeneratorRemovalsCall as alloy_sol_types::SolCall>::SIGNATURE,
<queueAddMultipleToWhitelistCall as alloy_sol_types::SolCall>::SIGNATURE,
<isEpochAdvanceReadyCall as alloy_sol_types::SolCall>::SIGNATURE,
<initializeEpochsCall as alloy_sol_types::SolCall>::SIGNATURE,
<queueAddTaskGeneratorCall as alloy_sol_types::SolCall>::SIGNATURE,
<initializeV2Call as alloy_sol_types::SolCall>::SIGNATURE,
<grantRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
<queueAddMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::SIGNATURE,
<epochStartBlockCall as alloy_sol_types::SolCall>::SIGNATURE,
<queueDeregisterCall as alloy_sol_types::SolCall>::SIGNATURE,
<applyPendingChangesCall as alloy_sol_types::SolCall>::SIGNATURE,
<initializeCall as alloy_sol_types::SolCall>::SIGNATURE,
<queueRemoveFromWhitelistCall as alloy_sol_types::SolCall>::SIGNATURE,
<consumeDeregisterApprovalCall as alloy_sol_types::SolCall>::SIGNATURE,
<operatorRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<queueRemoveTaskGeneratorCall as alloy_sol_types::SolCall>::SIGNATURE,
<pendingWhitelistRemovalsCall as alloy_sol_types::SolCall>::SIGNATURE,
<addTaskGeneratorCall as alloy_sol_types::SolCall>::SIGNATURE,
<renounceOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
<epochDurationBlocksCall as alloy_sol_types::SolCall>::SIGNATURE,
<pendingTaskGeneratorAdditionsCall as alloy_sol_types::SolCall>::SIGNATURE,
<ADMIN_ROLECall as alloy_sol_types::SolCall>::SIGNATURE,
<currentEpochCall as alloy_sol_types::SolCall>::SIGNATURE,
<pendingDeregistersForEpochCall as alloy_sol_types::SolCall>::SIGNATURE,
<addMultipleToWhitelistCall as alloy_sol_types::SolCall>::SIGNATURE,
<removeFromWhitelistCall as alloy_sol_types::SolCall>::SIGNATURE,
<ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
<hasRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
<cancelDeregisterApprovalCall as alloy_sol_types::SolCall>::SIGNATURE,
<nextEpochAdvanceAtCall as alloy_sol_types::SolCall>::SIGNATURE,
<pendingWhitelistAdditionsCall as alloy_sol_types::SolCall>::SIGNATURE,
<pendingEpochDurationBlocksCall as alloy_sol_types::SolCall>::SIGNATURE,
<approvedDeregisterEpochCall as alloy_sol_types::SolCall>::SIGNATURE,
<addMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::SIGNATURE,
<revokeRoleCall as alloy_sol_types::SolCall>::SIGNATURE,
<setEpochDurationBlocksCall as alloy_sol_types::SolCall>::SIGNATURE,
<addToWhitelistCall as alloy_sol_types::SolCall>::SIGNATURE,
<removeTaskGeneratorCall as alloy_sol_types::SolCall>::SIGNATURE,
<transferOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
<queueAddToWhitelistCall as alloy_sol_types::SolCall>::SIGNATURE,
];
#[inline]
pub fn signature_by_selector(
selector: [u8; 4usize],
) -> ::core::option::Option<&'static str> {
match Self::SELECTORS.binary_search(&selector) {
::core::result::Result::Ok(idx) => {
::core::option::Option::Some(Self::SIGNATURES[idx])
}
::core::result::Result::Err(_) => ::core::option::Option::None,
}
}
#[inline]
pub fn name_by_selector(
selector: [u8; 4usize],
) -> ::core::option::Option<&'static str> {
let sig = Self::signature_by_selector(selector)?;
sig.split_once('(').map(|(name, _)| name)
}
}
#[automatically_derived]
impl alloy_sol_types::SolInterface for OperatorRegistryEpochGovernanceCalls {
const NAME: &'static str = "OperatorRegistryEpochGovernanceCalls";
const MIN_DATA_LENGTH: usize = 0usize;
const COUNT: usize = 40usize;
#[inline]
fn selector(&self) -> [u8; 4] {
match self {
Self::ADMIN_ROLE(_) => {
<ADMIN_ROLECall as alloy_sol_types::SolCall>::SELECTOR
}
Self::addMultipleToTaskGenerators(_) => {
<addMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::addMultipleToWhitelist(_) => {
<addMultipleToWhitelistCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::addTaskGenerator(_) => {
<addTaskGeneratorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::addToWhitelist(_) => {
<addToWhitelistCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::applyPendingChanges(_) => {
<applyPendingChangesCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::approvedDeregisterEpoch(_) => {
<approvedDeregisterEpochCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::cancelDeregisterApproval(_) => {
<cancelDeregisterApprovalCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::consumeDeregisterApproval(_) => {
<consumeDeregisterApprovalCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::currentEpoch(_) => {
<currentEpochCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::epochDurationBlocks(_) => {
<epochDurationBlocksCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::epochStartBlock(_) => {
<epochStartBlockCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::grantRole(_) => {
<grantRoleCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::hasRole(_) => <hasRoleCall as alloy_sol_types::SolCall>::SELECTOR,
Self::initialize(_) => {
<initializeCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::initializeEpochs(_) => {
<initializeEpochsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::initializeV2(_) => {
<initializeV2Call as alloy_sol_types::SolCall>::SELECTOR
}
Self::isEpochAdvanceReady(_) => {
<isEpochAdvanceReadyCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::nextEpochAdvanceAt(_) => {
<nextEpochAdvanceAtCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::operatorRegistry(_) => {
<operatorRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
Self::pendingDeregistersForEpoch(_) => {
<pendingDeregistersForEpochCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::pendingEpochDurationBlocks(_) => {
<pendingEpochDurationBlocksCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::pendingTaskGeneratorAdditions(_) => {
<pendingTaskGeneratorAdditionsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::pendingTaskGeneratorRemovals(_) => {
<pendingTaskGeneratorRemovalsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::pendingWhitelistAdditions(_) => {
<pendingWhitelistAdditionsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::pendingWhitelistRemovals(_) => {
<pendingWhitelistRemovalsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::queueAddMultipleToTaskGenerators(_) => {
<queueAddMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::queueAddMultipleToWhitelist(_) => {
<queueAddMultipleToWhitelistCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::queueAddTaskGenerator(_) => {
<queueAddTaskGeneratorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::queueAddToWhitelist(_) => {
<queueAddToWhitelistCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::queueDeregister(_) => {
<queueDeregisterCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::queueRemoveFromWhitelist(_) => {
<queueRemoveFromWhitelistCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::queueRemoveTaskGenerator(_) => {
<queueRemoveTaskGeneratorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::removeFromWhitelist(_) => {
<removeFromWhitelistCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::removeTaskGenerator(_) => {
<removeTaskGeneratorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::renounceOwnership(_) => {
<renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::revokeRole(_) => {
<revokeRoleCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setEpochDurationBlocks(_) => {
<setEpochDurationBlocksCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::transferOwnership(_) => {
<transferOwnershipCall 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<OperatorRegistryEpochGovernanceCalls>] = &[
{
fn pendingTaskGeneratorRemovals(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<pendingTaskGeneratorRemovalsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::pendingTaskGeneratorRemovals,
)
}
pendingTaskGeneratorRemovals
},
{
fn queueAddMultipleToWhitelist(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueAddMultipleToWhitelistCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::queueAddMultipleToWhitelist,
)
}
queueAddMultipleToWhitelist
},
{
fn isEpochAdvanceReady(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<isEpochAdvanceReadyCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::isEpochAdvanceReady,
)
}
isEpochAdvanceReady
},
{
fn initializeEpochs(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<initializeEpochsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::initializeEpochs)
}
initializeEpochs
},
{
fn queueAddTaskGenerator(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueAddTaskGeneratorCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::queueAddTaskGenerator,
)
}
queueAddTaskGenerator
},
{
fn initializeV2(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<initializeV2Call as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::initializeV2)
}
initializeV2
},
{
fn grantRole(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(OperatorRegistryEpochGovernanceCalls::grantRole)
}
grantRole
},
{
fn queueAddMultipleToTaskGenerators(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueAddMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::queueAddMultipleToTaskGenerators,
)
}
queueAddMultipleToTaskGenerators
},
{
fn epochStartBlock(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<epochStartBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::epochStartBlock)
}
epochStartBlock
},
{
fn queueDeregister(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueDeregisterCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::queueDeregister)
}
queueDeregister
},
{
fn applyPendingChanges(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<applyPendingChangesCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::applyPendingChanges,
)
}
applyPendingChanges
},
{
fn initialize(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::initialize)
}
initialize
},
{
fn queueRemoveFromWhitelist(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueRemoveFromWhitelistCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::queueRemoveFromWhitelist,
)
}
queueRemoveFromWhitelist
},
{
fn consumeDeregisterApproval(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<consumeDeregisterApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::consumeDeregisterApproval,
)
}
consumeDeregisterApproval
},
{
fn operatorRegistry(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<operatorRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::operatorRegistry)
}
operatorRegistry
},
{
fn queueRemoveTaskGenerator(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueRemoveTaskGeneratorCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::queueRemoveTaskGenerator,
)
}
queueRemoveTaskGenerator
},
{
fn pendingWhitelistRemovals(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<pendingWhitelistRemovalsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::pendingWhitelistRemovals,
)
}
pendingWhitelistRemovals
},
{
fn addTaskGenerator(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<addTaskGeneratorCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::addTaskGenerator)
}
addTaskGenerator
},
{
fn renounceOwnership(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::renounceOwnership)
}
renounceOwnership
},
{
fn epochDurationBlocks(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<epochDurationBlocksCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::epochDurationBlocks,
)
}
epochDurationBlocks
},
{
fn pendingTaskGeneratorAdditions(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<pendingTaskGeneratorAdditionsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::pendingTaskGeneratorAdditions,
)
}
pendingTaskGeneratorAdditions
},
{
fn ADMIN_ROLE(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::ADMIN_ROLE)
}
ADMIN_ROLE
},
{
fn currentEpoch(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<currentEpochCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::currentEpoch)
}
currentEpoch
},
{
fn pendingDeregistersForEpoch(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<pendingDeregistersForEpochCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::pendingDeregistersForEpoch,
)
}
pendingDeregistersForEpoch
},
{
fn addMultipleToWhitelist(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<addMultipleToWhitelistCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::addMultipleToWhitelist,
)
}
addMultipleToWhitelist
},
{
fn removeFromWhitelist(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<removeFromWhitelistCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::removeFromWhitelist,
)
}
removeFromWhitelist
},
{
fn owner(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(OperatorRegistryEpochGovernanceCalls::owner)
}
owner
},
{
fn hasRole(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(OperatorRegistryEpochGovernanceCalls::hasRole)
}
hasRole
},
{
fn cancelDeregisterApproval(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<cancelDeregisterApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::cancelDeregisterApproval,
)
}
cancelDeregisterApproval
},
{
fn nextEpochAdvanceAt(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<nextEpochAdvanceAtCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::nextEpochAdvanceAt,
)
}
nextEpochAdvanceAt
},
{
fn pendingWhitelistAdditions(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<pendingWhitelistAdditionsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::pendingWhitelistAdditions,
)
}
pendingWhitelistAdditions
},
{
fn pendingEpochDurationBlocks(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<pendingEpochDurationBlocksCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::pendingEpochDurationBlocks,
)
}
pendingEpochDurationBlocks
},
{
fn approvedDeregisterEpoch(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<approvedDeregisterEpochCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::approvedDeregisterEpoch,
)
}
approvedDeregisterEpoch
},
{
fn addMultipleToTaskGenerators(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<addMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::addMultipleToTaskGenerators,
)
}
addMultipleToTaskGenerators
},
{
fn revokeRole(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::revokeRole)
}
revokeRole
},
{
fn setEpochDurationBlocks(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<setEpochDurationBlocksCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::setEpochDurationBlocks,
)
}
setEpochDurationBlocks
},
{
fn addToWhitelist(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<addToWhitelistCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::addToWhitelist)
}
addToWhitelist
},
{
fn removeTaskGenerator(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<removeTaskGeneratorCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::removeTaskGenerator,
)
}
removeTaskGenerator
},
{
fn transferOwnership(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::transferOwnership)
}
transferOwnership
},
{
fn queueAddToWhitelist(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueAddToWhitelistCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::queueAddToWhitelist,
)
}
queueAddToWhitelist
},
];
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<OperatorRegistryEpochGovernanceCalls>] = &[
{
fn pendingTaskGeneratorRemovals(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<pendingTaskGeneratorRemovalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::pendingTaskGeneratorRemovals,
)
}
pendingTaskGeneratorRemovals
},
{
fn queueAddMultipleToWhitelist(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueAddMultipleToWhitelistCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::queueAddMultipleToWhitelist,
)
}
queueAddMultipleToWhitelist
},
{
fn isEpochAdvanceReady(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<isEpochAdvanceReadyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::isEpochAdvanceReady,
)
}
isEpochAdvanceReady
},
{
fn initializeEpochs(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<initializeEpochsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::initializeEpochs)
}
initializeEpochs
},
{
fn queueAddTaskGenerator(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueAddTaskGeneratorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::queueAddTaskGenerator,
)
}
queueAddTaskGenerator
},
{
fn initializeV2(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<initializeV2Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::initializeV2)
}
initializeV2
},
{
fn grantRole(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<grantRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::grantRole)
}
grantRole
},
{
fn queueAddMultipleToTaskGenerators(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueAddMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::queueAddMultipleToTaskGenerators,
)
}
queueAddMultipleToTaskGenerators
},
{
fn epochStartBlock(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<epochStartBlockCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::epochStartBlock)
}
epochStartBlock
},
{
fn queueDeregister(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueDeregisterCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::queueDeregister)
}
queueDeregister
},
{
fn applyPendingChanges(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<applyPendingChangesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::applyPendingChanges,
)
}
applyPendingChanges
},
{
fn initialize(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<initializeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::initialize)
}
initialize
},
{
fn queueRemoveFromWhitelist(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueRemoveFromWhitelistCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::queueRemoveFromWhitelist,
)
}
queueRemoveFromWhitelist
},
{
fn consumeDeregisterApproval(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<consumeDeregisterApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::consumeDeregisterApproval,
)
}
consumeDeregisterApproval
},
{
fn operatorRegistry(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<operatorRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::operatorRegistry)
}
operatorRegistry
},
{
fn queueRemoveTaskGenerator(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueRemoveTaskGeneratorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::queueRemoveTaskGenerator,
)
}
queueRemoveTaskGenerator
},
{
fn pendingWhitelistRemovals(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<pendingWhitelistRemovalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::pendingWhitelistRemovals,
)
}
pendingWhitelistRemovals
},
{
fn addTaskGenerator(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<addTaskGeneratorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::addTaskGenerator)
}
addTaskGenerator
},
{
fn renounceOwnership(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::renounceOwnership)
}
renounceOwnership
},
{
fn epochDurationBlocks(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<epochDurationBlocksCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::epochDurationBlocks,
)
}
epochDurationBlocks
},
{
fn pendingTaskGeneratorAdditions(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<pendingTaskGeneratorAdditionsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::pendingTaskGeneratorAdditions,
)
}
pendingTaskGeneratorAdditions
},
{
fn ADMIN_ROLE(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::ADMIN_ROLE)
}
ADMIN_ROLE
},
{
fn currentEpoch(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<currentEpochCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::currentEpoch)
}
currentEpoch
},
{
fn pendingDeregistersForEpoch(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<pendingDeregistersForEpochCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::pendingDeregistersForEpoch,
)
}
pendingDeregistersForEpoch
},
{
fn addMultipleToWhitelist(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<addMultipleToWhitelistCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::addMultipleToWhitelist,
)
}
addMultipleToWhitelist
},
{
fn removeFromWhitelist(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<removeFromWhitelistCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::removeFromWhitelist,
)
}
removeFromWhitelist
},
{
fn owner(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::owner)
}
owner
},
{
fn hasRole(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<hasRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::hasRole)
}
hasRole
},
{
fn cancelDeregisterApproval(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<cancelDeregisterApprovalCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::cancelDeregisterApproval,
)
}
cancelDeregisterApproval
},
{
fn nextEpochAdvanceAt(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<nextEpochAdvanceAtCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::nextEpochAdvanceAt,
)
}
nextEpochAdvanceAt
},
{
fn pendingWhitelistAdditions(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<pendingWhitelistAdditionsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::pendingWhitelistAdditions,
)
}
pendingWhitelistAdditions
},
{
fn pendingEpochDurationBlocks(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<pendingEpochDurationBlocksCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::pendingEpochDurationBlocks,
)
}
pendingEpochDurationBlocks
},
{
fn approvedDeregisterEpoch(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<approvedDeregisterEpochCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::approvedDeregisterEpoch,
)
}
approvedDeregisterEpoch
},
{
fn addMultipleToTaskGenerators(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<addMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::addMultipleToTaskGenerators,
)
}
addMultipleToTaskGenerators
},
{
fn revokeRole(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<revokeRoleCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::revokeRole)
}
revokeRole
},
{
fn setEpochDurationBlocks(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<setEpochDurationBlocksCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::setEpochDurationBlocks,
)
}
setEpochDurationBlocks
},
{
fn addToWhitelist(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<addToWhitelistCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::addToWhitelist)
}
addToWhitelist
},
{
fn removeTaskGenerator(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<removeTaskGeneratorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::removeTaskGenerator,
)
}
removeTaskGenerator
},
{
fn transferOwnership(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceCalls::transferOwnership)
}
transferOwnership
},
{
fn queueAddToWhitelist(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceCalls> {
<queueAddToWhitelistCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceCalls::queueAddToWhitelist,
)
}
queueAddToWhitelist
},
];
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::ADMIN_ROLE(inner) => {
<ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::addMultipleToTaskGenerators(inner) => {
<addMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::addMultipleToWhitelist(inner) => {
<addMultipleToWhitelistCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::addTaskGenerator(inner) => {
<addTaskGeneratorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::addToWhitelist(inner) => {
<addToWhitelistCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::applyPendingChanges(inner) => {
<applyPendingChangesCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::approvedDeregisterEpoch(inner) => {
<approvedDeregisterEpochCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::cancelDeregisterApproval(inner) => {
<cancelDeregisterApprovalCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::consumeDeregisterApproval(inner) => {
<consumeDeregisterApprovalCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::currentEpoch(inner) => {
<currentEpochCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::epochDurationBlocks(inner) => {
<epochDurationBlocksCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::epochStartBlock(inner) => {
<epochStartBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::grantRole(inner) => {
<grantRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::hasRole(inner) => {
<hasRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::initialize(inner) => {
<initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::initializeEpochs(inner) => {
<initializeEpochsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::initializeV2(inner) => {
<initializeV2Call as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::isEpochAdvanceReady(inner) => {
<isEpochAdvanceReadyCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::nextEpochAdvanceAt(inner) => {
<nextEpochAdvanceAtCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::operatorRegistry(inner) => {
<operatorRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::owner(inner) => {
<ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::pendingDeregistersForEpoch(inner) => {
<pendingDeregistersForEpochCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::pendingEpochDurationBlocks(inner) => {
<pendingEpochDurationBlocksCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::pendingTaskGeneratorAdditions(inner) => {
<pendingTaskGeneratorAdditionsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::pendingTaskGeneratorRemovals(inner) => {
<pendingTaskGeneratorRemovalsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::pendingWhitelistAdditions(inner) => {
<pendingWhitelistAdditionsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::pendingWhitelistRemovals(inner) => {
<pendingWhitelistRemovalsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::queueAddMultipleToTaskGenerators(inner) => {
<queueAddMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::queueAddMultipleToWhitelist(inner) => {
<queueAddMultipleToWhitelistCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::queueAddTaskGenerator(inner) => {
<queueAddTaskGeneratorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::queueAddToWhitelist(inner) => {
<queueAddToWhitelistCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::queueDeregister(inner) => {
<queueDeregisterCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::queueRemoveFromWhitelist(inner) => {
<queueRemoveFromWhitelistCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::queueRemoveTaskGenerator(inner) => {
<queueRemoveTaskGeneratorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::removeFromWhitelist(inner) => {
<removeFromWhitelistCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::removeTaskGenerator(inner) => {
<removeTaskGeneratorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::renounceOwnership(inner) => {
<renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::revokeRole(inner) => {
<revokeRoleCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::setEpochDurationBlocks(inner) => {
<setEpochDurationBlocksCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::transferOwnership(inner) => {
<transferOwnershipCall 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::ADMIN_ROLE(inner) => {
<ADMIN_ROLECall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::addMultipleToTaskGenerators(inner) => {
<addMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::addMultipleToWhitelist(inner) => {
<addMultipleToWhitelistCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::addTaskGenerator(inner) => {
<addTaskGeneratorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::addToWhitelist(inner) => {
<addToWhitelistCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::applyPendingChanges(inner) => {
<applyPendingChangesCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::approvedDeregisterEpoch(inner) => {
<approvedDeregisterEpochCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::cancelDeregisterApproval(inner) => {
<cancelDeregisterApprovalCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::consumeDeregisterApproval(inner) => {
<consumeDeregisterApprovalCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::currentEpoch(inner) => {
<currentEpochCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::epochDurationBlocks(inner) => {
<epochDurationBlocksCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::epochStartBlock(inner) => {
<epochStartBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::grantRole(inner) => {
<grantRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::hasRole(inner) => {
<hasRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
Self::initialize(inner) => {
<initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::initializeEpochs(inner) => {
<initializeEpochsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::initializeV2(inner) => {
<initializeV2Call as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::isEpochAdvanceReady(inner) => {
<isEpochAdvanceReadyCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::nextEpochAdvanceAt(inner) => {
<nextEpochAdvanceAtCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::operatorRegistry(inner) => {
<operatorRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::owner(inner) => {
<ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
Self::pendingDeregistersForEpoch(inner) => {
<pendingDeregistersForEpochCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::pendingEpochDurationBlocks(inner) => {
<pendingEpochDurationBlocksCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::pendingTaskGeneratorAdditions(inner) => {
<pendingTaskGeneratorAdditionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::pendingTaskGeneratorRemovals(inner) => {
<pendingTaskGeneratorRemovalsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::pendingWhitelistAdditions(inner) => {
<pendingWhitelistAdditionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::pendingWhitelistRemovals(inner) => {
<pendingWhitelistRemovalsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::queueAddMultipleToTaskGenerators(inner) => {
<queueAddMultipleToTaskGeneratorsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::queueAddMultipleToWhitelist(inner) => {
<queueAddMultipleToWhitelistCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::queueAddTaskGenerator(inner) => {
<queueAddTaskGeneratorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::queueAddToWhitelist(inner) => {
<queueAddToWhitelistCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::queueDeregister(inner) => {
<queueDeregisterCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::queueRemoveFromWhitelist(inner) => {
<queueRemoveFromWhitelistCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::queueRemoveTaskGenerator(inner) => {
<queueRemoveTaskGeneratorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::removeFromWhitelist(inner) => {
<removeFromWhitelistCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::removeTaskGenerator(inner) => {
<removeTaskGeneratorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::renounceOwnership(inner) => {
<renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::revokeRole(inner) => {
<revokeRoleCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setEpochDurationBlocks(inner) => {
<setEpochDurationBlocksCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::transferOwnership(inner) => {
<transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
}
}
}
#[derive(Clone)]
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Debug, PartialEq, Eq, Hash)]
pub enum OperatorRegistryEpochGovernanceErrors {
#[allow(missing_docs)]
AdminAddressZero(AdminAddressZero),
#[allow(missing_docs)]
AlreadyQueuedForDeregister(AlreadyQueuedForDeregister),
#[allow(missing_docs)]
BootstrapPhaseEnded(BootstrapPhaseEnded),
#[allow(missing_docs)]
DeregisterEpochNotReached(DeregisterEpochNotReached),
#[allow(missing_docs)]
DeregisterNotApproved(DeregisterNotApproved),
#[allow(missing_docs)]
EpochNotReady(EpochNotReady),
#[allow(missing_docs)]
InvalidAddress(InvalidAddress),
#[allow(missing_docs)]
InvalidEpochDuration(InvalidEpochDuration),
#[allow(missing_docs)]
NoPendingChanges(NoPendingChanges),
#[allow(missing_docs)]
NotAdminOrOwner(NotAdminOrOwner),
#[allow(missing_docs)]
NotRegistered(NotRegistered),
#[allow(missing_docs)]
OnlyOperatorRegistry(OnlyOperatorRegistry),
#[allow(missing_docs)]
OperatorRegistryUnset(OperatorRegistryUnset),
}
impl OperatorRegistryEpochGovernanceErrors {
pub const SELECTORS: &'static [[u8; 4usize]] = &[
[14u8, 126u8, 27u8, 23u8],
[26u8, 185u8, 250u8, 134u8],
[57u8, 191u8, 221u8, 181u8],
[123u8, 182u8, 42u8, 33u8],
[128u8, 47u8, 54u8, 84u8],
[128u8, 185u8, 13u8, 205u8],
[149u8, 132u8, 17u8, 70u8],
[153u8, 14u8, 149u8, 230u8],
[164u8, 95u8, 145u8, 106u8],
[168u8, 62u8, 129u8, 186u8],
[191u8, 198u8, 195u8, 55u8],
[209u8, 235u8, 241u8, 226u8],
[230u8, 196u8, 36u8, 123u8],
];
pub const VARIANT_NAMES: &'static [&'static str] = &[
::core::stringify!(AlreadyQueuedForDeregister),
::core::stringify!(BootstrapPhaseEnded),
::core::stringify!(AdminAddressZero),
::core::stringify!(NotAdminOrOwner),
::core::stringify!(NoPendingChanges),
::core::stringify!(DeregisterEpochNotReached),
::core::stringify!(DeregisterNotApproved),
::core::stringify!(EpochNotReady),
::core::stringify!(OnlyOperatorRegistry),
::core::stringify!(OperatorRegistryUnset),
::core::stringify!(NotRegistered),
::core::stringify!(InvalidEpochDuration),
::core::stringify!(InvalidAddress),
];
pub const SIGNATURES: &'static [&'static str] = &[
<AlreadyQueuedForDeregister as alloy_sol_types::SolError>::SIGNATURE,
<BootstrapPhaseEnded as alloy_sol_types::SolError>::SIGNATURE,
<AdminAddressZero as alloy_sol_types::SolError>::SIGNATURE,
<NotAdminOrOwner as alloy_sol_types::SolError>::SIGNATURE,
<NoPendingChanges as alloy_sol_types::SolError>::SIGNATURE,
<DeregisterEpochNotReached as alloy_sol_types::SolError>::SIGNATURE,
<DeregisterNotApproved as alloy_sol_types::SolError>::SIGNATURE,
<EpochNotReady as alloy_sol_types::SolError>::SIGNATURE,
<OnlyOperatorRegistry as alloy_sol_types::SolError>::SIGNATURE,
<OperatorRegistryUnset as alloy_sol_types::SolError>::SIGNATURE,
<NotRegistered as alloy_sol_types::SolError>::SIGNATURE,
<InvalidEpochDuration as alloy_sol_types::SolError>::SIGNATURE,
<InvalidAddress as alloy_sol_types::SolError>::SIGNATURE,
];
#[inline]
pub fn signature_by_selector(
selector: [u8; 4usize],
) -> ::core::option::Option<&'static str> {
match Self::SELECTORS.binary_search(&selector) {
::core::result::Result::Ok(idx) => {
::core::option::Option::Some(Self::SIGNATURES[idx])
}
::core::result::Result::Err(_) => ::core::option::Option::None,
}
}
#[inline]
pub fn name_by_selector(
selector: [u8; 4usize],
) -> ::core::option::Option<&'static str> {
let sig = Self::signature_by_selector(selector)?;
sig.split_once('(').map(|(name, _)| name)
}
}
#[automatically_derived]
impl alloy_sol_types::SolInterface for OperatorRegistryEpochGovernanceErrors {
const NAME: &'static str = "OperatorRegistryEpochGovernanceErrors";
const MIN_DATA_LENGTH: usize = 0usize;
const COUNT: usize = 13usize;
#[inline]
fn selector(&self) -> [u8; 4] {
match self {
Self::AdminAddressZero(_) => {
<AdminAddressZero as alloy_sol_types::SolError>::SELECTOR
}
Self::AlreadyQueuedForDeregister(_) => {
<AlreadyQueuedForDeregister as alloy_sol_types::SolError>::SELECTOR
}
Self::BootstrapPhaseEnded(_) => {
<BootstrapPhaseEnded as alloy_sol_types::SolError>::SELECTOR
}
Self::DeregisterEpochNotReached(_) => {
<DeregisterEpochNotReached as alloy_sol_types::SolError>::SELECTOR
}
Self::DeregisterNotApproved(_) => {
<DeregisterNotApproved as alloy_sol_types::SolError>::SELECTOR
}
Self::EpochNotReady(_) => {
<EpochNotReady as alloy_sol_types::SolError>::SELECTOR
}
Self::InvalidAddress(_) => {
<InvalidAddress as alloy_sol_types::SolError>::SELECTOR
}
Self::InvalidEpochDuration(_) => {
<InvalidEpochDuration as alloy_sol_types::SolError>::SELECTOR
}
Self::NoPendingChanges(_) => {
<NoPendingChanges as alloy_sol_types::SolError>::SELECTOR
}
Self::NotAdminOrOwner(_) => {
<NotAdminOrOwner as alloy_sol_types::SolError>::SELECTOR
}
Self::NotRegistered(_) => {
<NotRegistered as alloy_sol_types::SolError>::SELECTOR
}
Self::OnlyOperatorRegistry(_) => {
<OnlyOperatorRegistry as alloy_sol_types::SolError>::SELECTOR
}
Self::OperatorRegistryUnset(_) => {
<OperatorRegistryUnset 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<OperatorRegistryEpochGovernanceErrors>] = &[
{
fn AlreadyQueuedForDeregister(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<AlreadyQueuedForDeregister as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::AlreadyQueuedForDeregister,
)
}
AlreadyQueuedForDeregister
},
{
fn BootstrapPhaseEnded(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<BootstrapPhaseEnded as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::BootstrapPhaseEnded,
)
}
BootstrapPhaseEnded
},
{
fn AdminAddressZero(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<AdminAddressZero as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceErrors::AdminAddressZero)
}
AdminAddressZero
},
{
fn NotAdminOrOwner(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<NotAdminOrOwner as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceErrors::NotAdminOrOwner)
}
NotAdminOrOwner
},
{
fn NoPendingChanges(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<NoPendingChanges as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceErrors::NoPendingChanges)
}
NoPendingChanges
},
{
fn DeregisterEpochNotReached(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<DeregisterEpochNotReached as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::DeregisterEpochNotReached,
)
}
DeregisterEpochNotReached
},
{
fn DeregisterNotApproved(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<DeregisterNotApproved as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::DeregisterNotApproved,
)
}
DeregisterNotApproved
},
{
fn EpochNotReady(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<EpochNotReady as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceErrors::EpochNotReady)
}
EpochNotReady
},
{
fn OnlyOperatorRegistry(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<OnlyOperatorRegistry as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::OnlyOperatorRegistry,
)
}
OnlyOperatorRegistry
},
{
fn OperatorRegistryUnset(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<OperatorRegistryUnset as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::OperatorRegistryUnset,
)
}
OperatorRegistryUnset
},
{
fn NotRegistered(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<NotRegistered as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceErrors::NotRegistered)
}
NotRegistered
},
{
fn InvalidEpochDuration(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<InvalidEpochDuration as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::InvalidEpochDuration,
)
}
InvalidEpochDuration
},
{
fn InvalidAddress(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<InvalidAddress as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(OperatorRegistryEpochGovernanceErrors::InvalidAddress)
}
InvalidAddress
},
];
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<OperatorRegistryEpochGovernanceErrors>] = &[
{
fn AlreadyQueuedForDeregister(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<AlreadyQueuedForDeregister as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::AlreadyQueuedForDeregister,
)
}
AlreadyQueuedForDeregister
},
{
fn BootstrapPhaseEnded(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<BootstrapPhaseEnded as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::BootstrapPhaseEnded,
)
}
BootstrapPhaseEnded
},
{
fn AdminAddressZero(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<AdminAddressZero as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceErrors::AdminAddressZero)
}
AdminAddressZero
},
{
fn NotAdminOrOwner(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<NotAdminOrOwner as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceErrors::NotAdminOrOwner)
}
NotAdminOrOwner
},
{
fn NoPendingChanges(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<NoPendingChanges as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceErrors::NoPendingChanges)
}
NoPendingChanges
},
{
fn DeregisterEpochNotReached(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<DeregisterEpochNotReached as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::DeregisterEpochNotReached,
)
}
DeregisterEpochNotReached
},
{
fn DeregisterNotApproved(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<DeregisterNotApproved as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::DeregisterNotApproved,
)
}
DeregisterNotApproved
},
{
fn EpochNotReady(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<EpochNotReady as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceErrors::EpochNotReady)
}
EpochNotReady
},
{
fn OnlyOperatorRegistry(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<OnlyOperatorRegistry as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::OnlyOperatorRegistry,
)
}
OnlyOperatorRegistry
},
{
fn OperatorRegistryUnset(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<OperatorRegistryUnset as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::OperatorRegistryUnset,
)
}
OperatorRegistryUnset
},
{
fn NotRegistered(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<NotRegistered as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceErrors::NotRegistered)
}
NotRegistered
},
{
fn InvalidEpochDuration(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<InvalidEpochDuration as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(
OperatorRegistryEpochGovernanceErrors::InvalidEpochDuration,
)
}
InvalidEpochDuration
},
{
fn InvalidAddress(
data: &[u8],
) -> alloy_sol_types::Result<OperatorRegistryEpochGovernanceErrors> {
<InvalidAddress as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(OperatorRegistryEpochGovernanceErrors::InvalidAddress)
}
InvalidAddress
},
];
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::AdminAddressZero(inner) => {
<AdminAddressZero as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::AlreadyQueuedForDeregister(inner) => {
<AlreadyQueuedForDeregister as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::BootstrapPhaseEnded(inner) => {
<BootstrapPhaseEnded as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::DeregisterEpochNotReached(inner) => {
<DeregisterEpochNotReached as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::DeregisterNotApproved(inner) => {
<DeregisterNotApproved as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::EpochNotReady(inner) => {
<EpochNotReady as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::InvalidAddress(inner) => {
<InvalidAddress as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::InvalidEpochDuration(inner) => {
<InvalidEpochDuration as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::NoPendingChanges(inner) => {
<NoPendingChanges as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::NotAdminOrOwner(inner) => {
<NotAdminOrOwner as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::NotRegistered(inner) => {
<NotRegistered as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::OnlyOperatorRegistry(inner) => {
<OnlyOperatorRegistry as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::OperatorRegistryUnset(inner) => {
<OperatorRegistryUnset 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::AdminAddressZero(inner) => {
<AdminAddressZero as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::AlreadyQueuedForDeregister(inner) => {
<AlreadyQueuedForDeregister as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::BootstrapPhaseEnded(inner) => {
<BootstrapPhaseEnded as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::DeregisterEpochNotReached(inner) => {
<DeregisterEpochNotReached as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::DeregisterNotApproved(inner) => {
<DeregisterNotApproved as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::EpochNotReady(inner) => {
<EpochNotReady as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::InvalidAddress(inner) => {
<InvalidAddress as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::InvalidEpochDuration(inner) => {
<InvalidEpochDuration as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::NoPendingChanges(inner) => {
<NoPendingChanges as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::NotAdminOrOwner(inner) => {
<NotAdminOrOwner as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::NotRegistered(inner) => {
<NotRegistered as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::OnlyOperatorRegistry(inner) => {
<OnlyOperatorRegistry as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::OperatorRegistryUnset(inner) => {
<OperatorRegistryUnset as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
}
}
}
#[derive(Clone)]
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Debug, PartialEq, Eq, Hash)]
pub enum OperatorRegistryEpochGovernanceEvents {
#[allow(missing_docs)]
EpochAdvanced(EpochAdvanced),
#[allow(missing_docs)]
EpochDurationBlocksQueued(EpochDurationBlocksQueued),
#[allow(missing_docs)]
Initialized(Initialized),
#[allow(missing_docs)]
OperatorDeregistrationQueued(OperatorDeregistrationQueued),
#[allow(missing_docs)]
OwnershipTransferred(OwnershipTransferred),
#[allow(missing_docs)]
TaskGeneratorAdditionQueued(TaskGeneratorAdditionQueued),
#[allow(missing_docs)]
TaskGeneratorRemovalQueued(TaskGeneratorRemovalQueued),
#[allow(missing_docs)]
WhitelistAdditionQueued(WhitelistAdditionQueued),
#[allow(missing_docs)]
WhitelistRemovalQueued(WhitelistRemovalQueued),
}
impl OperatorRegistryEpochGovernanceEvents {
pub const SELECTORS: &'static [[u8; 32usize]] = &[
[
35u8, 242u8, 61u8, 232u8, 28u8, 148u8, 4u8, 200u8, 39u8, 50u8, 248u8,
67u8, 61u8, 194u8, 77u8, 59u8, 42u8, 72u8, 148u8, 136u8, 71u8, 10u8,
125u8, 119u8, 141u8, 90u8, 48u8, 91u8, 19u8, 217u8, 235u8, 167u8,
],
[
37u8, 93u8, 18u8, 157u8, 99u8, 160u8, 246u8, 112u8, 192u8, 103u8, 98u8,
91u8, 48u8, 84u8, 110u8, 177u8, 124u8, 186u8, 67u8, 74u8, 14u8, 76u8,
214u8, 181u8, 198u8, 9u8, 174u8, 37u8, 238u8, 70u8, 26u8, 140u8,
],
[
127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
],
[
139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
],
[
154u8, 192u8, 205u8, 78u8, 66u8, 221u8, 11u8, 150u8, 167u8, 93u8, 140u8,
118u8, 60u8, 229u8, 198u8, 237u8, 13u8, 228u8, 143u8, 110u8, 243u8, 28u8,
70u8, 161u8, 182u8, 70u8, 160u8, 174u8, 249u8, 140u8, 84u8, 28u8,
],
[
203u8, 46u8, 89u8, 166u8, 67u8, 138u8, 176u8, 226u8, 49u8, 91u8, 138u8,
228u8, 253u8, 40u8, 32u8, 138u8, 114u8, 30u8, 143u8, 191u8, 205u8, 207u8,
66u8, 37u8, 153u8, 65u8, 201u8, 117u8, 77u8, 64u8, 142u8, 238u8,
],
[
209u8, 59u8, 207u8, 109u8, 83u8, 166u8, 248u8, 188u8, 162u8, 108u8,
181u8, 63u8, 216u8, 32u8, 145u8, 123u8, 186u8, 102u8, 244u8, 111u8, 72u8,
71u8, 145u8, 127u8, 80u8, 26u8, 41u8, 215u8, 221u8, 107u8, 174u8, 96u8,
],
[
216u8, 80u8, 93u8, 106u8, 213u8, 115u8, 64u8, 90u8, 158u8, 96u8, 185u8,
62u8, 44u8, 50u8, 128u8, 161u8, 232u8, 225u8, 254u8, 160u8, 123u8, 68u8,
5u8, 130u8, 230u8, 69u8, 121u8, 116u8, 159u8, 177u8, 10u8, 24u8,
],
[
228u8, 142u8, 15u8, 16u8, 233u8, 34u8, 164u8, 125u8, 245u8, 189u8, 74u8,
210u8, 152u8, 91u8, 155u8, 149u8, 30u8, 242u8, 249u8, 52u8, 23u8, 15u8,
113u8, 84u8, 115u8, 66u8, 151u8, 152u8, 174u8, 146u8, 44u8, 77u8,
],
];
pub const VARIANT_NAMES: &'static [&'static str] = &[
::core::stringify!(WhitelistAdditionQueued),
::core::stringify!(TaskGeneratorRemovalQueued),
::core::stringify!(Initialized),
::core::stringify!(OwnershipTransferred),
::core::stringify!(WhitelistRemovalQueued),
::core::stringify!(OperatorDeregistrationQueued),
::core::stringify!(EpochDurationBlocksQueued),
::core::stringify!(EpochAdvanced),
::core::stringify!(TaskGeneratorAdditionQueued),
];
pub const SIGNATURES: &'static [&'static str] = &[
<WhitelistAdditionQueued as alloy_sol_types::SolEvent>::SIGNATURE,
<TaskGeneratorRemovalQueued as alloy_sol_types::SolEvent>::SIGNATURE,
<Initialized as alloy_sol_types::SolEvent>::SIGNATURE,
<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE,
<WhitelistRemovalQueued as alloy_sol_types::SolEvent>::SIGNATURE,
<OperatorDeregistrationQueued as alloy_sol_types::SolEvent>::SIGNATURE,
<EpochDurationBlocksQueued as alloy_sol_types::SolEvent>::SIGNATURE,
<EpochAdvanced as alloy_sol_types::SolEvent>::SIGNATURE,
<TaskGeneratorAdditionQueued as alloy_sol_types::SolEvent>::SIGNATURE,
];
#[inline]
pub fn signature_by_selector(
selector: [u8; 32usize],
) -> ::core::option::Option<&'static str> {
match Self::SELECTORS.binary_search(&selector) {
::core::result::Result::Ok(idx) => {
::core::option::Option::Some(Self::SIGNATURES[idx])
}
::core::result::Result::Err(_) => ::core::option::Option::None,
}
}
#[inline]
pub fn name_by_selector(
selector: [u8; 32usize],
) -> ::core::option::Option<&'static str> {
let sig = Self::signature_by_selector(selector)?;
sig.split_once('(').map(|(name, _)| name)
}
}
#[automatically_derived]
impl alloy_sol_types::SolEventInterface for OperatorRegistryEpochGovernanceEvents {
const NAME: &'static str = "OperatorRegistryEpochGovernanceEvents";
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(<EpochAdvanced as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<EpochAdvanced as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::EpochAdvanced)
}
Some(
<EpochDurationBlocksQueued as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<EpochDurationBlocksQueued as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::EpochDurationBlocksQueued)
}
Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::Initialized)
}
Some(
<OperatorDeregistrationQueued as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<OperatorDeregistrationQueued as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::OperatorDeregistrationQueued)
}
Some(
<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::OwnershipTransferred)
}
Some(
<TaskGeneratorAdditionQueued as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<TaskGeneratorAdditionQueued as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::TaskGeneratorAdditionQueued)
}
Some(
<TaskGeneratorRemovalQueued as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<TaskGeneratorRemovalQueued as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::TaskGeneratorRemovalQueued)
}
Some(
<WhitelistAdditionQueued as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<WhitelistAdditionQueued as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::WhitelistAdditionQueued)
}
Some(
<WhitelistRemovalQueued as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<WhitelistRemovalQueued as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::WhitelistRemovalQueued)
}
_ => {
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 OperatorRegistryEpochGovernanceEvents {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
match self {
Self::EpochAdvanced(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::EpochDurationBlocksQueued(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::Initialized(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::OperatorDeregistrationQueued(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::OwnershipTransferred(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::TaskGeneratorAdditionQueued(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::TaskGeneratorRemovalQueued(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::WhitelistAdditionQueued(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::WhitelistRemovalQueued(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
}
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
match self {
Self::EpochAdvanced(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::EpochDurationBlocksQueued(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::Initialized(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::OperatorDeregistrationQueued(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::OwnershipTransferred(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::TaskGeneratorAdditionQueued(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::TaskGeneratorRemovalQueued(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::WhitelistAdditionQueued(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::WhitelistRemovalQueued(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,
) -> OperatorRegistryEpochGovernanceInstance<P, N> {
OperatorRegistryEpochGovernanceInstance::<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<OperatorRegistryEpochGovernanceInstance<P, N>>,
> {
OperatorRegistryEpochGovernanceInstance::<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> {
OperatorRegistryEpochGovernanceInstance::<P, N>::deploy_builder(__provider)
}
#[derive(Clone)]
pub struct OperatorRegistryEpochGovernanceInstance<
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 OperatorRegistryEpochGovernanceInstance<P, N> {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
f.debug_tuple("OperatorRegistryEpochGovernanceInstance")
.field(&self.address)
.finish()
}
}
impl<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
> OperatorRegistryEpochGovernanceInstance<P, N> {
#[inline]
pub const fn new(
address: alloy_sol_types::private::Address,
__provider: P,
) -> Self {
Self {
address,
provider: __provider,
_network: ::core::marker::PhantomData,
}
}
#[inline]
pub async fn deploy(
__provider: P,
) -> alloy_contract::Result<OperatorRegistryEpochGovernanceInstance<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> OperatorRegistryEpochGovernanceInstance<&P, N> {
#[inline]
pub fn with_cloned_provider(
self,
) -> OperatorRegistryEpochGovernanceInstance<P, N> {
OperatorRegistryEpochGovernanceInstance {
address: self.address,
provider: ::core::clone::Clone::clone(&self.provider),
_network: ::core::marker::PhantomData,
}
}
}
impl<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
> OperatorRegistryEpochGovernanceInstance<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 ADMIN_ROLE(
&self,
) -> alloy_contract::SolCallBuilder<&P, ADMIN_ROLECall, N> {
self.call_builder(&ADMIN_ROLECall)
}
pub fn addMultipleToTaskGenerators(
&self,
generators: alloy::sol_types::private::Vec<
alloy::sol_types::private::Address,
>,
) -> alloy_contract::SolCallBuilder<&P, addMultipleToTaskGeneratorsCall, N> {
self.call_builder(
&addMultipleToTaskGeneratorsCall {
generators,
},
)
}
pub fn addMultipleToWhitelist(
&self,
operators: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
) -> alloy_contract::SolCallBuilder<&P, addMultipleToWhitelistCall, N> {
self.call_builder(
&addMultipleToWhitelistCall {
operators,
},
)
}
pub fn addTaskGenerator(
&self,
generator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, addTaskGeneratorCall, N> {
self.call_builder(&addTaskGeneratorCall { generator })
}
pub fn addToWhitelist(
&self,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, addToWhitelistCall, N> {
self.call_builder(&addToWhitelistCall { operator })
}
pub fn applyPendingChanges(
&self,
) -> alloy_contract::SolCallBuilder<&P, applyPendingChangesCall, N> {
self.call_builder(&applyPendingChangesCall)
}
pub fn approvedDeregisterEpoch(
&self,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, approvedDeregisterEpochCall, N> {
self.call_builder(
&approvedDeregisterEpochCall {
operator,
},
)
}
pub fn cancelDeregisterApproval(
&self,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, cancelDeregisterApprovalCall, N> {
self.call_builder(
&cancelDeregisterApprovalCall {
operator,
},
)
}
pub fn consumeDeregisterApproval(
&self,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, consumeDeregisterApprovalCall, N> {
self.call_builder(
&consumeDeregisterApprovalCall {
operator,
},
)
}
pub fn currentEpoch(
&self,
) -> alloy_contract::SolCallBuilder<&P, currentEpochCall, N> {
self.call_builder(¤tEpochCall)
}
pub fn epochDurationBlocks(
&self,
) -> alloy_contract::SolCallBuilder<&P, epochDurationBlocksCall, N> {
self.call_builder(&epochDurationBlocksCall)
}
pub fn epochStartBlock(
&self,
) -> alloy_contract::SolCallBuilder<&P, epochStartBlockCall, N> {
self.call_builder(&epochStartBlockCall)
}
pub fn grantRole(
&self,
role: alloy::sol_types::private::FixedBytes<32>,
account: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, grantRoleCall, N> {
self.call_builder(&grantRoleCall { role, account })
}
pub fn hasRole(
&self,
role: alloy::sol_types::private::FixedBytes<32>,
account: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, hasRoleCall, N> {
self.call_builder(&hasRoleCall { role, account })
}
pub fn initialize(
&self,
_operatorRegistry: alloy::sol_types::private::Address,
_owner: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> {
self.call_builder(
&initializeCall {
_operatorRegistry,
_owner,
},
)
}
pub fn initializeEpochs(
&self,
_initialEpochDurationBlocks: u32,
) -> alloy_contract::SolCallBuilder<&P, initializeEpochsCall, N> {
self.call_builder(
&initializeEpochsCall {
_initialEpochDurationBlocks,
},
)
}
pub fn initializeV2(
&self,
admin: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, initializeV2Call, N> {
self.call_builder(&initializeV2Call { admin })
}
pub fn isEpochAdvanceReady(
&self,
) -> alloy_contract::SolCallBuilder<&P, isEpochAdvanceReadyCall, N> {
self.call_builder(&isEpochAdvanceReadyCall)
}
pub fn nextEpochAdvanceAt(
&self,
) -> alloy_contract::SolCallBuilder<&P, nextEpochAdvanceAtCall, N> {
self.call_builder(&nextEpochAdvanceAtCall)
}
pub fn operatorRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, operatorRegistryCall, N> {
self.call_builder(&operatorRegistryCall)
}
pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
self.call_builder(&ownerCall)
}
pub fn pendingDeregistersForEpoch(
&self,
_0: u32,
) -> alloy_contract::SolCallBuilder<&P, pendingDeregistersForEpochCall, N> {
self.call_builder(&pendingDeregistersForEpochCall(_0))
}
pub fn pendingEpochDurationBlocks(
&self,
) -> alloy_contract::SolCallBuilder<&P, pendingEpochDurationBlocksCall, N> {
self.call_builder(&pendingEpochDurationBlocksCall)
}
pub fn pendingTaskGeneratorAdditions(
&self,
epoch: u32,
) -> alloy_contract::SolCallBuilder<&P, pendingTaskGeneratorAdditionsCall, N> {
self.call_builder(
&pendingTaskGeneratorAdditionsCall {
epoch,
},
)
}
pub fn pendingTaskGeneratorRemovals(
&self,
epoch: u32,
) -> alloy_contract::SolCallBuilder<&P, pendingTaskGeneratorRemovalsCall, N> {
self.call_builder(
&pendingTaskGeneratorRemovalsCall {
epoch,
},
)
}
pub fn pendingWhitelistAdditions(
&self,
epoch: u32,
) -> alloy_contract::SolCallBuilder<&P, pendingWhitelistAdditionsCall, N> {
self.call_builder(
&pendingWhitelistAdditionsCall {
epoch,
},
)
}
pub fn pendingWhitelistRemovals(
&self,
epoch: u32,
) -> alloy_contract::SolCallBuilder<&P, pendingWhitelistRemovalsCall, N> {
self.call_builder(
&pendingWhitelistRemovalsCall {
epoch,
},
)
}
pub fn queueAddMultipleToTaskGenerators(
&self,
generators: alloy::sol_types::private::Vec<
alloy::sol_types::private::Address,
>,
) -> alloy_contract::SolCallBuilder<
&P,
queueAddMultipleToTaskGeneratorsCall,
N,
> {
self.call_builder(
&queueAddMultipleToTaskGeneratorsCall {
generators,
},
)
}
pub fn queueAddMultipleToWhitelist(
&self,
operators: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
) -> alloy_contract::SolCallBuilder<&P, queueAddMultipleToWhitelistCall, N> {
self.call_builder(
&queueAddMultipleToWhitelistCall {
operators,
},
)
}
pub fn queueAddTaskGenerator(
&self,
generator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, queueAddTaskGeneratorCall, N> {
self.call_builder(
&queueAddTaskGeneratorCall {
generator,
},
)
}
pub fn queueAddToWhitelist(
&self,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, queueAddToWhitelistCall, N> {
self.call_builder(
&queueAddToWhitelistCall {
operator,
},
)
}
pub fn queueDeregister(
&self,
) -> alloy_contract::SolCallBuilder<&P, queueDeregisterCall, N> {
self.call_builder(&queueDeregisterCall)
}
pub fn queueRemoveFromWhitelist(
&self,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, queueRemoveFromWhitelistCall, N> {
self.call_builder(
&queueRemoveFromWhitelistCall {
operator,
},
)
}
pub fn queueRemoveTaskGenerator(
&self,
generator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, queueRemoveTaskGeneratorCall, N> {
self.call_builder(
&queueRemoveTaskGeneratorCall {
generator,
},
)
}
pub fn removeFromWhitelist(
&self,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, removeFromWhitelistCall, N> {
self.call_builder(
&removeFromWhitelistCall {
operator,
},
)
}
pub fn removeTaskGenerator(
&self,
generator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, removeTaskGeneratorCall, N> {
self.call_builder(
&removeTaskGeneratorCall {
generator,
},
)
}
pub fn renounceOwnership(
&self,
) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
self.call_builder(&renounceOwnershipCall)
}
pub fn revokeRole(
&self,
role: alloy::sol_types::private::FixedBytes<32>,
account: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, revokeRoleCall, N> {
self.call_builder(&revokeRoleCall { role, account })
}
pub fn setEpochDurationBlocks(
&self,
newDuration: u32,
) -> alloy_contract::SolCallBuilder<&P, setEpochDurationBlocksCall, N> {
self.call_builder(
&setEpochDurationBlocksCall {
newDuration,
},
)
}
pub fn transferOwnership(
&self,
newOwner: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
self.call_builder(&transferOwnershipCall { newOwner })
}
}
impl<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
> OperatorRegistryEpochGovernanceInstance<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 EpochAdvanced_filter(
&self,
) -> alloy_contract::Event<&P, EpochAdvanced, N> {
self.event_filter::<EpochAdvanced>()
}
pub fn EpochDurationBlocksQueued_filter(
&self,
) -> alloy_contract::Event<&P, EpochDurationBlocksQueued, N> {
self.event_filter::<EpochDurationBlocksQueued>()
}
pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
self.event_filter::<Initialized>()
}
pub fn OperatorDeregistrationQueued_filter(
&self,
) -> alloy_contract::Event<&P, OperatorDeregistrationQueued, N> {
self.event_filter::<OperatorDeregistrationQueued>()
}
pub fn OwnershipTransferred_filter(
&self,
) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
self.event_filter::<OwnershipTransferred>()
}
pub fn TaskGeneratorAdditionQueued_filter(
&self,
) -> alloy_contract::Event<&P, TaskGeneratorAdditionQueued, N> {
self.event_filter::<TaskGeneratorAdditionQueued>()
}
pub fn TaskGeneratorRemovalQueued_filter(
&self,
) -> alloy_contract::Event<&P, TaskGeneratorRemovalQueued, N> {
self.event_filter::<TaskGeneratorRemovalQueued>()
}
pub fn WhitelistAdditionQueued_filter(
&self,
) -> alloy_contract::Event<&P, WhitelistAdditionQueued, N> {
self.event_filter::<WhitelistAdditionQueued>()
}
pub fn WhitelistRemovalQueued_filter(
&self,
) -> alloy_contract::Event<&P, WhitelistRemovalQueued, N> {
self.event_filter::<WhitelistRemovalQueued>()
}
}
}