#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style,
clippy::empty_structs_with_brackets
)]
pub mod IOperatorStatusRegistry {
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 StatusCode(u8);
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::private::SolTypeValue<StatusCode> for u8 {
#[inline]
fn stv_to_tokens(
&self,
) -> <alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::Token<'_> {
alloy_sol_types::private::SolTypeValue::<
alloy::sol_types::sol_data::Uint<8>,
>::stv_to_tokens(self)
}
#[inline]
fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::tokenize(self)
.0
}
#[inline]
fn stv_abi_encode_packed_to(
&self,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
}
#[inline]
fn stv_abi_packed_encoded_size(&self) -> usize {
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::abi_encoded_size(self)
}
}
impl StatusCode {
pub const NAME: &'static str = stringify!(@ name);
#[inline]
pub const fn from_underlying(value: u8) -> Self {
Self(value)
}
#[inline]
pub const fn into_underlying(self) -> u8 {
self.0
}
#[inline]
pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
<Self as alloy_sol_types::SolType>::abi_encode(&self.0)
}
#[inline]
pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
<Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
}
}
#[automatically_derived]
impl From<u8> for StatusCode {
fn from(value: u8) -> Self {
Self::from_underlying(value)
}
}
#[automatically_derived]
impl From<StatusCode> for u8 {
fn from(value: StatusCode) -> Self {
value.into_underlying()
}
}
#[automatically_derived]
impl alloy_sol_types::SolType for StatusCode {
type RustType = u8;
type Token<'a> = <alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::Token<'a>;
const SOL_NAME: &'static str = Self::NAME;
const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::ENCODED_SIZE;
const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
#[inline]
fn valid_token(token: &Self::Token<'_>) -> bool {
Self::type_check(token).is_ok()
}
#[inline]
fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::type_check(token)
}
#[inline]
fn detokenize(token: Self::Token<'_>) -> Self::RustType {
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::detokenize(token)
}
}
#[automatically_derived]
impl alloy_sol_types::EventTopic for StatusCode {
#[inline]
fn topic_preimage_length(rust: &Self::RustType) -> usize {
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
}
#[inline]
fn encode_topic_preimage(
rust: &Self::RustType,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
}
#[inline]
fn encode_topic(
rust: &Self::RustType,
) -> alloy_sol_types::abi::token::WordToken {
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::EventTopic>::encode_topic(rust)
}
}
};
#[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 HeartbeatConfig {
#[allow(missing_docs)]
pub interval: u64,
#[allow(missing_docs)]
pub maxMissed: u8,
#[allow(missing_docs)]
pub customMetrics: 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::Uint<64>,
alloy::sol_types::sol_data::Uint<8>,
alloy::sol_types::sol_data::Bool,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, u8, 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<HeartbeatConfig> for UnderlyingRustTuple<'_> {
fn from(value: HeartbeatConfig) -> Self {
(value.interval, value.maxMissed, value.customMetrics)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for HeartbeatConfig {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
interval: tuple.0,
maxMissed: tuple.1,
customMetrics: tuple.2,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolValue for HeartbeatConfig {
type SolType = Self;
}
#[automatically_derived]
impl alloy_sol_types::private::SolTypeValue<Self> for HeartbeatConfig {
#[inline]
fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
(
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.interval),
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::tokenize(&self.maxMissed),
<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
&self.customMetrics,
),
)
}
#[inline]
fn stv_abi_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
}
#[inline]
fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
<Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
}
#[inline]
fn stv_abi_encode_packed_to(
&self,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
}
#[inline]
fn stv_abi_packed_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolType for HeartbeatConfig {
type RustType = Self;
type Token<'a> = <UnderlyingSolTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::ENCODED_SIZE;
const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
#[inline]
fn valid_token(token: &Self::Token<'_>) -> bool {
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
}
#[inline]
fn detokenize(token: Self::Token<'_>) -> Self::RustType {
let tuple = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::detokenize(token);
<Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolStruct for HeartbeatConfig {
const NAME: &'static str = "HeartbeatConfig";
#[inline]
fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
alloy_sol_types::private::Cow::Borrowed(
"HeartbeatConfig(uint64 interval,uint8 maxMissed,bool customMetrics)",
)
}
#[inline]
fn eip712_components() -> alloy_sol_types::private::Vec<
alloy_sol_types::private::Cow<'static, str>,
> {
alloy_sol_types::private::Vec::new()
}
#[inline]
fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
<Self as alloy_sol_types::SolStruct>::eip712_root_type()
}
#[inline]
fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
[
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::eip712_data_word(&self.interval)
.0,
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::eip712_data_word(&self.maxMissed)
.0,
<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
&self.customMetrics,
)
.0,
]
.concat()
}
}
#[automatically_derived]
impl alloy_sol_types::EventTopic for HeartbeatConfig {
#[inline]
fn topic_preimage_length(rust: &Self::RustType) -> usize {
0usize
+ <alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.interval,
)
+ <alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.maxMissed,
)
+ <alloy::sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.customMetrics,
)
}
#[inline]
fn encode_topic_preimage(
rust: &Self::RustType,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
out.reserve(
<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
);
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.interval,
out,
);
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.maxMissed,
out,
);
<alloy::sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.customMetrics,
out,
);
}
#[inline]
fn encode_topic(
rust: &Self::RustType,
) -> alloy_sol_types::abi::token::WordToken {
let mut out = alloy_sol_types::private::Vec::new();
<Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
rust,
&mut out,
);
alloy_sol_types::abi::token::WordToken(
alloy_sol_types::private::keccak256(out),
)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct MetricDefinition {
#[allow(missing_docs)]
pub name: alloy::sol_types::private::String,
#[allow(missing_docs)]
pub minValue: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub maxValue: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub required: 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::String,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Bool,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::String,
alloy::sol_types::private::primitives::aliases::U256,
alloy::sol_types::private::primitives::aliases::U256,
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<MetricDefinition> for UnderlyingRustTuple<'_> {
fn from(value: MetricDefinition) -> Self {
(value.name, value.minValue, value.maxValue, value.required)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for MetricDefinition {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
name: tuple.0,
minValue: tuple.1,
maxValue: tuple.2,
required: tuple.3,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolValue for MetricDefinition {
type SolType = Self;
}
#[automatically_derived]
impl alloy_sol_types::private::SolTypeValue<Self> for MetricDefinition {
#[inline]
fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
(
<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.name,
),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self.minValue),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self.maxValue),
<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
&self.required,
),
)
}
#[inline]
fn stv_abi_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
}
#[inline]
fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
<Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
}
#[inline]
fn stv_abi_encode_packed_to(
&self,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
}
#[inline]
fn stv_abi_packed_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolType for MetricDefinition {
type RustType = Self;
type Token<'a> = <UnderlyingSolTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::ENCODED_SIZE;
const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
#[inline]
fn valid_token(token: &Self::Token<'_>) -> bool {
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
}
#[inline]
fn detokenize(token: Self::Token<'_>) -> Self::RustType {
let tuple = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::detokenize(token);
<Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolStruct for MetricDefinition {
const NAME: &'static str = "MetricDefinition";
#[inline]
fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
alloy_sol_types::private::Cow::Borrowed(
"MetricDefinition(string name,uint256 minValue,uint256 maxValue,bool required)",
)
}
#[inline]
fn eip712_components() -> alloy_sol_types::private::Vec<
alloy_sol_types::private::Cow<'static, str>,
> {
alloy_sol_types::private::Vec::new()
}
#[inline]
fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
<Self as alloy_sol_types::SolStruct>::eip712_root_type()
}
#[inline]
fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
[
<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
&self.name,
)
.0,
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::eip712_data_word(&self.minValue)
.0,
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::eip712_data_word(&self.maxValue)
.0,
<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::eip712_data_word(
&self.required,
)
.0,
]
.concat()
}
}
#[automatically_derived]
impl alloy_sol_types::EventTopic for MetricDefinition {
#[inline]
fn topic_preimage_length(rust: &Self::RustType) -> usize {
0usize
+ <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.name,
)
+ <alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.minValue,
)
+ <alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.maxValue,
)
+ <alloy::sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.required,
)
}
#[inline]
fn encode_topic_preimage(
rust: &Self::RustType,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
out.reserve(
<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
);
<alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.name,
out,
);
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.minValue,
out,
);
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.maxValue,
out,
);
<alloy::sol_types::sol_data::Bool as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.required,
out,
);
}
#[inline]
fn encode_topic(
rust: &Self::RustType,
) -> alloy_sol_types::abi::token::WordToken {
let mut out = alloy_sol_types::private::Vec::new();
<Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
rust,
&mut out,
);
alloy_sol_types::abi::token::WordToken(
alloy_sol_types::private::keccak256(out),
)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct OperatorState {
#[allow(missing_docs)]
pub lastHeartbeat: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub consecutiveBeats: u64,
#[allow(missing_docs)]
pub missedBeats: u8,
#[allow(missing_docs)]
pub status: <StatusCode as alloy::sol_types::SolType>::RustType,
#[allow(missing_docs)]
pub lastMetricsHash: 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> = (
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Uint<8>,
StatusCode,
alloy::sol_types::sol_data::FixedBytes<32>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::primitives::aliases::U256,
u64,
u8,
<StatusCode as alloy::sol_types::SolType>::RustType,
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<OperatorState> for UnderlyingRustTuple<'_> {
fn from(value: OperatorState) -> Self {
(
value.lastHeartbeat,
value.consecutiveBeats,
value.missedBeats,
value.status,
value.lastMetricsHash,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorState {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
lastHeartbeat: tuple.0,
consecutiveBeats: tuple.1,
missedBeats: tuple.2,
status: tuple.3,
lastMetricsHash: tuple.4,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolValue for OperatorState {
type SolType = Self;
}
#[automatically_derived]
impl alloy_sol_types::private::SolTypeValue<Self> for OperatorState {
#[inline]
fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
(
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self.lastHeartbeat),
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.consecutiveBeats),
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::tokenize(&self.missedBeats),
<StatusCode as alloy_sol_types::SolType>::tokenize(&self.status),
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.lastMetricsHash),
)
}
#[inline]
fn stv_abi_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
}
#[inline]
fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
<Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
}
#[inline]
fn stv_abi_encode_packed_to(
&self,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
}
#[inline]
fn stv_abi_packed_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolType for OperatorState {
type RustType = Self;
type Token<'a> = <UnderlyingSolTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::ENCODED_SIZE;
const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
#[inline]
fn valid_token(token: &Self::Token<'_>) -> bool {
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
}
#[inline]
fn detokenize(token: Self::Token<'_>) -> Self::RustType {
let tuple = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::detokenize(token);
<Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolStruct for OperatorState {
const NAME: &'static str = "OperatorState";
#[inline]
fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
alloy_sol_types::private::Cow::Borrowed(
"OperatorState(uint256 lastHeartbeat,uint64 consecutiveBeats,uint8 missedBeats,uint8 status,bytes32 lastMetricsHash)",
)
}
#[inline]
fn eip712_components() -> alloy_sol_types::private::Vec<
alloy_sol_types::private::Cow<'static, str>,
> {
alloy_sol_types::private::Vec::new()
}
#[inline]
fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
<Self as alloy_sol_types::SolStruct>::eip712_root_type()
}
#[inline]
fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
[
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::eip712_data_word(&self.lastHeartbeat)
.0,
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::eip712_data_word(
&self.consecutiveBeats,
)
.0,
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::eip712_data_word(&self.missedBeats)
.0,
<StatusCode as alloy_sol_types::SolType>::eip712_data_word(
&self.status,
)
.0,
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::eip712_data_word(
&self.lastMetricsHash,
)
.0,
]
.concat()
}
}
#[automatically_derived]
impl alloy_sol_types::EventTopic for OperatorState {
#[inline]
fn topic_preimage_length(rust: &Self::RustType) -> usize {
0usize
+ <alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.lastHeartbeat,
)
+ <alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.consecutiveBeats,
)
+ <alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.missedBeats,
)
+ <StatusCode as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.status,
)
+ <alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.lastMetricsHash,
)
}
#[inline]
fn encode_topic_preimage(
rust: &Self::RustType,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
out.reserve(
<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
);
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.lastHeartbeat,
out,
);
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.consecutiveBeats,
out,
);
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.missedBeats,
out,
);
<StatusCode as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.status,
out,
);
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.lastMetricsHash,
out,
);
}
#[inline]
fn encode_topic(
rust: &Self::RustType,
) -> alloy_sol_types::abi::token::WordToken {
let mut out = alloy_sol_types::private::Vec::new();
<Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
rust,
&mut out,
);
alloy_sol_types::abi::token::WordToken(
alloy_sol_types::private::keccak256(out),
)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addMetricDefinitionCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[allow(missing_docs)]
pub name: alloy::sol_types::private::String,
#[allow(missing_docs)]
pub minValue: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub maxValue: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub required: bool,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addMetricDefinitionReturn {}
#[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::String,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Bool,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
u64,
alloy::sol_types::private::String,
alloy::sol_types::private::primitives::aliases::U256,
alloy::sol_types::private::primitives::aliases::U256,
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<addMetricDefinitionCall>
for UnderlyingRustTuple<'_> {
fn from(value: addMetricDefinitionCall) -> Self {
(
value.serviceId,
value.name,
value.minValue,
value.maxValue,
value.required,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for addMetricDefinitionCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
name: tuple.1,
minValue: tuple.2,
maxValue: tuple.3,
required: tuple.4,
}
}
}
}
{
#[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<addMetricDefinitionReturn>
for UnderlyingRustTuple<'_> {
fn from(value: addMetricDefinitionReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for addMetricDefinitionReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl addMetricDefinitionReturn {
fn _tokenize(
&self,
) -> <addMetricDefinitionCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for addMetricDefinitionCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::String,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Bool,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = addMetricDefinitionReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "addMetricDefinition(uint64,string,uint256,uint256,bool)";
const SELECTOR: [u8; 4] = [174u8, 71u8, 10u8, 133u8];
#[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.serviceId),
<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.name,
),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self.minValue),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self.maxValue),
<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
&self.required,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
addMetricDefinitionReturn::_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 configureHeartbeatCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[allow(missing_docs)]
pub interval: u64,
#[allow(missing_docs)]
pub maxMissed: u8,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct configureHeartbeatReturn {}
#[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<64>,
alloy::sol_types::sol_data::Uint<8>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, u64, u8);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<configureHeartbeatCall>
for UnderlyingRustTuple<'_> {
fn from(value: configureHeartbeatCall) -> Self {
(value.serviceId, value.interval, value.maxMissed)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for configureHeartbeatCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
interval: tuple.1,
maxMissed: tuple.2,
}
}
}
}
{
#[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<configureHeartbeatReturn>
for UnderlyingRustTuple<'_> {
fn from(value: configureHeartbeatReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for configureHeartbeatReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl configureHeartbeatReturn {
fn _tokenize(
&self,
) -> <configureHeartbeatCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for configureHeartbeatCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Uint<8>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = configureHeartbeatReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "configureHeartbeat(uint64,uint64,uint8)";
const SELECTOR: [u8; 4] = [185u8, 159u8, 103u8, 89u8];
#[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.serviceId),
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.interval),
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::tokenize(&self.maxMissed),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
configureHeartbeatReturn::_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 deregisterOperatorCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[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 deregisterOperatorReturn {}
#[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::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, 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<deregisterOperatorCall>
for UnderlyingRustTuple<'_> {
fn from(value: deregisterOperatorCall) -> Self {
(value.serviceId, value.operator)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for deregisterOperatorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
operator: 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<deregisterOperatorReturn>
for UnderlyingRustTuple<'_> {
fn from(value: deregisterOperatorReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for deregisterOperatorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl deregisterOperatorReturn {
fn _tokenize(
&self,
) -> <deregisterOperatorCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for deregisterOperatorCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = deregisterOperatorReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "deregisterOperator(uint64,address)";
const SELECTOR: [u8; 4] = [255u8, 207u8, 8u8, 240u8];
#[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.serviceId),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
deregisterOperatorReturn::_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 enableCustomMetricsCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[allow(missing_docs)]
pub enabled: bool,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct enableCustomMetricsReturn {}
#[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::Bool,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, 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<enableCustomMetricsCall>
for UnderlyingRustTuple<'_> {
fn from(value: enableCustomMetricsCall) -> Self {
(value.serviceId, value.enabled)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for enableCustomMetricsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
enabled: 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<enableCustomMetricsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: enableCustomMetricsReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for enableCustomMetricsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl enableCustomMetricsReturn {
fn _tokenize(
&self,
) -> <enableCustomMetricsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for enableCustomMetricsCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Bool,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = enableCustomMetricsReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "enableCustomMetrics(uint64,bool)";
const SELECTOR: [u8; 4] = [249u8, 16u8, 127u8, 59u8];
#[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.serviceId),
<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
&self.enabled,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
enableCustomMetricsReturn::_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 getHeartbeatConfigCall {
#[allow(missing_docs)]
pub serviceId: u64,
}
#[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 getHeartbeatConfigReturn {
#[allow(missing_docs)]
pub _0: <HeartbeatConfig as alloy::sol_types::SolType>::RustType,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[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<getHeartbeatConfigCall>
for UnderlyingRustTuple<'_> {
fn from(value: getHeartbeatConfigCall) -> Self {
(value.serviceId,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getHeartbeatConfigCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { serviceId: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (HeartbeatConfig,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
<HeartbeatConfig as alloy::sol_types::SolType>::RustType,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getHeartbeatConfigReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getHeartbeatConfigReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getHeartbeatConfigReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getHeartbeatConfigCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<64>,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = <HeartbeatConfig as alloy::sol_types::SolType>::RustType;
type ReturnTuple<'a> = (HeartbeatConfig,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getHeartbeatConfig(uint64)";
const SELECTOR: [u8; 4] = [7u8, 88u8, 35u8, 111u8];
#[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.serviceId),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(<HeartbeatConfig 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: getHeartbeatConfigReturn = 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: getHeartbeatConfigReturn = 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 getLastHeartbeatCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[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 getLastHeartbeatReturn {
#[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> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, 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<getLastHeartbeatCall>
for UnderlyingRustTuple<'_> {
fn from(value: getLastHeartbeatCall) -> Self {
(value.serviceId, value.operator)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getLastHeartbeatCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
operator: tuple.1,
}
}
}
}
{
#[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<getLastHeartbeatReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getLastHeartbeatReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getLastHeartbeatReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getLastHeartbeatCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::primitives::aliases::U256;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getLastHeartbeat(uint64,address)";
const SELECTOR: [u8; 4] = [12u8, 118u8, 105u8, 122u8];
#[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.serviceId),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getLastHeartbeatReturn = 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: getLastHeartbeatReturn = 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 getMetricDefinitionsCall {
#[allow(missing_docs)]
pub serviceId: u64,
}
#[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 getMetricDefinitionsReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Vec<
<MetricDefinition as alloy::sol_types::SolType>::RustType,
>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[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<getMetricDefinitionsCall>
for UnderlyingRustTuple<'_> {
fn from(value: getMetricDefinitionsCall) -> Self {
(value.serviceId,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getMetricDefinitionsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { serviceId: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Array<MetricDefinition>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Vec<
<MetricDefinition as alloy::sol_types::SolType>::RustType,
>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getMetricDefinitionsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getMetricDefinitionsReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getMetricDefinitionsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getMetricDefinitionsCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<64>,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Vec<
<MetricDefinition as alloy::sol_types::SolType>::RustType,
>;
type ReturnTuple<'a> = (
alloy::sol_types::sol_data::Array<MetricDefinition>,
);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getMetricDefinitions(uint64)";
const SELECTOR: [u8; 4] = [193u8, 239u8, 157u8, 223u8];
#[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.serviceId),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Array<
MetricDefinition,
> 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: getMetricDefinitionsReturn = 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: getMetricDefinitionsReturn = 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 getMetricValueCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub metricName: alloy::sol_types::private::String,
}
#[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 getMetricValueReturn {
#[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> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::String,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
u64,
alloy::sol_types::private::Address,
alloy::sol_types::private::String,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getMetricValueCall> for UnderlyingRustTuple<'_> {
fn from(value: getMetricValueCall) -> Self {
(value.serviceId, value.operator, value.metricName)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMetricValueCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
operator: tuple.1,
metricName: tuple.2,
}
}
}
}
{
#[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<getMetricValueReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getMetricValueReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getMetricValueReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getMetricValueCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::String,
);
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 = "getMetricValue(uint64,address,string)";
const SELECTOR: [u8; 4] = [213u8, 81u8, 22u8, 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<
64,
> as alloy_sol_types::SolType>::tokenize(&self.serviceId),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.metricName,
),
)
}
#[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: getMetricValueReturn = 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: getMetricValueReturn = 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 getOnlineOperatorsCall {
#[allow(missing_docs)]
pub serviceId: u64,
}
#[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 getOnlineOperatorsReturn {
#[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<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<getOnlineOperatorsCall>
for UnderlyingRustTuple<'_> {
fn from(value: getOnlineOperatorsCall) -> Self {
(value.serviceId,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getOnlineOperatorsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { serviceId: 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<getOnlineOperatorsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getOnlineOperatorsReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getOnlineOperatorsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getOnlineOperatorsCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<64>,);
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 = "getOnlineOperators(uint64)";
const SELECTOR: [u8; 4] = [64u8, 35u8, 90u8, 156u8];
#[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.serviceId),
)
}
#[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: getOnlineOperatorsReturn = 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: getOnlineOperatorsReturn = 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 getOperatorStateCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[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 getOperatorStateReturn {
#[allow(missing_docs)]
pub _0: <OperatorState as alloy::sol_types::SolType>::RustType,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, 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<getOperatorStateCall>
for UnderlyingRustTuple<'_> {
fn from(value: getOperatorStateCall) -> Self {
(value.serviceId, value.operator)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getOperatorStateCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
operator: tuple.1,
}
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (OperatorState,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
<OperatorState as alloy::sol_types::SolType>::RustType,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getOperatorStateReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getOperatorStateReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getOperatorStateReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getOperatorStateCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = <OperatorState as alloy::sol_types::SolType>::RustType;
type ReturnTuple<'a> = (OperatorState,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getOperatorState(uint64,address)";
const SELECTOR: [u8; 4] = [113u8, 231u8, 56u8, 140u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.serviceId),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(<OperatorState 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: getOperatorStateReturn = 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: getOperatorStateReturn = 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 getOperatorStatusCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[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 getOperatorStatusReturn {
#[allow(missing_docs)]
pub _0: <StatusCode as alloy::sol_types::SolType>::RustType,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, 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<getOperatorStatusCall>
for UnderlyingRustTuple<'_> {
fn from(value: getOperatorStatusCall) -> Self {
(value.serviceId, value.operator)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getOperatorStatusCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
operator: tuple.1,
}
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (StatusCode,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
<StatusCode as alloy::sol_types::SolType>::RustType,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getOperatorStatusReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getOperatorStatusReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getOperatorStatusReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getOperatorStatusCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = <StatusCode as alloy::sol_types::SolType>::RustType;
type ReturnTuple<'a> = (StatusCode,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getOperatorStatus(uint64,address)";
const SELECTOR: [u8; 4] = [98u8, 199u8, 232u8, 252u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.serviceId),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(<StatusCode 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: getOperatorStatusReturn = 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: getOperatorStatusReturn = 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 getSlashableOperatorsCall {
#[allow(missing_docs)]
pub serviceId: u64,
}
#[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 getSlashableOperatorsReturn {
#[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<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<getSlashableOperatorsCall>
for UnderlyingRustTuple<'_> {
fn from(value: getSlashableOperatorsCall) -> Self {
(value.serviceId,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getSlashableOperatorsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { serviceId: 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<getSlashableOperatorsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getSlashableOperatorsReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getSlashableOperatorsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getSlashableOperatorsCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<64>,);
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 = "getSlashableOperators(uint64)";
const SELECTOR: [u8; 4] = [89u8, 220u8, 234u8, 18u8];
#[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.serviceId),
)
}
#[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: getSlashableOperatorsReturn = 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: getSlashableOperatorsReturn = 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 getSlashableOperatorsPaginatedCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[allow(missing_docs)]
pub offset: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub limit: alloy::sol_types::private::primitives::aliases::U256,
}
#[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 getSlashableOperatorsPaginatedReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
#[allow(missing_docs)]
pub _1: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
u64,
alloy::sol_types::private::primitives::aliases::U256,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getSlashableOperatorsPaginatedCall>
for UnderlyingRustTuple<'_> {
fn from(value: getSlashableOperatorsPaginatedCall) -> Self {
(value.serviceId, value.offset, value.limit)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getSlashableOperatorsPaginatedCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
offset: tuple.1,
limit: tuple.2,
}
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getSlashableOperatorsPaginatedReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getSlashableOperatorsPaginatedReturn) -> Self {
(value._0, value._1)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getSlashableOperatorsPaginatedReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0, _1: tuple.1 }
}
}
}
impl getSlashableOperatorsPaginatedReturn {
fn _tokenize(
&self,
) -> <getSlashableOperatorsPaginatedCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
(
<alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::Address,
> as alloy_sol_types::SolType>::tokenize(&self._0),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self._1),
)
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getSlashableOperatorsPaginatedCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = getSlashableOperatorsPaginatedReturn;
type ReturnTuple<'a> = (
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
alloy::sol_types::sol_data::Uint<256>,
);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getSlashableOperatorsPaginated(uint64,uint256,uint256)";
const SELECTOR: [u8; 4] = [129u8, 190u8, 172u8, 46u8];
#[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.serviceId),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self.offset),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self.limit),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
getSlashableOperatorsPaginatedReturn::_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 goOfflineCall {
#[allow(missing_docs)]
pub serviceId: u64,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct goOfflineReturn {}
#[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>,);
#[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<goOfflineCall> for UnderlyingRustTuple<'_> {
fn from(value: goOfflineCall) -> Self {
(value.serviceId,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for goOfflineCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { serviceId: 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<goOfflineReturn> for UnderlyingRustTuple<'_> {
fn from(value: goOfflineReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for goOfflineReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl goOfflineReturn {
fn _tokenize(
&self,
) -> <goOfflineCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for goOfflineCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<64>,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = goOfflineReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "goOffline(uint64)";
const SELECTOR: [u8; 4] = [197u8, 217u8, 96u8, 187u8];
#[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.serviceId),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
goOfflineReturn::_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 goOnlineCall {
#[allow(missing_docs)]
pub serviceId: u64,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct goOnlineReturn {}
#[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>,);
#[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<goOnlineCall> for UnderlyingRustTuple<'_> {
fn from(value: goOnlineCall) -> Self {
(value.serviceId,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for goOnlineCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { serviceId: 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<goOnlineReturn> for UnderlyingRustTuple<'_> {
fn from(value: goOnlineReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for goOnlineReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl goOnlineReturn {
fn _tokenize(
&self,
) -> <goOnlineCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for goOnlineCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Uint<64>,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = goOnlineReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "goOnline(uint64)";
const SELECTOR: [u8; 4] = [176u8, 116u8, 233u8, 221u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.serviceId),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
goOnlineReturn::_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 isHeartbeatCurrentCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[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 isHeartbeatCurrentReturn {
#[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::Uint<64>,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, 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<isHeartbeatCurrentCall>
for UnderlyingRustTuple<'_> {
fn from(value: isHeartbeatCurrentCall) -> Self {
(value.serviceId, value.operator)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for isHeartbeatCurrentCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
operator: 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<isHeartbeatCurrentReturn>
for UnderlyingRustTuple<'_> {
fn from(value: isHeartbeatCurrentReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for isHeartbeatCurrentReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for isHeartbeatCurrentCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
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 = "isHeartbeatCurrent(uint64,address)";
const SELECTOR: [u8; 4] = [238u8, 28u8, 3u8, 144u8];
#[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.serviceId),
<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::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: isHeartbeatCurrentReturn = 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: isHeartbeatCurrentReturn = 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 isOnlineCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[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 isOnlineReturn {
#[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::Uint<64>,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, 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<isOnlineCall> for UnderlyingRustTuple<'_> {
fn from(value: isOnlineCall) -> Self {
(value.serviceId, value.operator)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOnlineCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
operator: 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<isOnlineReturn> for UnderlyingRustTuple<'_> {
fn from(value: isOnlineReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOnlineReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for isOnlineCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
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 = "isOnline(uint64,address)";
const SELECTOR: [u8; 4] = [86u8, 133u8, 207u8, 104u8];
#[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.serviceId),
<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::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: isOnlineReturn = 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: isOnlineReturn = 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 isRegisteredOperatorCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[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 isRegisteredOperatorReturn {
#[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::Uint<64>,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, 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<isRegisteredOperatorCall>
for UnderlyingRustTuple<'_> {
fn from(value: isRegisteredOperatorCall) -> Self {
(value.serviceId, value.operator)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for isRegisteredOperatorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
operator: 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<isRegisteredOperatorReturn>
for UnderlyingRustTuple<'_> {
fn from(value: isRegisteredOperatorReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for isRegisteredOperatorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for isRegisteredOperatorCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
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 = "isRegisteredOperator(uint64,address)";
const SELECTOR: [u8; 4] = [96u8, 207u8, 9u8, 145u8];
#[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.serviceId),
<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::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: isRegisteredOperatorReturn = 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: isRegisteredOperatorReturn = 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 registerOperatorCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[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 registerOperatorReturn {}
#[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::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, 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<registerOperatorCall>
for UnderlyingRustTuple<'_> {
fn from(value: registerOperatorCall) -> Self {
(value.serviceId, value.operator)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for registerOperatorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
operator: 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<registerOperatorReturn>
for UnderlyingRustTuple<'_> {
fn from(value: registerOperatorReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for registerOperatorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl registerOperatorReturn {
fn _tokenize(
&self,
) -> <registerOperatorCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for registerOperatorCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = registerOperatorReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "registerOperator(uint64,address)";
const SELECTOR: [u8; 4] = [30u8, 143u8, 94u8, 229u8];
#[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.serviceId),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
registerOperatorReturn::_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 registerServiceOwnerCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[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 registerServiceOwnerReturn {}
#[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::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, 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<registerServiceOwnerCall>
for UnderlyingRustTuple<'_> {
fn from(value: registerServiceOwnerCall) -> Self {
(value.serviceId, value.owner)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for registerServiceOwnerCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: 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<registerServiceOwnerReturn>
for UnderlyingRustTuple<'_> {
fn from(value: registerServiceOwnerReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for registerServiceOwnerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl registerServiceOwnerReturn {
fn _tokenize(
&self,
) -> <registerServiceOwnerCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for registerServiceOwnerCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = registerServiceOwnerReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "registerServiceOwner(uint64,address)";
const SELECTOR: [u8; 4] = [5u8, 119u8, 133u8, 80u8];
#[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.serviceId),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.owner,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
registerServiceOwnerReturn::_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 removeInactiveOperatorCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[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 removeInactiveOperatorReturn {}
#[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::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (u64, 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<removeInactiveOperatorCall>
for UnderlyingRustTuple<'_> {
fn from(value: removeInactiveOperatorCall) -> Self {
(value.serviceId, value.operator)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for removeInactiveOperatorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
operator: 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<removeInactiveOperatorReturn>
for UnderlyingRustTuple<'_> {
fn from(value: removeInactiveOperatorReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for removeInactiveOperatorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl removeInactiveOperatorReturn {
fn _tokenize(
&self,
) -> <removeInactiveOperatorCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for removeInactiveOperatorCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = removeInactiveOperatorReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "removeInactiveOperator(uint64,address)";
const SELECTOR: [u8; 4] = [230u8, 92u8, 175u8, 203u8];
#[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.serviceId),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
removeInactiveOperatorReturn::_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 reportForSlashingCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[allow(missing_docs)]
pub operator: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub reason: alloy::sol_types::private::String,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct reportForSlashingReturn {}
#[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::Address,
alloy::sol_types::sol_data::String,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
u64,
alloy::sol_types::private::Address,
alloy::sol_types::private::String,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<reportForSlashingCall>
for UnderlyingRustTuple<'_> {
fn from(value: reportForSlashingCall) -> Self {
(value.serviceId, value.operator, value.reason)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for reportForSlashingCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
operator: tuple.1,
reason: tuple.2,
}
}
}
}
{
#[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<reportForSlashingReturn>
for UnderlyingRustTuple<'_> {
fn from(value: reportForSlashingReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for reportForSlashingReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl reportForSlashingReturn {
fn _tokenize(
&self,
) -> <reportForSlashingCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for reportForSlashingCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::String,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = reportForSlashingReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "reportForSlashing(uint64,address,string)";
const SELECTOR: [u8; 4] = [173u8, 255u8, 131u8, 12u8];
#[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.serviceId),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.operator,
),
<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.reason,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
reportForSlashingReturn::_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 setMetricDefinitionsCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[allow(missing_docs)]
pub definitions: alloy::sol_types::private::Vec<
<MetricDefinition as alloy::sol_types::SolType>::RustType,
>,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setMetricDefinitionsReturn {}
#[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::Array<MetricDefinition>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
u64,
alloy::sol_types::private::Vec<
<MetricDefinition as alloy::sol_types::SolType>::RustType,
>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setMetricDefinitionsCall>
for UnderlyingRustTuple<'_> {
fn from(value: setMetricDefinitionsCall) -> Self {
(value.serviceId, value.definitions)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setMetricDefinitionsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
definitions: 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<setMetricDefinitionsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setMetricDefinitionsReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setMetricDefinitionsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setMetricDefinitionsReturn {
fn _tokenize(
&self,
) -> <setMetricDefinitionsCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setMetricDefinitionsCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Array<MetricDefinition>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setMetricDefinitionsReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setMetricDefinitions(uint64,(string,uint256,uint256,bool)[])";
const SELECTOR: [u8; 4] = [25u8, 28u8, 189u8, 26u8];
#[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.serviceId),
<alloy::sol_types::sol_data::Array<
MetricDefinition,
> as alloy_sol_types::SolType>::tokenize(&self.definitions),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setMetricDefinitionsReturn::_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 submitHeartbeatCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[allow(missing_docs)]
pub blueprintId: u64,
#[allow(missing_docs)]
pub statusCode: u8,
#[allow(missing_docs)]
pub metrics: alloy::sol_types::private::Bytes,
#[allow(missing_docs)]
pub signature: alloy::sol_types::private::Bytes,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct submitHeartbeatReturn {}
#[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<64>,
alloy::sol_types::sol_data::Uint<8>,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Bytes,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
u64,
u64,
u8,
alloy::sol_types::private::Bytes,
alloy::sol_types::private::Bytes,
);
#[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<submitHeartbeatCall> for UnderlyingRustTuple<'_> {
fn from(value: submitHeartbeatCall) -> Self {
(
value.serviceId,
value.blueprintId,
value.statusCode,
value.metrics,
value.signature,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for submitHeartbeatCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
blueprintId: tuple.1,
statusCode: tuple.2,
metrics: tuple.3,
signature: tuple.4,
}
}
}
}
{
#[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<submitHeartbeatReturn>
for UnderlyingRustTuple<'_> {
fn from(value: submitHeartbeatReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for submitHeartbeatReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl submitHeartbeatReturn {
fn _tokenize(
&self,
) -> <submitHeartbeatCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for submitHeartbeatCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Uint<8>,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Bytes,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = submitHeartbeatReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "submitHeartbeat(uint64,uint64,uint8,bytes,bytes)";
const SELECTOR: [u8; 4] = [212u8, 19u8, 165u8, 128u8];
#[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.serviceId),
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.blueprintId),
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::tokenize(&self.statusCode),
<alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
&self.metrics,
),
<alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
&self.signature,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
submitHeartbeatReturn::_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 submitHeartbeatDirectCall {
#[allow(missing_docs)]
pub serviceId: u64,
#[allow(missing_docs)]
pub blueprintId: u64,
#[allow(missing_docs)]
pub statusCode: u8,
#[allow(missing_docs)]
pub metrics: alloy::sol_types::private::Bytes,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct submitHeartbeatDirectReturn {}
#[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<64>,
alloy::sol_types::sol_data::Uint<8>,
alloy::sol_types::sol_data::Bytes,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
u64,
u64,
u8,
alloy::sol_types::private::Bytes,
);
#[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<submitHeartbeatDirectCall>
for UnderlyingRustTuple<'_> {
fn from(value: submitHeartbeatDirectCall) -> Self {
(value.serviceId, value.blueprintId, value.statusCode, value.metrics)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for submitHeartbeatDirectCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
serviceId: tuple.0,
blueprintId: tuple.1,
statusCode: tuple.2,
metrics: tuple.3,
}
}
}
}
{
#[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<submitHeartbeatDirectReturn>
for UnderlyingRustTuple<'_> {
fn from(value: submitHeartbeatDirectReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for submitHeartbeatDirectReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl submitHeartbeatDirectReturn {
fn _tokenize(
&self,
) -> <submitHeartbeatDirectCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for submitHeartbeatDirectCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Uint<64>,
alloy::sol_types::sol_data::Uint<8>,
alloy::sol_types::sol_data::Bytes,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = submitHeartbeatDirectReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "submitHeartbeatDirect(uint64,uint64,uint8,bytes)";
const SELECTOR: [u8; 4] = [92u8, 206u8, 152u8, 166u8];
#[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.serviceId),
<alloy::sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.blueprintId),
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::tokenize(&self.statusCode),
<alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
&self.metrics,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
submitHeartbeatDirectReturn::_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 IOperatorStatusRegistryCalls {
#[allow(missing_docs)]
addMetricDefinition(addMetricDefinitionCall),
#[allow(missing_docs)]
configureHeartbeat(configureHeartbeatCall),
#[allow(missing_docs)]
deregisterOperator(deregisterOperatorCall),
#[allow(missing_docs)]
enableCustomMetrics(enableCustomMetricsCall),
#[allow(missing_docs)]
getHeartbeatConfig(getHeartbeatConfigCall),
#[allow(missing_docs)]
getLastHeartbeat(getLastHeartbeatCall),
#[allow(missing_docs)]
getMetricDefinitions(getMetricDefinitionsCall),
#[allow(missing_docs)]
getMetricValue(getMetricValueCall),
#[allow(missing_docs)]
getOnlineOperators(getOnlineOperatorsCall),
#[allow(missing_docs)]
getOperatorState(getOperatorStateCall),
#[allow(missing_docs)]
getOperatorStatus(getOperatorStatusCall),
#[allow(missing_docs)]
getSlashableOperators(getSlashableOperatorsCall),
#[allow(missing_docs)]
getSlashableOperatorsPaginated(getSlashableOperatorsPaginatedCall),
#[allow(missing_docs)]
goOffline(goOfflineCall),
#[allow(missing_docs)]
goOnline(goOnlineCall),
#[allow(missing_docs)]
isHeartbeatCurrent(isHeartbeatCurrentCall),
#[allow(missing_docs)]
isOnline(isOnlineCall),
#[allow(missing_docs)]
isRegisteredOperator(isRegisteredOperatorCall),
#[allow(missing_docs)]
registerOperator(registerOperatorCall),
#[allow(missing_docs)]
registerServiceOwner(registerServiceOwnerCall),
#[allow(missing_docs)]
removeInactiveOperator(removeInactiveOperatorCall),
#[allow(missing_docs)]
reportForSlashing(reportForSlashingCall),
#[allow(missing_docs)]
setMetricDefinitions(setMetricDefinitionsCall),
#[allow(missing_docs)]
submitHeartbeat(submitHeartbeatCall),
#[allow(missing_docs)]
submitHeartbeatDirect(submitHeartbeatDirectCall),
}
impl IOperatorStatusRegistryCalls {
pub const SELECTORS: &'static [[u8; 4usize]] = &[
[5u8, 119u8, 133u8, 80u8],
[7u8, 88u8, 35u8, 111u8],
[12u8, 118u8, 105u8, 122u8],
[25u8, 28u8, 189u8, 26u8],
[30u8, 143u8, 94u8, 229u8],
[64u8, 35u8, 90u8, 156u8],
[86u8, 133u8, 207u8, 104u8],
[89u8, 220u8, 234u8, 18u8],
[92u8, 206u8, 152u8, 166u8],
[96u8, 207u8, 9u8, 145u8],
[98u8, 199u8, 232u8, 252u8],
[113u8, 231u8, 56u8, 140u8],
[129u8, 190u8, 172u8, 46u8],
[173u8, 255u8, 131u8, 12u8],
[174u8, 71u8, 10u8, 133u8],
[176u8, 116u8, 233u8, 221u8],
[185u8, 159u8, 103u8, 89u8],
[193u8, 239u8, 157u8, 223u8],
[197u8, 217u8, 96u8, 187u8],
[212u8, 19u8, 165u8, 128u8],
[213u8, 81u8, 22u8, 44u8],
[230u8, 92u8, 175u8, 203u8],
[238u8, 28u8, 3u8, 144u8],
[249u8, 16u8, 127u8, 59u8],
[255u8, 207u8, 8u8, 240u8],
];
pub const VARIANT_NAMES: &'static [&'static str] = &[
::core::stringify!(registerServiceOwner),
::core::stringify!(getHeartbeatConfig),
::core::stringify!(getLastHeartbeat),
::core::stringify!(setMetricDefinitions),
::core::stringify!(registerOperator),
::core::stringify!(getOnlineOperators),
::core::stringify!(isOnline),
::core::stringify!(getSlashableOperators),
::core::stringify!(submitHeartbeatDirect),
::core::stringify!(isRegisteredOperator),
::core::stringify!(getOperatorStatus),
::core::stringify!(getOperatorState),
::core::stringify!(getSlashableOperatorsPaginated),
::core::stringify!(reportForSlashing),
::core::stringify!(addMetricDefinition),
::core::stringify!(goOnline),
::core::stringify!(configureHeartbeat),
::core::stringify!(getMetricDefinitions),
::core::stringify!(goOffline),
::core::stringify!(submitHeartbeat),
::core::stringify!(getMetricValue),
::core::stringify!(removeInactiveOperator),
::core::stringify!(isHeartbeatCurrent),
::core::stringify!(enableCustomMetrics),
::core::stringify!(deregisterOperator),
];
pub const SIGNATURES: &'static [&'static str] = &[
<registerServiceOwnerCall as alloy_sol_types::SolCall>::SIGNATURE,
<getHeartbeatConfigCall as alloy_sol_types::SolCall>::SIGNATURE,
<getLastHeartbeatCall as alloy_sol_types::SolCall>::SIGNATURE,
<setMetricDefinitionsCall as alloy_sol_types::SolCall>::SIGNATURE,
<registerOperatorCall as alloy_sol_types::SolCall>::SIGNATURE,
<getOnlineOperatorsCall as alloy_sol_types::SolCall>::SIGNATURE,
<isOnlineCall as alloy_sol_types::SolCall>::SIGNATURE,
<getSlashableOperatorsCall as alloy_sol_types::SolCall>::SIGNATURE,
<submitHeartbeatDirectCall as alloy_sol_types::SolCall>::SIGNATURE,
<isRegisteredOperatorCall as alloy_sol_types::SolCall>::SIGNATURE,
<getOperatorStatusCall as alloy_sol_types::SolCall>::SIGNATURE,
<getOperatorStateCall as alloy_sol_types::SolCall>::SIGNATURE,
<getSlashableOperatorsPaginatedCall as alloy_sol_types::SolCall>::SIGNATURE,
<reportForSlashingCall as alloy_sol_types::SolCall>::SIGNATURE,
<addMetricDefinitionCall as alloy_sol_types::SolCall>::SIGNATURE,
<goOnlineCall as alloy_sol_types::SolCall>::SIGNATURE,
<configureHeartbeatCall as alloy_sol_types::SolCall>::SIGNATURE,
<getMetricDefinitionsCall as alloy_sol_types::SolCall>::SIGNATURE,
<goOfflineCall as alloy_sol_types::SolCall>::SIGNATURE,
<submitHeartbeatCall as alloy_sol_types::SolCall>::SIGNATURE,
<getMetricValueCall as alloy_sol_types::SolCall>::SIGNATURE,
<removeInactiveOperatorCall as alloy_sol_types::SolCall>::SIGNATURE,
<isHeartbeatCurrentCall as alloy_sol_types::SolCall>::SIGNATURE,
<enableCustomMetricsCall as alloy_sol_types::SolCall>::SIGNATURE,
<deregisterOperatorCall 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 IOperatorStatusRegistryCalls {
const NAME: &'static str = "IOperatorStatusRegistryCalls";
const MIN_DATA_LENGTH: usize = 32usize;
const COUNT: usize = 25usize;
#[inline]
fn selector(&self) -> [u8; 4] {
match self {
Self::addMetricDefinition(_) => {
<addMetricDefinitionCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::configureHeartbeat(_) => {
<configureHeartbeatCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::deregisterOperator(_) => {
<deregisterOperatorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::enableCustomMetrics(_) => {
<enableCustomMetricsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getHeartbeatConfig(_) => {
<getHeartbeatConfigCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getLastHeartbeat(_) => {
<getLastHeartbeatCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getMetricDefinitions(_) => {
<getMetricDefinitionsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getMetricValue(_) => {
<getMetricValueCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getOnlineOperators(_) => {
<getOnlineOperatorsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getOperatorState(_) => {
<getOperatorStateCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getOperatorStatus(_) => {
<getOperatorStatusCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getSlashableOperators(_) => {
<getSlashableOperatorsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getSlashableOperatorsPaginated(_) => {
<getSlashableOperatorsPaginatedCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::goOffline(_) => {
<goOfflineCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::goOnline(_) => <goOnlineCall as alloy_sol_types::SolCall>::SELECTOR,
Self::isHeartbeatCurrent(_) => {
<isHeartbeatCurrentCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::isOnline(_) => <isOnlineCall as alloy_sol_types::SolCall>::SELECTOR,
Self::isRegisteredOperator(_) => {
<isRegisteredOperatorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::registerOperator(_) => {
<registerOperatorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::registerServiceOwner(_) => {
<registerServiceOwnerCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::removeInactiveOperator(_) => {
<removeInactiveOperatorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::reportForSlashing(_) => {
<reportForSlashingCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setMetricDefinitions(_) => {
<setMetricDefinitionsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::submitHeartbeat(_) => {
<submitHeartbeatCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::submitHeartbeatDirect(_) => {
<submitHeartbeatDirectCall 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<IOperatorStatusRegistryCalls>] = &[
{
fn registerServiceOwner(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<registerServiceOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::registerServiceOwner)
}
registerServiceOwner
},
{
fn getHeartbeatConfig(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getHeartbeatConfigCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::getHeartbeatConfig)
}
getHeartbeatConfig
},
{
fn getLastHeartbeat(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getLastHeartbeatCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::getLastHeartbeat)
}
getLastHeartbeat
},
{
fn setMetricDefinitions(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<setMetricDefinitionsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::setMetricDefinitions)
}
setMetricDefinitions
},
{
fn registerOperator(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<registerOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::registerOperator)
}
registerOperator
},
{
fn getOnlineOperators(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getOnlineOperatorsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::getOnlineOperators)
}
getOnlineOperators
},
{
fn isOnline(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<isOnlineCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IOperatorStatusRegistryCalls::isOnline)
}
isOnline
},
{
fn getSlashableOperators(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getSlashableOperatorsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::getSlashableOperators)
}
getSlashableOperators
},
{
fn submitHeartbeatDirect(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<submitHeartbeatDirectCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::submitHeartbeatDirect)
}
submitHeartbeatDirect
},
{
fn isRegisteredOperator(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<isRegisteredOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::isRegisteredOperator)
}
isRegisteredOperator
},
{
fn getOperatorStatus(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getOperatorStatusCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::getOperatorStatus)
}
getOperatorStatus
},
{
fn getOperatorState(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getOperatorStateCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::getOperatorState)
}
getOperatorState
},
{
fn getSlashableOperatorsPaginated(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getSlashableOperatorsPaginatedCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
IOperatorStatusRegistryCalls::getSlashableOperatorsPaginated,
)
}
getSlashableOperatorsPaginated
},
{
fn reportForSlashing(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<reportForSlashingCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::reportForSlashing)
}
reportForSlashing
},
{
fn addMetricDefinition(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<addMetricDefinitionCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::addMetricDefinition)
}
addMetricDefinition
},
{
fn goOnline(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<goOnlineCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IOperatorStatusRegistryCalls::goOnline)
}
goOnline
},
{
fn configureHeartbeat(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<configureHeartbeatCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::configureHeartbeat)
}
configureHeartbeat
},
{
fn getMetricDefinitions(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getMetricDefinitionsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::getMetricDefinitions)
}
getMetricDefinitions
},
{
fn goOffline(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<goOfflineCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IOperatorStatusRegistryCalls::goOffline)
}
goOffline
},
{
fn submitHeartbeat(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<submitHeartbeatCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::submitHeartbeat)
}
submitHeartbeat
},
{
fn getMetricValue(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getMetricValueCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::getMetricValue)
}
getMetricValue
},
{
fn removeInactiveOperator(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<removeInactiveOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::removeInactiveOperator)
}
removeInactiveOperator
},
{
fn isHeartbeatCurrent(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<isHeartbeatCurrentCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::isHeartbeatCurrent)
}
isHeartbeatCurrent
},
{
fn enableCustomMetrics(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<enableCustomMetricsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::enableCustomMetrics)
}
enableCustomMetrics
},
{
fn deregisterOperator(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<deregisterOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IOperatorStatusRegistryCalls::deregisterOperator)
}
deregisterOperator
},
];
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<IOperatorStatusRegistryCalls>] = &[
{
fn registerServiceOwner(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<registerServiceOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::registerServiceOwner)
}
registerServiceOwner
},
{
fn getHeartbeatConfig(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getHeartbeatConfigCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::getHeartbeatConfig)
}
getHeartbeatConfig
},
{
fn getLastHeartbeat(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getLastHeartbeatCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::getLastHeartbeat)
}
getLastHeartbeat
},
{
fn setMetricDefinitions(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<setMetricDefinitionsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::setMetricDefinitions)
}
setMetricDefinitions
},
{
fn registerOperator(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<registerOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::registerOperator)
}
registerOperator
},
{
fn getOnlineOperators(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getOnlineOperatorsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::getOnlineOperators)
}
getOnlineOperators
},
{
fn isOnline(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<isOnlineCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::isOnline)
}
isOnline
},
{
fn getSlashableOperators(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getSlashableOperatorsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::getSlashableOperators)
}
getSlashableOperators
},
{
fn submitHeartbeatDirect(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<submitHeartbeatDirectCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::submitHeartbeatDirect)
}
submitHeartbeatDirect
},
{
fn isRegisteredOperator(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<isRegisteredOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::isRegisteredOperator)
}
isRegisteredOperator
},
{
fn getOperatorStatus(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getOperatorStatusCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::getOperatorStatus)
}
getOperatorStatus
},
{
fn getOperatorState(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getOperatorStateCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::getOperatorState)
}
getOperatorState
},
{
fn getSlashableOperatorsPaginated(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getSlashableOperatorsPaginatedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
IOperatorStatusRegistryCalls::getSlashableOperatorsPaginated,
)
}
getSlashableOperatorsPaginated
},
{
fn reportForSlashing(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<reportForSlashingCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::reportForSlashing)
}
reportForSlashing
},
{
fn addMetricDefinition(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<addMetricDefinitionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::addMetricDefinition)
}
addMetricDefinition
},
{
fn goOnline(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<goOnlineCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::goOnline)
}
goOnline
},
{
fn configureHeartbeat(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<configureHeartbeatCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::configureHeartbeat)
}
configureHeartbeat
},
{
fn getMetricDefinitions(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getMetricDefinitionsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::getMetricDefinitions)
}
getMetricDefinitions
},
{
fn goOffline(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<goOfflineCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::goOffline)
}
goOffline
},
{
fn submitHeartbeat(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<submitHeartbeatCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::submitHeartbeat)
}
submitHeartbeat
},
{
fn getMetricValue(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<getMetricValueCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::getMetricValue)
}
getMetricValue
},
{
fn removeInactiveOperator(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<removeInactiveOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::removeInactiveOperator)
}
removeInactiveOperator
},
{
fn isHeartbeatCurrent(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<isHeartbeatCurrentCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::isHeartbeatCurrent)
}
isHeartbeatCurrent
},
{
fn enableCustomMetrics(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<enableCustomMetricsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::enableCustomMetrics)
}
enableCustomMetrics
},
{
fn deregisterOperator(
data: &[u8],
) -> alloy_sol_types::Result<IOperatorStatusRegistryCalls> {
<deregisterOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IOperatorStatusRegistryCalls::deregisterOperator)
}
deregisterOperator
},
];
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::addMetricDefinition(inner) => {
<addMetricDefinitionCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::configureHeartbeat(inner) => {
<configureHeartbeatCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::deregisterOperator(inner) => {
<deregisterOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::enableCustomMetrics(inner) => {
<enableCustomMetricsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getHeartbeatConfig(inner) => {
<getHeartbeatConfigCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getLastHeartbeat(inner) => {
<getLastHeartbeatCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getMetricDefinitions(inner) => {
<getMetricDefinitionsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getMetricValue(inner) => {
<getMetricValueCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getOnlineOperators(inner) => {
<getOnlineOperatorsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getOperatorState(inner) => {
<getOperatorStateCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getOperatorStatus(inner) => {
<getOperatorStatusCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getSlashableOperators(inner) => {
<getSlashableOperatorsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getSlashableOperatorsPaginated(inner) => {
<getSlashableOperatorsPaginatedCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::goOffline(inner) => {
<goOfflineCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::goOnline(inner) => {
<goOnlineCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::isHeartbeatCurrent(inner) => {
<isHeartbeatCurrentCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::isOnline(inner) => {
<isOnlineCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::isRegisteredOperator(inner) => {
<isRegisteredOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::registerOperator(inner) => {
<registerOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::registerServiceOwner(inner) => {
<registerServiceOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::removeInactiveOperator(inner) => {
<removeInactiveOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::reportForSlashing(inner) => {
<reportForSlashingCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setMetricDefinitions(inner) => {
<setMetricDefinitionsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::submitHeartbeat(inner) => {
<submitHeartbeatCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::submitHeartbeatDirect(inner) => {
<submitHeartbeatDirectCall 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::addMetricDefinition(inner) => {
<addMetricDefinitionCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::configureHeartbeat(inner) => {
<configureHeartbeatCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::deregisterOperator(inner) => {
<deregisterOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::enableCustomMetrics(inner) => {
<enableCustomMetricsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getHeartbeatConfig(inner) => {
<getHeartbeatConfigCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getLastHeartbeat(inner) => {
<getLastHeartbeatCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getMetricDefinitions(inner) => {
<getMetricDefinitionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getMetricValue(inner) => {
<getMetricValueCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getOnlineOperators(inner) => {
<getOnlineOperatorsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getOperatorState(inner) => {
<getOperatorStateCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getOperatorStatus(inner) => {
<getOperatorStatusCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getSlashableOperators(inner) => {
<getSlashableOperatorsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getSlashableOperatorsPaginated(inner) => {
<getSlashableOperatorsPaginatedCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::goOffline(inner) => {
<goOfflineCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::goOnline(inner) => {
<goOnlineCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::isHeartbeatCurrent(inner) => {
<isHeartbeatCurrentCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::isOnline(inner) => {
<isOnlineCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::isRegisteredOperator(inner) => {
<isRegisteredOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::registerOperator(inner) => {
<registerOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::registerServiceOwner(inner) => {
<registerServiceOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::removeInactiveOperator(inner) => {
<removeInactiveOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::reportForSlashing(inner) => {
<reportForSlashingCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setMetricDefinitions(inner) => {
<setMetricDefinitionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::submitHeartbeat(inner) => {
<submitHeartbeatCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::submitHeartbeatDirect(inner) => {
<submitHeartbeatDirectCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
}
}
}
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,
) -> IOperatorStatusRegistryInstance<P, N> {
IOperatorStatusRegistryInstance::<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<IOperatorStatusRegistryInstance<P, N>>,
> {
IOperatorStatusRegistryInstance::<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> {
IOperatorStatusRegistryInstance::<P, N>::deploy_builder(__provider)
}
#[derive(Clone)]
pub struct IOperatorStatusRegistryInstance<
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 IOperatorStatusRegistryInstance<P, N> {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
f.debug_tuple("IOperatorStatusRegistryInstance")
.field(&self.address)
.finish()
}
}
impl<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
> IOperatorStatusRegistryInstance<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<IOperatorStatusRegistryInstance<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> IOperatorStatusRegistryInstance<&P, N> {
#[inline]
pub fn with_cloned_provider(self) -> IOperatorStatusRegistryInstance<P, N> {
IOperatorStatusRegistryInstance {
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,
> IOperatorStatusRegistryInstance<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 addMetricDefinition(
&self,
serviceId: u64,
name: alloy::sol_types::private::String,
minValue: alloy::sol_types::private::primitives::aliases::U256,
maxValue: alloy::sol_types::private::primitives::aliases::U256,
required: bool,
) -> alloy_contract::SolCallBuilder<&P, addMetricDefinitionCall, N> {
self.call_builder(
&addMetricDefinitionCall {
serviceId,
name,
minValue,
maxValue,
required,
},
)
}
pub fn configureHeartbeat(
&self,
serviceId: u64,
interval: u64,
maxMissed: u8,
) -> alloy_contract::SolCallBuilder<&P, configureHeartbeatCall, N> {
self.call_builder(
&configureHeartbeatCall {
serviceId,
interval,
maxMissed,
},
)
}
pub fn deregisterOperator(
&self,
serviceId: u64,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, deregisterOperatorCall, N> {
self.call_builder(
&deregisterOperatorCall {
serviceId,
operator,
},
)
}
pub fn enableCustomMetrics(
&self,
serviceId: u64,
enabled: bool,
) -> alloy_contract::SolCallBuilder<&P, enableCustomMetricsCall, N> {
self.call_builder(
&enableCustomMetricsCall {
serviceId,
enabled,
},
)
}
pub fn getHeartbeatConfig(
&self,
serviceId: u64,
) -> alloy_contract::SolCallBuilder<&P, getHeartbeatConfigCall, N> {
self.call_builder(
&getHeartbeatConfigCall {
serviceId,
},
)
}
pub fn getLastHeartbeat(
&self,
serviceId: u64,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, getLastHeartbeatCall, N> {
self.call_builder(
&getLastHeartbeatCall {
serviceId,
operator,
},
)
}
pub fn getMetricDefinitions(
&self,
serviceId: u64,
) -> alloy_contract::SolCallBuilder<&P, getMetricDefinitionsCall, N> {
self.call_builder(
&getMetricDefinitionsCall {
serviceId,
},
)
}
pub fn getMetricValue(
&self,
serviceId: u64,
operator: alloy::sol_types::private::Address,
metricName: alloy::sol_types::private::String,
) -> alloy_contract::SolCallBuilder<&P, getMetricValueCall, N> {
self.call_builder(
&getMetricValueCall {
serviceId,
operator,
metricName,
},
)
}
pub fn getOnlineOperators(
&self,
serviceId: u64,
) -> alloy_contract::SolCallBuilder<&P, getOnlineOperatorsCall, N> {
self.call_builder(
&getOnlineOperatorsCall {
serviceId,
},
)
}
pub fn getOperatorState(
&self,
serviceId: u64,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, getOperatorStateCall, N> {
self.call_builder(
&getOperatorStateCall {
serviceId,
operator,
},
)
}
pub fn getOperatorStatus(
&self,
serviceId: u64,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, getOperatorStatusCall, N> {
self.call_builder(
&getOperatorStatusCall {
serviceId,
operator,
},
)
}
pub fn getSlashableOperators(
&self,
serviceId: u64,
) -> alloy_contract::SolCallBuilder<&P, getSlashableOperatorsCall, N> {
self.call_builder(
&getSlashableOperatorsCall {
serviceId,
},
)
}
pub fn getSlashableOperatorsPaginated(
&self,
serviceId: u64,
offset: alloy::sol_types::private::primitives::aliases::U256,
limit: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, getSlashableOperatorsPaginatedCall, N> {
self.call_builder(
&getSlashableOperatorsPaginatedCall {
serviceId,
offset,
limit,
},
)
}
pub fn goOffline(
&self,
serviceId: u64,
) -> alloy_contract::SolCallBuilder<&P, goOfflineCall, N> {
self.call_builder(&goOfflineCall { serviceId })
}
pub fn goOnline(
&self,
serviceId: u64,
) -> alloy_contract::SolCallBuilder<&P, goOnlineCall, N> {
self.call_builder(&goOnlineCall { serviceId })
}
pub fn isHeartbeatCurrent(
&self,
serviceId: u64,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, isHeartbeatCurrentCall, N> {
self.call_builder(
&isHeartbeatCurrentCall {
serviceId,
operator,
},
)
}
pub fn isOnline(
&self,
serviceId: u64,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, isOnlineCall, N> {
self.call_builder(
&isOnlineCall {
serviceId,
operator,
},
)
}
pub fn isRegisteredOperator(
&self,
serviceId: u64,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, isRegisteredOperatorCall, N> {
self.call_builder(
&isRegisteredOperatorCall {
serviceId,
operator,
},
)
}
pub fn registerOperator(
&self,
serviceId: u64,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, registerOperatorCall, N> {
self.call_builder(
®isterOperatorCall {
serviceId,
operator,
},
)
}
pub fn registerServiceOwner(
&self,
serviceId: u64,
owner: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, registerServiceOwnerCall, N> {
self.call_builder(
®isterServiceOwnerCall {
serviceId,
owner,
},
)
}
pub fn removeInactiveOperator(
&self,
serviceId: u64,
operator: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, removeInactiveOperatorCall, N> {
self.call_builder(
&removeInactiveOperatorCall {
serviceId,
operator,
},
)
}
pub fn reportForSlashing(
&self,
serviceId: u64,
operator: alloy::sol_types::private::Address,
reason: alloy::sol_types::private::String,
) -> alloy_contract::SolCallBuilder<&P, reportForSlashingCall, N> {
self.call_builder(
&reportForSlashingCall {
serviceId,
operator,
reason,
},
)
}
pub fn setMetricDefinitions(
&self,
serviceId: u64,
definitions: alloy::sol_types::private::Vec<
<MetricDefinition as alloy::sol_types::SolType>::RustType,
>,
) -> alloy_contract::SolCallBuilder<&P, setMetricDefinitionsCall, N> {
self.call_builder(
&setMetricDefinitionsCall {
serviceId,
definitions,
},
)
}
pub fn submitHeartbeat(
&self,
serviceId: u64,
blueprintId: u64,
statusCode: u8,
metrics: alloy::sol_types::private::Bytes,
signature: alloy::sol_types::private::Bytes,
) -> alloy_contract::SolCallBuilder<&P, submitHeartbeatCall, N> {
self.call_builder(
&submitHeartbeatCall {
serviceId,
blueprintId,
statusCode,
metrics,
signature,
},
)
}
pub fn submitHeartbeatDirect(
&self,
serviceId: u64,
blueprintId: u64,
statusCode: u8,
metrics: alloy::sol_types::private::Bytes,
) -> alloy_contract::SolCallBuilder<&P, submitHeartbeatDirectCall, N> {
self.call_builder(
&submitHeartbeatDirectCall {
serviceId,
blueprintId,
statusCode,
metrics,
},
)
}
}
impl<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
> IOperatorStatusRegistryInstance<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)
}
}
}