#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style,
clippy::empty_structs_with_brackets
)]
pub mod NewtonAddressesProvider {
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 InvalidShortString;
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<InvalidShortString> for UnderlyingRustTuple<'_> {
fn from(value: InvalidShortString) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidShortString {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InvalidShortString {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InvalidShortString()";
const SELECTOR: [u8; 4] = [179u8, 81u8, 43u8, 12u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(Self::new)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct NoContractCode {
#[allow(missing_docs)]
pub id: alloy::sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub addr: 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::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::FixedBytes<32>,
alloy::sol_types::private::Address,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<NoContractCode> for UnderlyingRustTuple<'_> {
fn from(value: NoContractCode) -> Self {
(value.id, value.addr)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for NoContractCode {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { id: tuple.0, addr: tuple.1 }
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for NoContractCode {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "NoContractCode(bytes32,address)";
const SELECTOR: [u8; 4] = [86u8, 58u8, 50u8, 132u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.id),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(Self::new)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct StringTooLong {
#[allow(missing_docs)]
pub str: alloy::sol_types::private::String,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<StringTooLong> for UnderlyingRustTuple<'_> {
fn from(value: StringTooLong) -> Self {
(value.str,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for StringTooLong {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { str: tuple.0 }
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for StringTooLong {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "StringTooLong(string)";
const SELECTOR: [u8; 4] = [48u8, 90u8, 39u8, 169u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.str,
),
)
}
#[inline]
fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(Self::new)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct ZeroAddress {
#[allow(missing_docs)]
pub id: 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::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<ZeroAddress> for UnderlyingRustTuple<'_> {
fn from(value: ZeroAddress) -> Self {
(value.id,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ZeroAddress {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { id: tuple.0 }
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for ZeroAddress {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "ZeroAddress(bytes32)";
const SELECTOR: [u8; 4] = [131u8, 207u8, 74u8, 43u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.id),
)
}
#[inline]
fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(Self::new)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct AddressSet {
#[allow(missing_docs)]
pub id: alloy::sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub oldAddress: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub newAddress: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for AddressSet {
type DataTuple<'a> = ();
type DataToken<'a> = <Self::DataTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (
alloy_sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
const SIGNATURE: &'static str = "AddressSet(bytes32,address,address)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
158u8, 240u8, 232u8, 200u8, 229u8, 39u8, 67u8, 187u8, 56u8, 184u8, 59u8,
23u8, 217u8, 66u8, 145u8, 65u8, 212u8, 148u8, 184u8, 4u8, 28u8, 166u8,
214u8, 22u8, 166u8, 199u8, 124u8, 235u8, 174u8, 156u8, 216u8, 183u8,
]);
const ANONYMOUS: bool = false;
#[allow(unused_variables)]
#[inline]
fn new(
topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
) -> Self {
Self {
id: topics.1,
oldAddress: topics.2,
newAddress: topics.3,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(
alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
),
);
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
()
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(
Self::SIGNATURE_HASH.into(),
self.id.clone(),
self.oldAddress.clone(),
self.newAddress.clone(),
)
}
#[inline]
fn encode_topics_raw(
&self,
out: &mut [alloy_sol_types::abi::token::WordToken],
) -> alloy_sol_types::Result<()> {
if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
return Err(alloy_sol_types::Error::Overrun);
}
out[0usize] = alloy_sol_types::abi::token::WordToken(
Self::SIGNATURE_HASH,
);
out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::EventTopic>::encode_topic(&self.id);
out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.oldAddress,
);
out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.newAddress,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for AddressSet {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
From::from(self)
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
From::from(&self)
}
}
#[automatically_derived]
impl From<&AddressSet> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &AddressSet) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct Initialized {
#[allow(missing_docs)]
pub version: u8,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for Initialized {
type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
type DataToken<'a> = <Self::DataTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
const SIGNATURE: &'static str = "Initialized(uint8)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
]);
const ANONYMOUS: bool = false;
#[allow(unused_variables)]
#[inline]
fn new(
topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
) -> Self {
Self { version: data.0 }
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(
alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
),
);
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
(
<alloy::sol_types::sol_data::Uint<
8,
> as alloy_sol_types::SolType>::tokenize(&self.version),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(Self::SIGNATURE_HASH.into(),)
}
#[inline]
fn encode_topics_raw(
&self,
out: &mut [alloy_sol_types::abi::token::WordToken],
) -> alloy_sol_types::Result<()> {
if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
return Err(alloy_sol_types::Error::Overrun);
}
out[0usize] = alloy_sol_types::abi::token::WordToken(
Self::SIGNATURE_HASH,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for Initialized {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
From::from(self)
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
From::from(&self)
}
}
#[automatically_derived]
impl From<&Initialized> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct OwnershipTransferred {
#[allow(missing_docs)]
pub previousOwner: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub newOwner: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for OwnershipTransferred {
type DataTuple<'a> = ();
type DataToken<'a> = <Self::DataTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (
alloy_sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
]);
const ANONYMOUS: bool = false;
#[allow(unused_variables)]
#[inline]
fn new(
topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
) -> Self {
Self {
previousOwner: topics.1,
newOwner: topics.2,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(
alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
),
);
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
()
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(
Self::SIGNATURE_HASH.into(),
self.previousOwner.clone(),
self.newOwner.clone(),
)
}
#[inline]
fn encode_topics_raw(
&self,
out: &mut [alloy_sol_types::abi::token::WordToken],
) -> alloy_sol_types::Result<()> {
if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
return Err(alloy_sol_types::Error::Overrun);
}
out[0usize] = alloy_sol_types::abi::token::WordToken(
Self::SIGNATURE_HASH,
);
out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.previousOwner,
);
out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.newOwner,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
From::from(self)
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
From::from(&self)
}
}
#[automatically_derived]
impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
alloy_sol_types::SolEvent::encode_log_data(this)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct constructorCall {
#[allow(missing_docs)]
pub _version: alloy::sol_types::private::String,
}
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
fn from(value: constructorCall) -> Self {
(value._version,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _version: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolConstructor for constructorCall {
type Parameters<'a> = (alloy::sol_types::sol_data::String,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self._version,
),
)
}
}
};
#[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 ATTESTATION_VALIDATORCall;
#[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 ATTESTATION_VALIDATORReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<ATTESTATION_VALIDATORCall>
for UnderlyingRustTuple<'_> {
fn from(value: ATTESTATION_VALIDATORCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for ATTESTATION_VALIDATORCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<ATTESTATION_VALIDATORReturn>
for UnderlyingRustTuple<'_> {
fn from(value: ATTESTATION_VALIDATORReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for ATTESTATION_VALIDATORReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for ATTESTATION_VALIDATORCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "ATTESTATION_VALIDATOR()";
const SELECTOR: [u8; 4] = [199u8, 63u8, 24u8, 27u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: ATTESTATION_VALIDATORReturn = 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: ATTESTATION_VALIDATORReturn = 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 BATCH_TASK_MANAGERCall;
#[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 BATCH_TASK_MANAGERReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<BATCH_TASK_MANAGERCall>
for UnderlyingRustTuple<'_> {
fn from(value: BATCH_TASK_MANAGERCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for BATCH_TASK_MANAGERCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<BATCH_TASK_MANAGERReturn>
for UnderlyingRustTuple<'_> {
fn from(value: BATCH_TASK_MANAGERReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for BATCH_TASK_MANAGERReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for BATCH_TASK_MANAGERCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "BATCH_TASK_MANAGER()";
const SELECTOR: [u8; 4] = [40u8, 48u8, 29u8, 197u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: BATCH_TASK_MANAGERReturn = 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: BATCH_TASK_MANAGERReturn = 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 CHALLENGE_VERIFIERCall;
#[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 CHALLENGE_VERIFIERReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<CHALLENGE_VERIFIERCall>
for UnderlyingRustTuple<'_> {
fn from(value: CHALLENGE_VERIFIERCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for CHALLENGE_VERIFIERCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<CHALLENGE_VERIFIERReturn>
for UnderlyingRustTuple<'_> {
fn from(value: CHALLENGE_VERIFIERReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for CHALLENGE_VERIFIERReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for CHALLENGE_VERIFIERCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "CHALLENGE_VERIFIER()";
const SELECTOR: [u8; 4] = [135u8, 176u8, 97u8, 121u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: CHALLENGE_VERIFIERReturn = 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: CHALLENGE_VERIFIERReturn = 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 CONFIDENTIAL_DATA_REGISTRYCall;
#[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 CONFIDENTIAL_DATA_REGISTRYReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<CONFIDENTIAL_DATA_REGISTRYCall>
for UnderlyingRustTuple<'_> {
fn from(value: CONFIDENTIAL_DATA_REGISTRYCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for CONFIDENTIAL_DATA_REGISTRYCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<CONFIDENTIAL_DATA_REGISTRYReturn>
for UnderlyingRustTuple<'_> {
fn from(value: CONFIDENTIAL_DATA_REGISTRYReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for CONFIDENTIAL_DATA_REGISTRYReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for CONFIDENTIAL_DATA_REGISTRYCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "CONFIDENTIAL_DATA_REGISTRY()";
const SELECTOR: [u8; 4] = [92u8, 152u8, 210u8, 41u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: CONFIDENTIAL_DATA_REGISTRYReturn = 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: CONFIDENTIAL_DATA_REGISTRYReturn = 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 ENCLAVE_VERSION_REGISTRYCall;
#[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 ENCLAVE_VERSION_REGISTRYReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<ENCLAVE_VERSION_REGISTRYCall>
for UnderlyingRustTuple<'_> {
fn from(value: ENCLAVE_VERSION_REGISTRYCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for ENCLAVE_VERSION_REGISTRYCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<ENCLAVE_VERSION_REGISTRYReturn>
for UnderlyingRustTuple<'_> {
fn from(value: ENCLAVE_VERSION_REGISTRYReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for ENCLAVE_VERSION_REGISTRYReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for ENCLAVE_VERSION_REGISTRYCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "ENCLAVE_VERSION_REGISTRY()";
const SELECTOR: [u8; 4] = [224u8, 219u8, 131u8, 226u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: ENCLAVE_VERSION_REGISTRYReturn = 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: ENCLAVE_VERSION_REGISTRYReturn = 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 EPOCH_REGISTRYCall;
#[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 EPOCH_REGISTRYReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<EPOCH_REGISTRYCall> for UnderlyingRustTuple<'_> {
fn from(value: EPOCH_REGISTRYCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for EPOCH_REGISTRYCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<EPOCH_REGISTRYReturn>
for UnderlyingRustTuple<'_> {
fn from(value: EPOCH_REGISTRYReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for EPOCH_REGISTRYReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for EPOCH_REGISTRYCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "EPOCH_REGISTRY()";
const SELECTOR: [u8; 4] = [115u8, 109u8, 88u8, 13u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: EPOCH_REGISTRYReturn = 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: EPOCH_REGISTRYReturn = 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 IDENTITY_REGISTRYCall;
#[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 IDENTITY_REGISTRYReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<IDENTITY_REGISTRYCall>
for UnderlyingRustTuple<'_> {
fn from(value: IDENTITY_REGISTRYCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for IDENTITY_REGISTRYCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<IDENTITY_REGISTRYReturn>
for UnderlyingRustTuple<'_> {
fn from(value: IDENTITY_REGISTRYReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for IDENTITY_REGISTRYReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for IDENTITY_REGISTRYCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "IDENTITY_REGISTRY()";
const SELECTOR: [u8; 4] = [101u8, 250u8, 208u8, 39u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: IDENTITY_REGISTRYReturn = 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: IDENTITY_REGISTRYReturn = 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 OPERATOR_REGISTRYCall;
#[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 OPERATOR_REGISTRYReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<OPERATOR_REGISTRYCall>
for UnderlyingRustTuple<'_> {
fn from(value: OPERATOR_REGISTRYCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for OPERATOR_REGISTRYCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<OPERATOR_REGISTRYReturn>
for UnderlyingRustTuple<'_> {
fn from(value: OPERATOR_REGISTRYReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for OPERATOR_REGISTRYReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for OPERATOR_REGISTRYCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "OPERATOR_REGISTRY()";
const SELECTOR: [u8; 4] = [131u8, 206u8, 3u8, 34u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: OPERATOR_REGISTRYReturn = 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: OPERATOR_REGISTRYReturn = 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 POLICY_CLIENT_REGISTRYCall;
#[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 POLICY_CLIENT_REGISTRYReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<POLICY_CLIENT_REGISTRYCall>
for UnderlyingRustTuple<'_> {
fn from(value: POLICY_CLIENT_REGISTRYCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for POLICY_CLIENT_REGISTRYCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<POLICY_CLIENT_REGISTRYReturn>
for UnderlyingRustTuple<'_> {
fn from(value: POLICY_CLIENT_REGISTRYReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for POLICY_CLIENT_REGISTRYReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for POLICY_CLIENT_REGISTRYCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "POLICY_CLIENT_REGISTRY()";
const SELECTOR: [u8; 4] = [139u8, 66u8, 74u8, 87u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: POLICY_CLIENT_REGISTRYReturn = 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: POLICY_CLIENT_REGISTRYReturn = 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 POLICY_DATA_FACTORYCall;
#[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 POLICY_DATA_FACTORYReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<POLICY_DATA_FACTORYCall>
for UnderlyingRustTuple<'_> {
fn from(value: POLICY_DATA_FACTORYCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for POLICY_DATA_FACTORYCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<POLICY_DATA_FACTORYReturn>
for UnderlyingRustTuple<'_> {
fn from(value: POLICY_DATA_FACTORYReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for POLICY_DATA_FACTORYReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for POLICY_DATA_FACTORYCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "POLICY_DATA_FACTORY()";
const SELECTOR: [u8; 4] = [126u8, 125u8, 126u8, 232u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: POLICY_DATA_FACTORYReturn = 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: POLICY_DATA_FACTORYReturn = 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 POLICY_FACTORYCall;
#[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 POLICY_FACTORYReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<POLICY_FACTORYCall> for UnderlyingRustTuple<'_> {
fn from(value: POLICY_FACTORYCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for POLICY_FACTORYCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<POLICY_FACTORYReturn>
for UnderlyingRustTuple<'_> {
fn from(value: POLICY_FACTORYReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for POLICY_FACTORYReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for POLICY_FACTORYCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "POLICY_FACTORY()";
const SELECTOR: [u8; 4] = [130u8, 41u8, 212u8, 102u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: POLICY_FACTORYReturn = 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: POLICY_FACTORYReturn = 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 REGO_VERIFIERCall;
#[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 REGO_VERIFIERReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<REGO_VERIFIERCall> for UnderlyingRustTuple<'_> {
fn from(value: REGO_VERIFIERCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for REGO_VERIFIERCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<REGO_VERIFIERReturn> for UnderlyingRustTuple<'_> {
fn from(value: REGO_VERIFIERReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for REGO_VERIFIERReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for REGO_VERIFIERCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "REGO_VERIFIER()";
const SELECTOR: [u8; 4] = [42u8, 196u8, 217u8, 130u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: REGO_VERIFIERReturn = 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: REGO_VERIFIERReturn = 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 SERVICE_MANAGERCall;
#[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 SERVICE_MANAGERReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<SERVICE_MANAGERCall> for UnderlyingRustTuple<'_> {
fn from(value: SERVICE_MANAGERCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for SERVICE_MANAGERCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<SERVICE_MANAGERReturn>
for UnderlyingRustTuple<'_> {
fn from(value: SERVICE_MANAGERReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for SERVICE_MANAGERReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for SERVICE_MANAGERCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "SERVICE_MANAGER()";
const SELECTOR: [u8; 4] = [27u8, 172u8, 158u8, 178u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: SERVICE_MANAGERReturn = 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: SERVICE_MANAGERReturn = 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 SOCKET_REGISTRYCall;
#[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 SOCKET_REGISTRYReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<SOCKET_REGISTRYCall> for UnderlyingRustTuple<'_> {
fn from(value: SOCKET_REGISTRYCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for SOCKET_REGISTRYCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<SOCKET_REGISTRYReturn>
for UnderlyingRustTuple<'_> {
fn from(value: SOCKET_REGISTRYReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for SOCKET_REGISTRYReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for SOCKET_REGISTRYCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "SOCKET_REGISTRY()";
const SELECTOR: [u8; 4] = [143u8, 43u8, 120u8, 106u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: SOCKET_REGISTRYReturn = 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: SOCKET_REGISTRYReturn = 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 STATE_COMMIT_REGISTRYCall;
#[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 STATE_COMMIT_REGISTRYReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<STATE_COMMIT_REGISTRYCall>
for UnderlyingRustTuple<'_> {
fn from(value: STATE_COMMIT_REGISTRYCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for STATE_COMMIT_REGISTRYCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<STATE_COMMIT_REGISTRYReturn>
for UnderlyingRustTuple<'_> {
fn from(value: STATE_COMMIT_REGISTRYReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for STATE_COMMIT_REGISTRYReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for STATE_COMMIT_REGISTRYCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "STATE_COMMIT_REGISTRY()";
const SELECTOR: [u8; 4] = [89u8, 59u8, 199u8, 147u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: STATE_COMMIT_REGISTRYReturn = 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: STATE_COMMIT_REGISTRYReturn = 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 TASK_MANAGERCall;
#[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 TASK_MANAGERReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<TASK_MANAGERCall> for UnderlyingRustTuple<'_> {
fn from(value: TASK_MANAGERCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for TASK_MANAGERCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<TASK_MANAGERReturn> for UnderlyingRustTuple<'_> {
fn from(value: TASK_MANAGERReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for TASK_MANAGERReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for TASK_MANAGERCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "TASK_MANAGER()";
const SELECTOR: [u8; 4] = [58u8, 194u8, 87u8, 224u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: TASK_MANAGERReturn = 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: TASK_MANAGERReturn = 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 VIEW_BN254_CERTIFICATE_VERIFIERCall;
#[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 VIEW_BN254_CERTIFICATE_VERIFIERReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<VIEW_BN254_CERTIFICATE_VERIFIERCall>
for UnderlyingRustTuple<'_> {
fn from(value: VIEW_BN254_CERTIFICATE_VERIFIERCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for VIEW_BN254_CERTIFICATE_VERIFIERCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<VIEW_BN254_CERTIFICATE_VERIFIERReturn>
for UnderlyingRustTuple<'_> {
fn from(value: VIEW_BN254_CERTIFICATE_VERIFIERReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for VIEW_BN254_CERTIFICATE_VERIFIERReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for VIEW_BN254_CERTIFICATE_VERIFIERCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::FixedBytes<32>;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "VIEW_BN254_CERTIFICATE_VERIFIER()";
const SELECTOR: [u8; 4] = [81u8, 220u8, 231u8, 226u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: VIEW_BN254_CERTIFICATE_VERIFIERReturn = 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: VIEW_BN254_CERTIFICATE_VERIFIERReturn = 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 getAddressCall {
#[allow(missing_docs)]
pub id: alloy::sol_types::private::FixedBytes<32>,
}
#[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 getAddressReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getAddressCall> for UnderlyingRustTuple<'_> {
fn from(value: getAddressCall) -> Self {
(value.id,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAddressCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { id: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getAddressReturn> for UnderlyingRustTuple<'_> {
fn from(value: getAddressReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAddressReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getAddressCall {
type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getAddress(bytes32)";
const SELECTOR: [u8; 4] = [33u8, 248u8, 167u8, 33u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.id),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getAddressReturn = 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: getAddressReturn = 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 getAttestationValidatorCall;
#[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 getAttestationValidatorReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getAttestationValidatorCall>
for UnderlyingRustTuple<'_> {
fn from(value: getAttestationValidatorCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getAttestationValidatorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getAttestationValidatorReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getAttestationValidatorReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getAttestationValidatorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getAttestationValidatorCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getAttestationValidator()";
const SELECTOR: [u8; 4] = [203u8, 72u8, 106u8, 147u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getAttestationValidatorReturn = 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: getAttestationValidatorReturn = 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 getBatchTaskManagerCall;
#[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 getBatchTaskManagerReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getBatchTaskManagerCall>
for UnderlyingRustTuple<'_> {
fn from(value: getBatchTaskManagerCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getBatchTaskManagerCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getBatchTaskManagerReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getBatchTaskManagerReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getBatchTaskManagerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getBatchTaskManagerCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getBatchTaskManager()";
const SELECTOR: [u8; 4] = [137u8, 243u8, 205u8, 140u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getBatchTaskManagerReturn = 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: getBatchTaskManagerReturn = 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 getChallengeVerifierCall;
#[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 getChallengeVerifierReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getChallengeVerifierCall>
for UnderlyingRustTuple<'_> {
fn from(value: getChallengeVerifierCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getChallengeVerifierCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getChallengeVerifierReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getChallengeVerifierReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getChallengeVerifierReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getChallengeVerifierCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getChallengeVerifier()";
const SELECTOR: [u8; 4] = [66u8, 169u8, 221u8, 235u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getChallengeVerifierReturn = 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: getChallengeVerifierReturn = 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 getConfidentialDataRegistryCall;
#[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 getConfidentialDataRegistryReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getConfidentialDataRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: getConfidentialDataRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getConfidentialDataRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getConfidentialDataRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getConfidentialDataRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getConfidentialDataRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getConfidentialDataRegistryCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getConfidentialDataRegistry()";
const SELECTOR: [u8; 4] = [185u8, 119u8, 89u8, 1u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getConfidentialDataRegistryReturn = 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: getConfidentialDataRegistryReturn = 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 getEnclaveVersionRegistryCall;
#[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 getEnclaveVersionRegistryReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getEnclaveVersionRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: getEnclaveVersionRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getEnclaveVersionRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getEnclaveVersionRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getEnclaveVersionRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getEnclaveVersionRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getEnclaveVersionRegistryCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getEnclaveVersionRegistry()";
const SELECTOR: [u8; 4] = [181u8, 139u8, 53u8, 188u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getEnclaveVersionRegistryReturn = 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: getEnclaveVersionRegistryReturn = 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 getEpochRegistryCall;
#[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 getEpochRegistryReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getEpochRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: getEpochRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getEpochRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getEpochRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getEpochRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getEpochRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getEpochRegistryCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getEpochRegistry()";
const SELECTOR: [u8; 4] = [27u8, 182u8, 93u8, 83u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getEpochRegistryReturn = 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: getEpochRegistryReturn = 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 getIdentityRegistryCall;
#[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 getIdentityRegistryReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getIdentityRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: getIdentityRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getIdentityRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getIdentityRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getIdentityRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getIdentityRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getIdentityRegistryCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getIdentityRegistry()";
const SELECTOR: [u8; 4] = [188u8, 77u8, 134u8, 27u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getIdentityRegistryReturn = 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: getIdentityRegistryReturn = 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 getOperatorRegistryCall;
#[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 getOperatorRegistryReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getOperatorRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: getOperatorRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getOperatorRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getOperatorRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getOperatorRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getOperatorRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getOperatorRegistryCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getOperatorRegistry()";
const SELECTOR: [u8; 4] = [253u8, 46u8, 2u8, 229u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getOperatorRegistryReturn = 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: getOperatorRegistryReturn = 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 getPolicyClientRegistryCall;
#[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 getPolicyClientRegistryReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getPolicyClientRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: getPolicyClientRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getPolicyClientRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getPolicyClientRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getPolicyClientRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getPolicyClientRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getPolicyClientRegistryCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getPolicyClientRegistry()";
const SELECTOR: [u8; 4] = [222u8, 176u8, 134u8, 90u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getPolicyClientRegistryReturn = 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: getPolicyClientRegistryReturn = 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 getPolicyDataFactoryCall;
#[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 getPolicyDataFactoryReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getPolicyDataFactoryCall>
for UnderlyingRustTuple<'_> {
fn from(value: getPolicyDataFactoryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getPolicyDataFactoryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getPolicyDataFactoryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getPolicyDataFactoryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getPolicyDataFactoryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getPolicyDataFactoryCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getPolicyDataFactory()";
const SELECTOR: [u8; 4] = [253u8, 123u8, 98u8, 33u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getPolicyDataFactoryReturn = 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: getPolicyDataFactoryReturn = 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 getPolicyFactoryCall;
#[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 getPolicyFactoryReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getPolicyFactoryCall>
for UnderlyingRustTuple<'_> {
fn from(value: getPolicyFactoryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getPolicyFactoryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getPolicyFactoryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getPolicyFactoryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getPolicyFactoryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getPolicyFactoryCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getPolicyFactory()";
const SELECTOR: [u8; 4] = [62u8, 19u8, 71u8, 162u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getPolicyFactoryReturn = 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: getPolicyFactoryReturn = 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 getRegoVerifierCall;
#[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 getRegoVerifierReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getRegoVerifierCall> for UnderlyingRustTuple<'_> {
fn from(value: getRegoVerifierCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRegoVerifierCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getRegoVerifierReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getRegoVerifierReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getRegoVerifierReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getRegoVerifierCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getRegoVerifier()";
const SELECTOR: [u8; 4] = [190u8, 157u8, 70u8, 190u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::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: getRegoVerifierReturn = 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: getRegoVerifierReturn = 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 getServiceManagerCall;
#[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 getServiceManagerReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getServiceManagerCall>
for UnderlyingRustTuple<'_> {
fn from(value: getServiceManagerCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getServiceManagerCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getServiceManagerReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getServiceManagerReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getServiceManagerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getServiceManagerCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getServiceManager()";
const SELECTOR: [u8; 4] = [77u8, 218u8, 11u8, 67u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getServiceManagerReturn = 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: getServiceManagerReturn = 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 getSocketRegistryCall;
#[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 getSocketRegistryReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getSocketRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: getSocketRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getSocketRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getSocketRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getSocketRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getSocketRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getSocketRegistryCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getSocketRegistry()";
const SELECTOR: [u8; 4] = [74u8, 4u8, 136u8, 105u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getSocketRegistryReturn = 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: getSocketRegistryReturn = 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 getStateCommitRegistryCall;
#[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 getStateCommitRegistryReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getStateCommitRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: getStateCommitRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getStateCommitRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getStateCommitRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getStateCommitRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getStateCommitRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getStateCommitRegistryCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getStateCommitRegistry()";
const SELECTOR: [u8; 4] = [220u8, 58u8, 17u8, 127u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getStateCommitRegistryReturn = 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: getStateCommitRegistryReturn = 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 getTaskManagerCall;
#[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 getTaskManagerReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getTaskManagerCall> for UnderlyingRustTuple<'_> {
fn from(value: getTaskManagerCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTaskManagerCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getTaskManagerReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getTaskManagerReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getTaskManagerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getTaskManagerCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getTaskManager()";
const SELECTOR: [u8; 4] = [116u8, 227u8, 217u8, 73u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getTaskManagerReturn = 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: getTaskManagerReturn = 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 getViewBN254CertificateVerifierCall;
#[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 getViewBN254CertificateVerifierReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getViewBN254CertificateVerifierCall>
for UnderlyingRustTuple<'_> {
fn from(value: getViewBN254CertificateVerifierCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getViewBN254CertificateVerifierCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getViewBN254CertificateVerifierReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getViewBN254CertificateVerifierReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getViewBN254CertificateVerifierReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getViewBN254CertificateVerifierCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getViewBN254CertificateVerifier()";
const SELECTOR: [u8; 4] = [19u8, 152u8, 45u8, 82u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: getViewBN254CertificateVerifierReturn = 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: getViewBN254CertificateVerifierReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct initializeCall {
#[allow(missing_docs)]
pub _owner: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct initializeReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
fn from(value: initializeCall) -> Self {
(value._owner,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _owner: 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<initializeReturn> for UnderlyingRustTuple<'_> {
fn from(value: initializeReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl initializeReturn {
fn _tokenize(
&self,
) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for initializeCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = initializeReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "initialize(address)";
const SELECTOR: [u8; 4] = [196u8, 214u8, 109u8, 232u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self._owner,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
initializeReturn::_tokenize(ret)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(Into::into)
}
#[inline]
fn abi_decode_returns_validate(
data: &[u8],
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(Into::into)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct ownerCall;
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct ownerReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
fn from(value: ownerCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
fn from(value: ownerReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for ownerCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "owner()";
const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: ownerReturn = r.into();
r._0
})
}
#[inline]
fn abi_decode_returns_validate(
data: &[u8],
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(|r| {
let r: ownerReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct renounceOwnershipCall;
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct renounceOwnershipReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<renounceOwnershipCall>
for UnderlyingRustTuple<'_> {
fn from(value: renounceOwnershipCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for renounceOwnershipCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<renounceOwnershipReturn>
for UnderlyingRustTuple<'_> {
fn from(value: renounceOwnershipReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for renounceOwnershipReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl renounceOwnershipReturn {
fn _tokenize(
&self,
) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for renounceOwnershipCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = renounceOwnershipReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "renounceOwnership()";
const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
renounceOwnershipReturn::_tokenize(ret)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(Into::into)
}
#[inline]
fn abi_decode_returns_validate(
data: &[u8],
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(Into::into)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setAddressCall {
#[allow(missing_docs)]
pub id: alloy::sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setAddressReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::FixedBytes<32>,
alloy::sol_types::private::Address,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setAddressCall> for UnderlyingRustTuple<'_> {
fn from(value: setAddressCall) -> Self {
(value.id, value.addr)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAddressCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { id: tuple.0, addr: 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<setAddressReturn> for UnderlyingRustTuple<'_> {
fn from(value: setAddressReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAddressReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setAddressReturn {
fn _tokenize(
&self,
) -> <setAddressCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setAddressCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setAddressReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setAddress(bytes32,address)";
const SELECTOR: [u8; 4] = [202u8, 68u8, 109u8, 217u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.id),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setAddressReturn::_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 setAttestationValidatorCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setAttestationValidatorReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setAttestationValidatorCall>
for UnderlyingRustTuple<'_> {
fn from(value: setAttestationValidatorCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setAttestationValidatorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setAttestationValidatorReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setAttestationValidatorReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setAttestationValidatorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setAttestationValidatorReturn {
fn _tokenize(
&self,
) -> <setAttestationValidatorCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setAttestationValidatorCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setAttestationValidatorReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setAttestationValidator(address)";
const SELECTOR: [u8; 4] = [138u8, 104u8, 69u8, 83u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setAttestationValidatorReturn::_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 setBatchTaskManagerCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setBatchTaskManagerReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setBatchTaskManagerCall>
for UnderlyingRustTuple<'_> {
fn from(value: setBatchTaskManagerCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setBatchTaskManagerCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setBatchTaskManagerReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setBatchTaskManagerReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setBatchTaskManagerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setBatchTaskManagerReturn {
fn _tokenize(
&self,
) -> <setBatchTaskManagerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setBatchTaskManagerCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setBatchTaskManagerReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setBatchTaskManager(address)";
const SELECTOR: [u8; 4] = [169u8, 184u8, 138u8, 225u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setBatchTaskManagerReturn::_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 setChallengeVerifierCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setChallengeVerifierReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setChallengeVerifierCall>
for UnderlyingRustTuple<'_> {
fn from(value: setChallengeVerifierCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setChallengeVerifierCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setChallengeVerifierReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setChallengeVerifierReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setChallengeVerifierReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setChallengeVerifierReturn {
fn _tokenize(
&self,
) -> <setChallengeVerifierCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setChallengeVerifierCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setChallengeVerifierReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setChallengeVerifier(address)";
const SELECTOR: [u8; 4] = [169u8, 127u8, 180u8, 77u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setChallengeVerifierReturn::_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 setConfidentialDataRegistryCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setConfidentialDataRegistryReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setConfidentialDataRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: setConfidentialDataRegistryCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setConfidentialDataRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setConfidentialDataRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setConfidentialDataRegistryReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setConfidentialDataRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setConfidentialDataRegistryReturn {
fn _tokenize(
&self,
) -> <setConfidentialDataRegistryCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setConfidentialDataRegistryCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setConfidentialDataRegistryReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setConfidentialDataRegistry(address)";
const SELECTOR: [u8; 4] = [114u8, 22u8, 39u8, 61u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setConfidentialDataRegistryReturn::_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 setEnclaveVersionRegistryCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setEnclaveVersionRegistryReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setEnclaveVersionRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: setEnclaveVersionRegistryCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setEnclaveVersionRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setEnclaveVersionRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setEnclaveVersionRegistryReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setEnclaveVersionRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setEnclaveVersionRegistryReturn {
fn _tokenize(
&self,
) -> <setEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setEnclaveVersionRegistryCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setEnclaveVersionRegistryReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setEnclaveVersionRegistry(address)";
const SELECTOR: [u8; 4] = [204u8, 31u8, 53u8, 27u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setEnclaveVersionRegistryReturn::_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 setEpochRegistryCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setEpochRegistryReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setEpochRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: setEpochRegistryCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setEpochRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setEpochRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setEpochRegistryReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setEpochRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setEpochRegistryReturn {
fn _tokenize(
&self,
) -> <setEpochRegistryCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setEpochRegistryCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setEpochRegistryReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setEpochRegistry(address)";
const SELECTOR: [u8; 4] = [112u8, 40u8, 240u8, 143u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setEpochRegistryReturn::_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 setIdentityRegistryCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setIdentityRegistryReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setIdentityRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: setIdentityRegistryCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setIdentityRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setIdentityRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setIdentityRegistryReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setIdentityRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setIdentityRegistryReturn {
fn _tokenize(
&self,
) -> <setIdentityRegistryCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setIdentityRegistryCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setIdentityRegistryReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setIdentityRegistry(address)";
const SELECTOR: [u8; 4] = [203u8, 243u8, 248u8, 97u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setIdentityRegistryReturn::_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 setOperatorRegistryCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setOperatorRegistryReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setOperatorRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: setOperatorRegistryCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setOperatorRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setOperatorRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setOperatorRegistryReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setOperatorRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setOperatorRegistryReturn {
fn _tokenize(
&self,
) -> <setOperatorRegistryCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setOperatorRegistryCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setOperatorRegistryReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setOperatorRegistry(address)";
const SELECTOR: [u8; 4] = [157u8, 40u8, 251u8, 134u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setOperatorRegistryReturn::_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 setPolicyClientRegistryCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setPolicyClientRegistryReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setPolicyClientRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: setPolicyClientRegistryCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setPolicyClientRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setPolicyClientRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setPolicyClientRegistryReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setPolicyClientRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setPolicyClientRegistryReturn {
fn _tokenize(
&self,
) -> <setPolicyClientRegistryCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setPolicyClientRegistryCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setPolicyClientRegistryReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setPolicyClientRegistry(address)";
const SELECTOR: [u8; 4] = [101u8, 179u8, 174u8, 177u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setPolicyClientRegistryReturn::_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 setPolicyDataFactoryCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setPolicyDataFactoryReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setPolicyDataFactoryCall>
for UnderlyingRustTuple<'_> {
fn from(value: setPolicyDataFactoryCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setPolicyDataFactoryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setPolicyDataFactoryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setPolicyDataFactoryReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setPolicyDataFactoryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setPolicyDataFactoryReturn {
fn _tokenize(
&self,
) -> <setPolicyDataFactoryCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setPolicyDataFactoryCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setPolicyDataFactoryReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setPolicyDataFactory(address)";
const SELECTOR: [u8; 4] = [60u8, 99u8, 229u8, 178u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setPolicyDataFactoryReturn::_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 setPolicyFactoryCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setPolicyFactoryReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setPolicyFactoryCall>
for UnderlyingRustTuple<'_> {
fn from(value: setPolicyFactoryCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setPolicyFactoryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setPolicyFactoryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setPolicyFactoryReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setPolicyFactoryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setPolicyFactoryReturn {
fn _tokenize(
&self,
) -> <setPolicyFactoryCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setPolicyFactoryCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setPolicyFactoryReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setPolicyFactory(address)";
const SELECTOR: [u8; 4] = [236u8, 50u8, 179u8, 149u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setPolicyFactoryReturn::_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 setRegoVerifierCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setRegoVerifierReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setRegoVerifierCall> for UnderlyingRustTuple<'_> {
fn from(value: setRegoVerifierCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for setRegoVerifierCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setRegoVerifierReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setRegoVerifierReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setRegoVerifierReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setRegoVerifierReturn {
fn _tokenize(
&self,
) -> <setRegoVerifierCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setRegoVerifierCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setRegoVerifierReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setRegoVerifier(address)";
const SELECTOR: [u8; 4] = [157u8, 226u8, 77u8, 132u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setRegoVerifierReturn::_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 setServiceManagerCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setServiceManagerReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setServiceManagerCall>
for UnderlyingRustTuple<'_> {
fn from(value: setServiceManagerCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setServiceManagerCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setServiceManagerReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setServiceManagerReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setServiceManagerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setServiceManagerReturn {
fn _tokenize(
&self,
) -> <setServiceManagerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setServiceManagerCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setServiceManagerReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setServiceManager(address)";
const SELECTOR: [u8; 4] = [155u8, 65u8, 191u8, 35u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setServiceManagerReturn::_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 setSocketRegistryCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setSocketRegistryReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setSocketRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: setSocketRegistryCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setSocketRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setSocketRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setSocketRegistryReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setSocketRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setSocketRegistryReturn {
fn _tokenize(
&self,
) -> <setSocketRegistryCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setSocketRegistryCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setSocketRegistryReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setSocketRegistry(address)";
const SELECTOR: [u8; 4] = [148u8, 246u8, 171u8, 252u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setSocketRegistryReturn::_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 setStateCommitRegistryCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setStateCommitRegistryReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setStateCommitRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: setStateCommitRegistryCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setStateCommitRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setStateCommitRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setStateCommitRegistryReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setStateCommitRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setStateCommitRegistryReturn {
fn _tokenize(
&self,
) -> <setStateCommitRegistryCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setStateCommitRegistryCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setStateCommitRegistryReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setStateCommitRegistry(address)";
const SELECTOR: [u8; 4] = [74u8, 33u8, 96u8, 57u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setStateCommitRegistryReturn::_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 setTaskManagerCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setTaskManagerReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setTaskManagerCall> for UnderlyingRustTuple<'_> {
fn from(value: setTaskManagerCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for setTaskManagerCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setTaskManagerReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setTaskManagerReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setTaskManagerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setTaskManagerReturn {
fn _tokenize(
&self,
) -> <setTaskManagerCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setTaskManagerCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setTaskManagerReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setTaskManager(address)";
const SELECTOR: [u8; 4] = [50u8, 125u8, 10u8, 96u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setTaskManagerReturn::_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 setViewBN254CertificateVerifierCall {
#[allow(missing_docs)]
pub addr: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct setViewBN254CertificateVerifierReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<setViewBN254CertificateVerifierCall>
for UnderlyingRustTuple<'_> {
fn from(value: setViewBN254CertificateVerifierCall) -> Self {
(value.addr,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setViewBN254CertificateVerifierCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { addr: 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<setViewBN254CertificateVerifierReturn>
for UnderlyingRustTuple<'_> {
fn from(value: setViewBN254CertificateVerifierReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for setViewBN254CertificateVerifierReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl setViewBN254CertificateVerifierReturn {
fn _tokenize(
&self,
) -> <setViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for setViewBN254CertificateVerifierCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = setViewBN254CertificateVerifierReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "setViewBN254CertificateVerifier(address)";
const SELECTOR: [u8; 4] = [149u8, 20u8, 174u8, 160u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.addr,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
setViewBN254CertificateVerifierReturn::_tokenize(ret)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(Into::into)
}
#[inline]
fn abi_decode_returns_validate(
data: &[u8],
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(Into::into)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct transferOwnershipCall {
#[allow(missing_docs)]
pub newOwner: alloy::sol_types::private::Address,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct transferOwnershipReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<transferOwnershipCall>
for UnderlyingRustTuple<'_> {
fn from(value: transferOwnershipCall) -> Self {
(value.newOwner,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for transferOwnershipCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { newOwner: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<transferOwnershipReturn>
for UnderlyingRustTuple<'_> {
fn from(value: transferOwnershipReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for transferOwnershipReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl transferOwnershipReturn {
fn _tokenize(
&self,
) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for transferOwnershipCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = transferOwnershipReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "transferOwnership(address)";
const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.newOwner,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
transferOwnershipReturn::_tokenize(ret)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(Into::into)
}
#[inline]
fn abi_decode_returns_validate(
data: &[u8],
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(Into::into)
}
}
};
#[derive(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 versionCall;
#[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 versionReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::String,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[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<versionCall> for UnderlyingRustTuple<'_> {
fn from(value: versionCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
fn from(value: versionReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for versionCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::String;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "version()";
const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: versionReturn = r.into();
r._0
})
}
#[inline]
fn abi_decode_returns_validate(
data: &[u8],
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(|r| {
let r: versionReturn = r.into();
r._0
})
}
}
};
#[derive(Clone)]
#[derive(serde::Serialize, serde::Deserialize)]
#[derive()]
pub enum NewtonAddressesProviderCalls {
#[allow(missing_docs)]
ATTESTATION_VALIDATOR(ATTESTATION_VALIDATORCall),
#[allow(missing_docs)]
BATCH_TASK_MANAGER(BATCH_TASK_MANAGERCall),
#[allow(missing_docs)]
CHALLENGE_VERIFIER(CHALLENGE_VERIFIERCall),
#[allow(missing_docs)]
CONFIDENTIAL_DATA_REGISTRY(CONFIDENTIAL_DATA_REGISTRYCall),
#[allow(missing_docs)]
ENCLAVE_VERSION_REGISTRY(ENCLAVE_VERSION_REGISTRYCall),
#[allow(missing_docs)]
EPOCH_REGISTRY(EPOCH_REGISTRYCall),
#[allow(missing_docs)]
IDENTITY_REGISTRY(IDENTITY_REGISTRYCall),
#[allow(missing_docs)]
OPERATOR_REGISTRY(OPERATOR_REGISTRYCall),
#[allow(missing_docs)]
POLICY_CLIENT_REGISTRY(POLICY_CLIENT_REGISTRYCall),
#[allow(missing_docs)]
POLICY_DATA_FACTORY(POLICY_DATA_FACTORYCall),
#[allow(missing_docs)]
POLICY_FACTORY(POLICY_FACTORYCall),
#[allow(missing_docs)]
REGO_VERIFIER(REGO_VERIFIERCall),
#[allow(missing_docs)]
SERVICE_MANAGER(SERVICE_MANAGERCall),
#[allow(missing_docs)]
SOCKET_REGISTRY(SOCKET_REGISTRYCall),
#[allow(missing_docs)]
STATE_COMMIT_REGISTRY(STATE_COMMIT_REGISTRYCall),
#[allow(missing_docs)]
TASK_MANAGER(TASK_MANAGERCall),
#[allow(missing_docs)]
VIEW_BN254_CERTIFICATE_VERIFIER(VIEW_BN254_CERTIFICATE_VERIFIERCall),
#[allow(missing_docs)]
getAddress(getAddressCall),
#[allow(missing_docs)]
getAttestationValidator(getAttestationValidatorCall),
#[allow(missing_docs)]
getBatchTaskManager(getBatchTaskManagerCall),
#[allow(missing_docs)]
getChallengeVerifier(getChallengeVerifierCall),
#[allow(missing_docs)]
getConfidentialDataRegistry(getConfidentialDataRegistryCall),
#[allow(missing_docs)]
getEnclaveVersionRegistry(getEnclaveVersionRegistryCall),
#[allow(missing_docs)]
getEpochRegistry(getEpochRegistryCall),
#[allow(missing_docs)]
getIdentityRegistry(getIdentityRegistryCall),
#[allow(missing_docs)]
getOperatorRegistry(getOperatorRegistryCall),
#[allow(missing_docs)]
getPolicyClientRegistry(getPolicyClientRegistryCall),
#[allow(missing_docs)]
getPolicyDataFactory(getPolicyDataFactoryCall),
#[allow(missing_docs)]
getPolicyFactory(getPolicyFactoryCall),
#[allow(missing_docs)]
getRegoVerifier(getRegoVerifierCall),
#[allow(missing_docs)]
getServiceManager(getServiceManagerCall),
#[allow(missing_docs)]
getSocketRegistry(getSocketRegistryCall),
#[allow(missing_docs)]
getStateCommitRegistry(getStateCommitRegistryCall),
#[allow(missing_docs)]
getTaskManager(getTaskManagerCall),
#[allow(missing_docs)]
getViewBN254CertificateVerifier(getViewBN254CertificateVerifierCall),
#[allow(missing_docs)]
initialize(initializeCall),
#[allow(missing_docs)]
owner(ownerCall),
#[allow(missing_docs)]
renounceOwnership(renounceOwnershipCall),
#[allow(missing_docs)]
setAddress(setAddressCall),
#[allow(missing_docs)]
setAttestationValidator(setAttestationValidatorCall),
#[allow(missing_docs)]
setBatchTaskManager(setBatchTaskManagerCall),
#[allow(missing_docs)]
setChallengeVerifier(setChallengeVerifierCall),
#[allow(missing_docs)]
setConfidentialDataRegistry(setConfidentialDataRegistryCall),
#[allow(missing_docs)]
setEnclaveVersionRegistry(setEnclaveVersionRegistryCall),
#[allow(missing_docs)]
setEpochRegistry(setEpochRegistryCall),
#[allow(missing_docs)]
setIdentityRegistry(setIdentityRegistryCall),
#[allow(missing_docs)]
setOperatorRegistry(setOperatorRegistryCall),
#[allow(missing_docs)]
setPolicyClientRegistry(setPolicyClientRegistryCall),
#[allow(missing_docs)]
setPolicyDataFactory(setPolicyDataFactoryCall),
#[allow(missing_docs)]
setPolicyFactory(setPolicyFactoryCall),
#[allow(missing_docs)]
setRegoVerifier(setRegoVerifierCall),
#[allow(missing_docs)]
setServiceManager(setServiceManagerCall),
#[allow(missing_docs)]
setSocketRegistry(setSocketRegistryCall),
#[allow(missing_docs)]
setStateCommitRegistry(setStateCommitRegistryCall),
#[allow(missing_docs)]
setTaskManager(setTaskManagerCall),
#[allow(missing_docs)]
setViewBN254CertificateVerifier(setViewBN254CertificateVerifierCall),
#[allow(missing_docs)]
transferOwnership(transferOwnershipCall),
#[allow(missing_docs)]
version(versionCall),
}
impl NewtonAddressesProviderCalls {
pub const SELECTORS: &'static [[u8; 4usize]] = &[
[19u8, 152u8, 45u8, 82u8],
[27u8, 172u8, 158u8, 178u8],
[27u8, 182u8, 93u8, 83u8],
[33u8, 248u8, 167u8, 33u8],
[40u8, 48u8, 29u8, 197u8],
[42u8, 196u8, 217u8, 130u8],
[50u8, 125u8, 10u8, 96u8],
[58u8, 194u8, 87u8, 224u8],
[60u8, 99u8, 229u8, 178u8],
[62u8, 19u8, 71u8, 162u8],
[66u8, 169u8, 221u8, 235u8],
[74u8, 4u8, 136u8, 105u8],
[74u8, 33u8, 96u8, 57u8],
[77u8, 218u8, 11u8, 67u8],
[81u8, 220u8, 231u8, 226u8],
[84u8, 253u8, 77u8, 80u8],
[89u8, 59u8, 199u8, 147u8],
[92u8, 152u8, 210u8, 41u8],
[101u8, 179u8, 174u8, 177u8],
[101u8, 250u8, 208u8, 39u8],
[112u8, 40u8, 240u8, 143u8],
[113u8, 80u8, 24u8, 166u8],
[114u8, 22u8, 39u8, 61u8],
[115u8, 109u8, 88u8, 13u8],
[116u8, 227u8, 217u8, 73u8],
[126u8, 125u8, 126u8, 232u8],
[130u8, 41u8, 212u8, 102u8],
[131u8, 206u8, 3u8, 34u8],
[135u8, 176u8, 97u8, 121u8],
[137u8, 243u8, 205u8, 140u8],
[138u8, 104u8, 69u8, 83u8],
[139u8, 66u8, 74u8, 87u8],
[141u8, 165u8, 203u8, 91u8],
[143u8, 43u8, 120u8, 106u8],
[148u8, 246u8, 171u8, 252u8],
[149u8, 20u8, 174u8, 160u8],
[155u8, 65u8, 191u8, 35u8],
[157u8, 40u8, 251u8, 134u8],
[157u8, 226u8, 77u8, 132u8],
[169u8, 127u8, 180u8, 77u8],
[169u8, 184u8, 138u8, 225u8],
[181u8, 139u8, 53u8, 188u8],
[185u8, 119u8, 89u8, 1u8],
[188u8, 77u8, 134u8, 27u8],
[190u8, 157u8, 70u8, 190u8],
[196u8, 214u8, 109u8, 232u8],
[199u8, 63u8, 24u8, 27u8],
[202u8, 68u8, 109u8, 217u8],
[203u8, 72u8, 106u8, 147u8],
[203u8, 243u8, 248u8, 97u8],
[204u8, 31u8, 53u8, 27u8],
[220u8, 58u8, 17u8, 127u8],
[222u8, 176u8, 134u8, 90u8],
[224u8, 219u8, 131u8, 226u8],
[236u8, 50u8, 179u8, 149u8],
[242u8, 253u8, 227u8, 139u8],
[253u8, 46u8, 2u8, 229u8],
[253u8, 123u8, 98u8, 33u8],
];
pub const VARIANT_NAMES: &'static [&'static str] = &[
::core::stringify!(getViewBN254CertificateVerifier),
::core::stringify!(SERVICE_MANAGER),
::core::stringify!(getEpochRegistry),
::core::stringify!(getAddress),
::core::stringify!(BATCH_TASK_MANAGER),
::core::stringify!(REGO_VERIFIER),
::core::stringify!(setTaskManager),
::core::stringify!(TASK_MANAGER),
::core::stringify!(setPolicyDataFactory),
::core::stringify!(getPolicyFactory),
::core::stringify!(getChallengeVerifier),
::core::stringify!(getSocketRegistry),
::core::stringify!(setStateCommitRegistry),
::core::stringify!(getServiceManager),
::core::stringify!(VIEW_BN254_CERTIFICATE_VERIFIER),
::core::stringify!(version),
::core::stringify!(STATE_COMMIT_REGISTRY),
::core::stringify!(CONFIDENTIAL_DATA_REGISTRY),
::core::stringify!(setPolicyClientRegistry),
::core::stringify!(IDENTITY_REGISTRY),
::core::stringify!(setEpochRegistry),
::core::stringify!(renounceOwnership),
::core::stringify!(setConfidentialDataRegistry),
::core::stringify!(EPOCH_REGISTRY),
::core::stringify!(getTaskManager),
::core::stringify!(POLICY_DATA_FACTORY),
::core::stringify!(POLICY_FACTORY),
::core::stringify!(OPERATOR_REGISTRY),
::core::stringify!(CHALLENGE_VERIFIER),
::core::stringify!(getBatchTaskManager),
::core::stringify!(setAttestationValidator),
::core::stringify!(POLICY_CLIENT_REGISTRY),
::core::stringify!(owner),
::core::stringify!(SOCKET_REGISTRY),
::core::stringify!(setSocketRegistry),
::core::stringify!(setViewBN254CertificateVerifier),
::core::stringify!(setServiceManager),
::core::stringify!(setOperatorRegistry),
::core::stringify!(setRegoVerifier),
::core::stringify!(setChallengeVerifier),
::core::stringify!(setBatchTaskManager),
::core::stringify!(getEnclaveVersionRegistry),
::core::stringify!(getConfidentialDataRegistry),
::core::stringify!(getIdentityRegistry),
::core::stringify!(getRegoVerifier),
::core::stringify!(initialize),
::core::stringify!(ATTESTATION_VALIDATOR),
::core::stringify!(setAddress),
::core::stringify!(getAttestationValidator),
::core::stringify!(setIdentityRegistry),
::core::stringify!(setEnclaveVersionRegistry),
::core::stringify!(getStateCommitRegistry),
::core::stringify!(getPolicyClientRegistry),
::core::stringify!(ENCLAVE_VERSION_REGISTRY),
::core::stringify!(setPolicyFactory),
::core::stringify!(transferOwnership),
::core::stringify!(getOperatorRegistry),
::core::stringify!(getPolicyDataFactory),
];
pub const SIGNATURES: &'static [&'static str] = &[
<getViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::SIGNATURE,
<SERVICE_MANAGERCall as alloy_sol_types::SolCall>::SIGNATURE,
<getEpochRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<getAddressCall as alloy_sol_types::SolCall>::SIGNATURE,
<BATCH_TASK_MANAGERCall as alloy_sol_types::SolCall>::SIGNATURE,
<REGO_VERIFIERCall as alloy_sol_types::SolCall>::SIGNATURE,
<setTaskManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
<TASK_MANAGERCall as alloy_sol_types::SolCall>::SIGNATURE,
<setPolicyDataFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
<getPolicyFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
<getChallengeVerifierCall as alloy_sol_types::SolCall>::SIGNATURE,
<getSocketRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<setStateCommitRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<getServiceManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
<VIEW_BN254_CERTIFICATE_VERIFIERCall as alloy_sol_types::SolCall>::SIGNATURE,
<versionCall as alloy_sol_types::SolCall>::SIGNATURE,
<STATE_COMMIT_REGISTRYCall as alloy_sol_types::SolCall>::SIGNATURE,
<CONFIDENTIAL_DATA_REGISTRYCall as alloy_sol_types::SolCall>::SIGNATURE,
<setPolicyClientRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<IDENTITY_REGISTRYCall as alloy_sol_types::SolCall>::SIGNATURE,
<setEpochRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<renounceOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
<setConfidentialDataRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<EPOCH_REGISTRYCall as alloy_sol_types::SolCall>::SIGNATURE,
<getTaskManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
<POLICY_DATA_FACTORYCall as alloy_sol_types::SolCall>::SIGNATURE,
<POLICY_FACTORYCall as alloy_sol_types::SolCall>::SIGNATURE,
<OPERATOR_REGISTRYCall as alloy_sol_types::SolCall>::SIGNATURE,
<CHALLENGE_VERIFIERCall as alloy_sol_types::SolCall>::SIGNATURE,
<getBatchTaskManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
<setAttestationValidatorCall as alloy_sol_types::SolCall>::SIGNATURE,
<POLICY_CLIENT_REGISTRYCall as alloy_sol_types::SolCall>::SIGNATURE,
<ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
<SOCKET_REGISTRYCall as alloy_sol_types::SolCall>::SIGNATURE,
<setSocketRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<setViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::SIGNATURE,
<setServiceManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
<setOperatorRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<setRegoVerifierCall as alloy_sol_types::SolCall>::SIGNATURE,
<setChallengeVerifierCall as alloy_sol_types::SolCall>::SIGNATURE,
<setBatchTaskManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
<getEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<getConfidentialDataRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<getIdentityRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<getRegoVerifierCall as alloy_sol_types::SolCall>::SIGNATURE,
<initializeCall as alloy_sol_types::SolCall>::SIGNATURE,
<ATTESTATION_VALIDATORCall as alloy_sol_types::SolCall>::SIGNATURE,
<setAddressCall as alloy_sol_types::SolCall>::SIGNATURE,
<getAttestationValidatorCall as alloy_sol_types::SolCall>::SIGNATURE,
<setIdentityRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<setEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<getStateCommitRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<getPolicyClientRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<ENCLAVE_VERSION_REGISTRYCall as alloy_sol_types::SolCall>::SIGNATURE,
<setPolicyFactoryCall as alloy_sol_types::SolCall>::SIGNATURE,
<transferOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
<getOperatorRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<getPolicyDataFactoryCall 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 NewtonAddressesProviderCalls {
const NAME: &'static str = "NewtonAddressesProviderCalls";
const MIN_DATA_LENGTH: usize = 0usize;
const COUNT: usize = 58usize;
#[inline]
fn selector(&self) -> [u8; 4] {
match self {
Self::ATTESTATION_VALIDATOR(_) => {
<ATTESTATION_VALIDATORCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::BATCH_TASK_MANAGER(_) => {
<BATCH_TASK_MANAGERCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::CHALLENGE_VERIFIER(_) => {
<CHALLENGE_VERIFIERCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::CONFIDENTIAL_DATA_REGISTRY(_) => {
<CONFIDENTIAL_DATA_REGISTRYCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::ENCLAVE_VERSION_REGISTRY(_) => {
<ENCLAVE_VERSION_REGISTRYCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::EPOCH_REGISTRY(_) => {
<EPOCH_REGISTRYCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::IDENTITY_REGISTRY(_) => {
<IDENTITY_REGISTRYCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::OPERATOR_REGISTRY(_) => {
<OPERATOR_REGISTRYCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::POLICY_CLIENT_REGISTRY(_) => {
<POLICY_CLIENT_REGISTRYCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::POLICY_DATA_FACTORY(_) => {
<POLICY_DATA_FACTORYCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::POLICY_FACTORY(_) => {
<POLICY_FACTORYCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::REGO_VERIFIER(_) => {
<REGO_VERIFIERCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::SERVICE_MANAGER(_) => {
<SERVICE_MANAGERCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::SOCKET_REGISTRY(_) => {
<SOCKET_REGISTRYCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::STATE_COMMIT_REGISTRY(_) => {
<STATE_COMMIT_REGISTRYCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::TASK_MANAGER(_) => {
<TASK_MANAGERCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::VIEW_BN254_CERTIFICATE_VERIFIER(_) => {
<VIEW_BN254_CERTIFICATE_VERIFIERCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getAddress(_) => {
<getAddressCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getAttestationValidator(_) => {
<getAttestationValidatorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getBatchTaskManager(_) => {
<getBatchTaskManagerCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getChallengeVerifier(_) => {
<getChallengeVerifierCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getConfidentialDataRegistry(_) => {
<getConfidentialDataRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getEnclaveVersionRegistry(_) => {
<getEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getEpochRegistry(_) => {
<getEpochRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getIdentityRegistry(_) => {
<getIdentityRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getOperatorRegistry(_) => {
<getOperatorRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getPolicyClientRegistry(_) => {
<getPolicyClientRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getPolicyDataFactory(_) => {
<getPolicyDataFactoryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getPolicyFactory(_) => {
<getPolicyFactoryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getRegoVerifier(_) => {
<getRegoVerifierCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getServiceManager(_) => {
<getServiceManagerCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getSocketRegistry(_) => {
<getSocketRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getStateCommitRegistry(_) => {
<getStateCommitRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getTaskManager(_) => {
<getTaskManagerCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getViewBN254CertificateVerifier(_) => {
<getViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::initialize(_) => {
<initializeCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
Self::renounceOwnership(_) => {
<renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setAddress(_) => {
<setAddressCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setAttestationValidator(_) => {
<setAttestationValidatorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setBatchTaskManager(_) => {
<setBatchTaskManagerCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setChallengeVerifier(_) => {
<setChallengeVerifierCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setConfidentialDataRegistry(_) => {
<setConfidentialDataRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setEnclaveVersionRegistry(_) => {
<setEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setEpochRegistry(_) => {
<setEpochRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setIdentityRegistry(_) => {
<setIdentityRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setOperatorRegistry(_) => {
<setOperatorRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setPolicyClientRegistry(_) => {
<setPolicyClientRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setPolicyDataFactory(_) => {
<setPolicyDataFactoryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setPolicyFactory(_) => {
<setPolicyFactoryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setRegoVerifier(_) => {
<setRegoVerifierCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setServiceManager(_) => {
<setServiceManagerCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setSocketRegistry(_) => {
<setSocketRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setStateCommitRegistry(_) => {
<setStateCommitRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setTaskManager(_) => {
<setTaskManagerCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::setViewBN254CertificateVerifier(_) => {
<setViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::transferOwnership(_) => {
<transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::version(_) => <versionCall 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<NewtonAddressesProviderCalls>] = &[
{
fn getViewBN254CertificateVerifier(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
NewtonAddressesProviderCalls::getViewBN254CertificateVerifier,
)
}
getViewBN254CertificateVerifier
},
{
fn SERVICE_MANAGER(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<SERVICE_MANAGERCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::SERVICE_MANAGER)
}
SERVICE_MANAGER
},
{
fn getEpochRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getEpochRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getEpochRegistry)
}
getEpochRegistry
},
{
fn getAddress(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getAddressCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getAddress)
}
getAddress
},
{
fn BATCH_TASK_MANAGER(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<BATCH_TASK_MANAGERCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::BATCH_TASK_MANAGER)
}
BATCH_TASK_MANAGER
},
{
fn REGO_VERIFIER(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<REGO_VERIFIERCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::REGO_VERIFIER)
}
REGO_VERIFIER
},
{
fn setTaskManager(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setTaskManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setTaskManager)
}
setTaskManager
},
{
fn TASK_MANAGER(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<TASK_MANAGERCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::TASK_MANAGER)
}
TASK_MANAGER
},
{
fn setPolicyDataFactory(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setPolicyDataFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setPolicyDataFactory)
}
setPolicyDataFactory
},
{
fn getPolicyFactory(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getPolicyFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getPolicyFactory)
}
getPolicyFactory
},
{
fn getChallengeVerifier(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getChallengeVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getChallengeVerifier)
}
getChallengeVerifier
},
{
fn getSocketRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getSocketRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getSocketRegistry)
}
getSocketRegistry
},
{
fn setStateCommitRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setStateCommitRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setStateCommitRegistry)
}
setStateCommitRegistry
},
{
fn getServiceManager(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getServiceManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getServiceManager)
}
getServiceManager
},
{
fn VIEW_BN254_CERTIFICATE_VERIFIER(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<VIEW_BN254_CERTIFICATE_VERIFIERCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
NewtonAddressesProviderCalls::VIEW_BN254_CERTIFICATE_VERIFIER,
)
}
VIEW_BN254_CERTIFICATE_VERIFIER
},
{
fn version(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(NewtonAddressesProviderCalls::version)
}
version
},
{
fn STATE_COMMIT_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<STATE_COMMIT_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::STATE_COMMIT_REGISTRY)
}
STATE_COMMIT_REGISTRY
},
{
fn CONFIDENTIAL_DATA_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<CONFIDENTIAL_DATA_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
NewtonAddressesProviderCalls::CONFIDENTIAL_DATA_REGISTRY,
)
}
CONFIDENTIAL_DATA_REGISTRY
},
{
fn setPolicyClientRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setPolicyClientRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setPolicyClientRegistry)
}
setPolicyClientRegistry
},
{
fn IDENTITY_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<IDENTITY_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::IDENTITY_REGISTRY)
}
IDENTITY_REGISTRY
},
{
fn setEpochRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setEpochRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setEpochRegistry)
}
setEpochRegistry
},
{
fn renounceOwnership(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::renounceOwnership)
}
renounceOwnership
},
{
fn setConfidentialDataRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setConfidentialDataRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
NewtonAddressesProviderCalls::setConfidentialDataRegistry,
)
}
setConfidentialDataRegistry
},
{
fn EPOCH_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<EPOCH_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::EPOCH_REGISTRY)
}
EPOCH_REGISTRY
},
{
fn getTaskManager(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getTaskManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getTaskManager)
}
getTaskManager
},
{
fn POLICY_DATA_FACTORY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<POLICY_DATA_FACTORYCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::POLICY_DATA_FACTORY)
}
POLICY_DATA_FACTORY
},
{
fn POLICY_FACTORY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<POLICY_FACTORYCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::POLICY_FACTORY)
}
POLICY_FACTORY
},
{
fn OPERATOR_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<OPERATOR_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::OPERATOR_REGISTRY)
}
OPERATOR_REGISTRY
},
{
fn CHALLENGE_VERIFIER(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<CHALLENGE_VERIFIERCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::CHALLENGE_VERIFIER)
}
CHALLENGE_VERIFIER
},
{
fn getBatchTaskManager(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getBatchTaskManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getBatchTaskManager)
}
getBatchTaskManager
},
{
fn setAttestationValidator(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setAttestationValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setAttestationValidator)
}
setAttestationValidator
},
{
fn POLICY_CLIENT_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<POLICY_CLIENT_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::POLICY_CLIENT_REGISTRY)
}
POLICY_CLIENT_REGISTRY
},
{
fn owner(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(NewtonAddressesProviderCalls::owner)
}
owner
},
{
fn SOCKET_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<SOCKET_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::SOCKET_REGISTRY)
}
SOCKET_REGISTRY
},
{
fn setSocketRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setSocketRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setSocketRegistry)
}
setSocketRegistry
},
{
fn setViewBN254CertificateVerifier(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
NewtonAddressesProviderCalls::setViewBN254CertificateVerifier,
)
}
setViewBN254CertificateVerifier
},
{
fn setServiceManager(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setServiceManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setServiceManager)
}
setServiceManager
},
{
fn setOperatorRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setOperatorRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setOperatorRegistry)
}
setOperatorRegistry
},
{
fn setRegoVerifier(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setRegoVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setRegoVerifier)
}
setRegoVerifier
},
{
fn setChallengeVerifier(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setChallengeVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setChallengeVerifier)
}
setChallengeVerifier
},
{
fn setBatchTaskManager(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setBatchTaskManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setBatchTaskManager)
}
setBatchTaskManager
},
{
fn getEnclaveVersionRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getEnclaveVersionRegistry)
}
getEnclaveVersionRegistry
},
{
fn getConfidentialDataRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getConfidentialDataRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(
NewtonAddressesProviderCalls::getConfidentialDataRegistry,
)
}
getConfidentialDataRegistry
},
{
fn getIdentityRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getIdentityRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getIdentityRegistry)
}
getIdentityRegistry
},
{
fn getRegoVerifier(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getRegoVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getRegoVerifier)
}
getRegoVerifier
},
{
fn initialize(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::initialize)
}
initialize
},
{
fn ATTESTATION_VALIDATOR(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<ATTESTATION_VALIDATORCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::ATTESTATION_VALIDATOR)
}
ATTESTATION_VALIDATOR
},
{
fn setAddress(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setAddressCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setAddress)
}
setAddress
},
{
fn getAttestationValidator(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getAttestationValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getAttestationValidator)
}
getAttestationValidator
},
{
fn setIdentityRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setIdentityRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setIdentityRegistry)
}
setIdentityRegistry
},
{
fn setEnclaveVersionRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setEnclaveVersionRegistry)
}
setEnclaveVersionRegistry
},
{
fn getStateCommitRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getStateCommitRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getStateCommitRegistry)
}
getStateCommitRegistry
},
{
fn getPolicyClientRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getPolicyClientRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getPolicyClientRegistry)
}
getPolicyClientRegistry
},
{
fn ENCLAVE_VERSION_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<ENCLAVE_VERSION_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::ENCLAVE_VERSION_REGISTRY)
}
ENCLAVE_VERSION_REGISTRY
},
{
fn setPolicyFactory(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setPolicyFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::setPolicyFactory)
}
setPolicyFactory
},
{
fn transferOwnership(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::transferOwnership)
}
transferOwnership
},
{
fn getOperatorRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getOperatorRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getOperatorRegistry)
}
getOperatorRegistry
},
{
fn getPolicyDataFactory(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getPolicyDataFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderCalls::getPolicyDataFactory)
}
getPolicyDataFactory
},
];
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<NewtonAddressesProviderCalls>] = &[
{
fn getViewBN254CertificateVerifier(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
NewtonAddressesProviderCalls::getViewBN254CertificateVerifier,
)
}
getViewBN254CertificateVerifier
},
{
fn SERVICE_MANAGER(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<SERVICE_MANAGERCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::SERVICE_MANAGER)
}
SERVICE_MANAGER
},
{
fn getEpochRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getEpochRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getEpochRegistry)
}
getEpochRegistry
},
{
fn getAddress(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getAddressCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getAddress)
}
getAddress
},
{
fn BATCH_TASK_MANAGER(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<BATCH_TASK_MANAGERCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::BATCH_TASK_MANAGER)
}
BATCH_TASK_MANAGER
},
{
fn REGO_VERIFIER(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<REGO_VERIFIERCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::REGO_VERIFIER)
}
REGO_VERIFIER
},
{
fn setTaskManager(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setTaskManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setTaskManager)
}
setTaskManager
},
{
fn TASK_MANAGER(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<TASK_MANAGERCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::TASK_MANAGER)
}
TASK_MANAGER
},
{
fn setPolicyDataFactory(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setPolicyDataFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setPolicyDataFactory)
}
setPolicyDataFactory
},
{
fn getPolicyFactory(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getPolicyFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getPolicyFactory)
}
getPolicyFactory
},
{
fn getChallengeVerifier(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getChallengeVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getChallengeVerifier)
}
getChallengeVerifier
},
{
fn getSocketRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getSocketRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getSocketRegistry)
}
getSocketRegistry
},
{
fn setStateCommitRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setStateCommitRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setStateCommitRegistry)
}
setStateCommitRegistry
},
{
fn getServiceManager(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getServiceManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getServiceManager)
}
getServiceManager
},
{
fn VIEW_BN254_CERTIFICATE_VERIFIER(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<VIEW_BN254_CERTIFICATE_VERIFIERCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
NewtonAddressesProviderCalls::VIEW_BN254_CERTIFICATE_VERIFIER,
)
}
VIEW_BN254_CERTIFICATE_VERIFIER
},
{
fn version(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::version)
}
version
},
{
fn STATE_COMMIT_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<STATE_COMMIT_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::STATE_COMMIT_REGISTRY)
}
STATE_COMMIT_REGISTRY
},
{
fn CONFIDENTIAL_DATA_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<CONFIDENTIAL_DATA_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
NewtonAddressesProviderCalls::CONFIDENTIAL_DATA_REGISTRY,
)
}
CONFIDENTIAL_DATA_REGISTRY
},
{
fn setPolicyClientRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setPolicyClientRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setPolicyClientRegistry)
}
setPolicyClientRegistry
},
{
fn IDENTITY_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<IDENTITY_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::IDENTITY_REGISTRY)
}
IDENTITY_REGISTRY
},
{
fn setEpochRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setEpochRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setEpochRegistry)
}
setEpochRegistry
},
{
fn renounceOwnership(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::renounceOwnership)
}
renounceOwnership
},
{
fn setConfidentialDataRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setConfidentialDataRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
NewtonAddressesProviderCalls::setConfidentialDataRegistry,
)
}
setConfidentialDataRegistry
},
{
fn EPOCH_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<EPOCH_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::EPOCH_REGISTRY)
}
EPOCH_REGISTRY
},
{
fn getTaskManager(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getTaskManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getTaskManager)
}
getTaskManager
},
{
fn POLICY_DATA_FACTORY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<POLICY_DATA_FACTORYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::POLICY_DATA_FACTORY)
}
POLICY_DATA_FACTORY
},
{
fn POLICY_FACTORY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<POLICY_FACTORYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::POLICY_FACTORY)
}
POLICY_FACTORY
},
{
fn OPERATOR_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<OPERATOR_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::OPERATOR_REGISTRY)
}
OPERATOR_REGISTRY
},
{
fn CHALLENGE_VERIFIER(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<CHALLENGE_VERIFIERCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::CHALLENGE_VERIFIER)
}
CHALLENGE_VERIFIER
},
{
fn getBatchTaskManager(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getBatchTaskManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getBatchTaskManager)
}
getBatchTaskManager
},
{
fn setAttestationValidator(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setAttestationValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setAttestationValidator)
}
setAttestationValidator
},
{
fn POLICY_CLIENT_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<POLICY_CLIENT_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::POLICY_CLIENT_REGISTRY)
}
POLICY_CLIENT_REGISTRY
},
{
fn owner(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::owner)
}
owner
},
{
fn SOCKET_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<SOCKET_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::SOCKET_REGISTRY)
}
SOCKET_REGISTRY
},
{
fn setSocketRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setSocketRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setSocketRegistry)
}
setSocketRegistry
},
{
fn setViewBN254CertificateVerifier(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
NewtonAddressesProviderCalls::setViewBN254CertificateVerifier,
)
}
setViewBN254CertificateVerifier
},
{
fn setServiceManager(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setServiceManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setServiceManager)
}
setServiceManager
},
{
fn setOperatorRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setOperatorRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setOperatorRegistry)
}
setOperatorRegistry
},
{
fn setRegoVerifier(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setRegoVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setRegoVerifier)
}
setRegoVerifier
},
{
fn setChallengeVerifier(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setChallengeVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setChallengeVerifier)
}
setChallengeVerifier
},
{
fn setBatchTaskManager(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setBatchTaskManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setBatchTaskManager)
}
setBatchTaskManager
},
{
fn getEnclaveVersionRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getEnclaveVersionRegistry)
}
getEnclaveVersionRegistry
},
{
fn getConfidentialDataRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getConfidentialDataRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(
NewtonAddressesProviderCalls::getConfidentialDataRegistry,
)
}
getConfidentialDataRegistry
},
{
fn getIdentityRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getIdentityRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getIdentityRegistry)
}
getIdentityRegistry
},
{
fn getRegoVerifier(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getRegoVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getRegoVerifier)
}
getRegoVerifier
},
{
fn initialize(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<initializeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::initialize)
}
initialize
},
{
fn ATTESTATION_VALIDATOR(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<ATTESTATION_VALIDATORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::ATTESTATION_VALIDATOR)
}
ATTESTATION_VALIDATOR
},
{
fn setAddress(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setAddressCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setAddress)
}
setAddress
},
{
fn getAttestationValidator(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getAttestationValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getAttestationValidator)
}
getAttestationValidator
},
{
fn setIdentityRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setIdentityRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setIdentityRegistry)
}
setIdentityRegistry
},
{
fn setEnclaveVersionRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setEnclaveVersionRegistry)
}
setEnclaveVersionRegistry
},
{
fn getStateCommitRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getStateCommitRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getStateCommitRegistry)
}
getStateCommitRegistry
},
{
fn getPolicyClientRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getPolicyClientRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getPolicyClientRegistry)
}
getPolicyClientRegistry
},
{
fn ENCLAVE_VERSION_REGISTRY(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<ENCLAVE_VERSION_REGISTRYCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::ENCLAVE_VERSION_REGISTRY)
}
ENCLAVE_VERSION_REGISTRY
},
{
fn setPolicyFactory(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<setPolicyFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::setPolicyFactory)
}
setPolicyFactory
},
{
fn transferOwnership(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::transferOwnership)
}
transferOwnership
},
{
fn getOperatorRegistry(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getOperatorRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getOperatorRegistry)
}
getOperatorRegistry
},
{
fn getPolicyDataFactory(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderCalls> {
<getPolicyDataFactoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderCalls::getPolicyDataFactory)
}
getPolicyDataFactory
},
];
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::ATTESTATION_VALIDATOR(inner) => {
<ATTESTATION_VALIDATORCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::BATCH_TASK_MANAGER(inner) => {
<BATCH_TASK_MANAGERCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::CHALLENGE_VERIFIER(inner) => {
<CHALLENGE_VERIFIERCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::CONFIDENTIAL_DATA_REGISTRY(inner) => {
<CONFIDENTIAL_DATA_REGISTRYCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::ENCLAVE_VERSION_REGISTRY(inner) => {
<ENCLAVE_VERSION_REGISTRYCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::EPOCH_REGISTRY(inner) => {
<EPOCH_REGISTRYCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::IDENTITY_REGISTRY(inner) => {
<IDENTITY_REGISTRYCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::OPERATOR_REGISTRY(inner) => {
<OPERATOR_REGISTRYCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::POLICY_CLIENT_REGISTRY(inner) => {
<POLICY_CLIENT_REGISTRYCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::POLICY_DATA_FACTORY(inner) => {
<POLICY_DATA_FACTORYCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::POLICY_FACTORY(inner) => {
<POLICY_FACTORYCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::REGO_VERIFIER(inner) => {
<REGO_VERIFIERCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::SERVICE_MANAGER(inner) => {
<SERVICE_MANAGERCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::SOCKET_REGISTRY(inner) => {
<SOCKET_REGISTRYCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::STATE_COMMIT_REGISTRY(inner) => {
<STATE_COMMIT_REGISTRYCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::TASK_MANAGER(inner) => {
<TASK_MANAGERCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::VIEW_BN254_CERTIFICATE_VERIFIER(inner) => {
<VIEW_BN254_CERTIFICATE_VERIFIERCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getAddress(inner) => {
<getAddressCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::getAttestationValidator(inner) => {
<getAttestationValidatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getBatchTaskManager(inner) => {
<getBatchTaskManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getChallengeVerifier(inner) => {
<getChallengeVerifierCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getConfidentialDataRegistry(inner) => {
<getConfidentialDataRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getEnclaveVersionRegistry(inner) => {
<getEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getEpochRegistry(inner) => {
<getEpochRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getIdentityRegistry(inner) => {
<getIdentityRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getOperatorRegistry(inner) => {
<getOperatorRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getPolicyClientRegistry(inner) => {
<getPolicyClientRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getPolicyDataFactory(inner) => {
<getPolicyDataFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getPolicyFactory(inner) => {
<getPolicyFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getRegoVerifier(inner) => {
<getRegoVerifierCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getServiceManager(inner) => {
<getServiceManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getSocketRegistry(inner) => {
<getSocketRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getStateCommitRegistry(inner) => {
<getStateCommitRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getTaskManager(inner) => {
<getTaskManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getViewBN254CertificateVerifier(inner) => {
<getViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::initialize(inner) => {
<initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::owner(inner) => {
<ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::renounceOwnership(inner) => {
<renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setAddress(inner) => {
<setAddressCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::setAttestationValidator(inner) => {
<setAttestationValidatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setBatchTaskManager(inner) => {
<setBatchTaskManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setChallengeVerifier(inner) => {
<setChallengeVerifierCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setConfidentialDataRegistry(inner) => {
<setConfidentialDataRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setEnclaveVersionRegistry(inner) => {
<setEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setEpochRegistry(inner) => {
<setEpochRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setIdentityRegistry(inner) => {
<setIdentityRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setOperatorRegistry(inner) => {
<setOperatorRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setPolicyClientRegistry(inner) => {
<setPolicyClientRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setPolicyDataFactory(inner) => {
<setPolicyDataFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setPolicyFactory(inner) => {
<setPolicyFactoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setRegoVerifier(inner) => {
<setRegoVerifierCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setServiceManager(inner) => {
<setServiceManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setSocketRegistry(inner) => {
<setSocketRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setStateCommitRegistry(inner) => {
<setStateCommitRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setTaskManager(inner) => {
<setTaskManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::setViewBN254CertificateVerifier(inner) => {
<setViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::transferOwnership(inner) => {
<transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::version(inner) => {
<versionCall 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::ATTESTATION_VALIDATOR(inner) => {
<ATTESTATION_VALIDATORCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::BATCH_TASK_MANAGER(inner) => {
<BATCH_TASK_MANAGERCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::CHALLENGE_VERIFIER(inner) => {
<CHALLENGE_VERIFIERCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::CONFIDENTIAL_DATA_REGISTRY(inner) => {
<CONFIDENTIAL_DATA_REGISTRYCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::ENCLAVE_VERSION_REGISTRY(inner) => {
<ENCLAVE_VERSION_REGISTRYCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::EPOCH_REGISTRY(inner) => {
<EPOCH_REGISTRYCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::IDENTITY_REGISTRY(inner) => {
<IDENTITY_REGISTRYCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::OPERATOR_REGISTRY(inner) => {
<OPERATOR_REGISTRYCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::POLICY_CLIENT_REGISTRY(inner) => {
<POLICY_CLIENT_REGISTRYCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::POLICY_DATA_FACTORY(inner) => {
<POLICY_DATA_FACTORYCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::POLICY_FACTORY(inner) => {
<POLICY_FACTORYCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::REGO_VERIFIER(inner) => {
<REGO_VERIFIERCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::SERVICE_MANAGER(inner) => {
<SERVICE_MANAGERCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::SOCKET_REGISTRY(inner) => {
<SOCKET_REGISTRYCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::STATE_COMMIT_REGISTRY(inner) => {
<STATE_COMMIT_REGISTRYCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::TASK_MANAGER(inner) => {
<TASK_MANAGERCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::VIEW_BN254_CERTIFICATE_VERIFIER(inner) => {
<VIEW_BN254_CERTIFICATE_VERIFIERCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getAddress(inner) => {
<getAddressCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getAttestationValidator(inner) => {
<getAttestationValidatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getBatchTaskManager(inner) => {
<getBatchTaskManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getChallengeVerifier(inner) => {
<getChallengeVerifierCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getConfidentialDataRegistry(inner) => {
<getConfidentialDataRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getEnclaveVersionRegistry(inner) => {
<getEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getEpochRegistry(inner) => {
<getEpochRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getIdentityRegistry(inner) => {
<getIdentityRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getOperatorRegistry(inner) => {
<getOperatorRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getPolicyClientRegistry(inner) => {
<getPolicyClientRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getPolicyDataFactory(inner) => {
<getPolicyDataFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getPolicyFactory(inner) => {
<getPolicyFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getRegoVerifier(inner) => {
<getRegoVerifierCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getServiceManager(inner) => {
<getServiceManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getSocketRegistry(inner) => {
<getSocketRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getStateCommitRegistry(inner) => {
<getStateCommitRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getTaskManager(inner) => {
<getTaskManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getViewBN254CertificateVerifier(inner) => {
<getViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::initialize(inner) => {
<initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::owner(inner) => {
<ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
Self::renounceOwnership(inner) => {
<renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setAddress(inner) => {
<setAddressCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setAttestationValidator(inner) => {
<setAttestationValidatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setBatchTaskManager(inner) => {
<setBatchTaskManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setChallengeVerifier(inner) => {
<setChallengeVerifierCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setConfidentialDataRegistry(inner) => {
<setConfidentialDataRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setEnclaveVersionRegistry(inner) => {
<setEnclaveVersionRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setEpochRegistry(inner) => {
<setEpochRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setIdentityRegistry(inner) => {
<setIdentityRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setOperatorRegistry(inner) => {
<setOperatorRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setPolicyClientRegistry(inner) => {
<setPolicyClientRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setPolicyDataFactory(inner) => {
<setPolicyDataFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setPolicyFactory(inner) => {
<setPolicyFactoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setRegoVerifier(inner) => {
<setRegoVerifierCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setServiceManager(inner) => {
<setServiceManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setSocketRegistry(inner) => {
<setSocketRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setStateCommitRegistry(inner) => {
<setStateCommitRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setTaskManager(inner) => {
<setTaskManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::setViewBN254CertificateVerifier(inner) => {
<setViewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::transferOwnership(inner) => {
<transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::version(inner) => {
<versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
}
}
}
#[derive(Clone)]
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Debug, PartialEq, Eq, Hash)]
pub enum NewtonAddressesProviderErrors {
#[allow(missing_docs)]
InvalidShortString(InvalidShortString),
#[allow(missing_docs)]
NoContractCode(NoContractCode),
#[allow(missing_docs)]
StringTooLong(StringTooLong),
#[allow(missing_docs)]
ZeroAddress(ZeroAddress),
}
impl NewtonAddressesProviderErrors {
pub const SELECTORS: &'static [[u8; 4usize]] = &[
[48u8, 90u8, 39u8, 169u8],
[86u8, 58u8, 50u8, 132u8],
[131u8, 207u8, 74u8, 43u8],
[179u8, 81u8, 43u8, 12u8],
];
pub const VARIANT_NAMES: &'static [&'static str] = &[
::core::stringify!(StringTooLong),
::core::stringify!(NoContractCode),
::core::stringify!(ZeroAddress),
::core::stringify!(InvalidShortString),
];
pub const SIGNATURES: &'static [&'static str] = &[
<StringTooLong as alloy_sol_types::SolError>::SIGNATURE,
<NoContractCode as alloy_sol_types::SolError>::SIGNATURE,
<ZeroAddress as alloy_sol_types::SolError>::SIGNATURE,
<InvalidShortString as alloy_sol_types::SolError>::SIGNATURE,
];
#[inline]
pub fn signature_by_selector(
selector: [u8; 4usize],
) -> ::core::option::Option<&'static str> {
match Self::SELECTORS.binary_search(&selector) {
::core::result::Result::Ok(idx) => {
::core::option::Option::Some(Self::SIGNATURES[idx])
}
::core::result::Result::Err(_) => ::core::option::Option::None,
}
}
#[inline]
pub fn name_by_selector(
selector: [u8; 4usize],
) -> ::core::option::Option<&'static str> {
let sig = Self::signature_by_selector(selector)?;
sig.split_once('(').map(|(name, _)| name)
}
}
#[automatically_derived]
impl alloy_sol_types::SolInterface for NewtonAddressesProviderErrors {
const NAME: &'static str = "NewtonAddressesProviderErrors";
const MIN_DATA_LENGTH: usize = 0usize;
const COUNT: usize = 4usize;
#[inline]
fn selector(&self) -> [u8; 4] {
match self {
Self::InvalidShortString(_) => {
<InvalidShortString as alloy_sol_types::SolError>::SELECTOR
}
Self::NoContractCode(_) => {
<NoContractCode as alloy_sol_types::SolError>::SELECTOR
}
Self::StringTooLong(_) => {
<StringTooLong as alloy_sol_types::SolError>::SELECTOR
}
Self::ZeroAddress(_) => {
<ZeroAddress as alloy_sol_types::SolError>::SELECTOR
}
}
}
#[inline]
fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
Self::SELECTORS.get(i).copied()
}
#[inline]
fn valid_selector(selector: [u8; 4]) -> bool {
Self::SELECTORS.binary_search(&selector).is_ok()
}
#[inline]
#[allow(non_snake_case)]
fn abi_decode_raw(
selector: [u8; 4],
data: &[u8],
) -> alloy_sol_types::Result<Self> {
static DECODE_SHIMS: &[fn(
&[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderErrors>] = &[
{
fn StringTooLong(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderErrors> {
<StringTooLong as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderErrors::StringTooLong)
}
StringTooLong
},
{
fn NoContractCode(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderErrors> {
<NoContractCode as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderErrors::NoContractCode)
}
NoContractCode
},
{
fn ZeroAddress(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderErrors> {
<ZeroAddress as alloy_sol_types::SolError>::abi_decode_raw(data)
.map(NewtonAddressesProviderErrors::ZeroAddress)
}
ZeroAddress
},
{
fn InvalidShortString(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderErrors> {
<InvalidShortString as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(NewtonAddressesProviderErrors::InvalidShortString)
}
InvalidShortString
},
];
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<NewtonAddressesProviderErrors>] = &[
{
fn StringTooLong(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderErrors> {
<StringTooLong as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderErrors::StringTooLong)
}
StringTooLong
},
{
fn NoContractCode(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderErrors> {
<NoContractCode as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderErrors::NoContractCode)
}
NoContractCode
},
{
fn ZeroAddress(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderErrors> {
<ZeroAddress as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderErrors::ZeroAddress)
}
ZeroAddress
},
{
fn InvalidShortString(
data: &[u8],
) -> alloy_sol_types::Result<NewtonAddressesProviderErrors> {
<InvalidShortString as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(NewtonAddressesProviderErrors::InvalidShortString)
}
InvalidShortString
},
];
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::InvalidShortString(inner) => {
<InvalidShortString as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::NoContractCode(inner) => {
<NoContractCode as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::StringTooLong(inner) => {
<StringTooLong as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
Self::ZeroAddress(inner) => {
<ZeroAddress as alloy_sol_types::SolError>::abi_encoded_size(inner)
}
}
}
#[inline]
fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
match self {
Self::InvalidShortString(inner) => {
<InvalidShortString as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::NoContractCode(inner) => {
<NoContractCode as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::StringTooLong(inner) => {
<StringTooLong as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::ZeroAddress(inner) => {
<ZeroAddress as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
}
}
}
#[derive(Clone)]
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Debug, PartialEq, Eq, Hash)]
pub enum NewtonAddressesProviderEvents {
#[allow(missing_docs)]
AddressSet(AddressSet),
#[allow(missing_docs)]
Initialized(Initialized),
#[allow(missing_docs)]
OwnershipTransferred(OwnershipTransferred),
}
impl NewtonAddressesProviderEvents {
pub const SELECTORS: &'static [[u8; 32usize]] = &[
[
127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
],
[
139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
],
[
158u8, 240u8, 232u8, 200u8, 229u8, 39u8, 67u8, 187u8, 56u8, 184u8, 59u8,
23u8, 217u8, 66u8, 145u8, 65u8, 212u8, 148u8, 184u8, 4u8, 28u8, 166u8,
214u8, 22u8, 166u8, 199u8, 124u8, 235u8, 174u8, 156u8, 216u8, 183u8,
],
];
pub const VARIANT_NAMES: &'static [&'static str] = &[
::core::stringify!(Initialized),
::core::stringify!(OwnershipTransferred),
::core::stringify!(AddressSet),
];
pub const SIGNATURES: &'static [&'static str] = &[
<Initialized as alloy_sol_types::SolEvent>::SIGNATURE,
<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE,
<AddressSet as alloy_sol_types::SolEvent>::SIGNATURE,
];
#[inline]
pub fn signature_by_selector(
selector: [u8; 32usize],
) -> ::core::option::Option<&'static str> {
match Self::SELECTORS.binary_search(&selector) {
::core::result::Result::Ok(idx) => {
::core::option::Option::Some(Self::SIGNATURES[idx])
}
::core::result::Result::Err(_) => ::core::option::Option::None,
}
}
#[inline]
pub fn name_by_selector(
selector: [u8; 32usize],
) -> ::core::option::Option<&'static str> {
let sig = Self::signature_by_selector(selector)?;
sig.split_once('(').map(|(name, _)| name)
}
}
#[automatically_derived]
impl alloy_sol_types::SolEventInterface for NewtonAddressesProviderEvents {
const NAME: &'static str = "NewtonAddressesProviderEvents";
const COUNT: usize = 3usize;
fn decode_raw_log(
topics: &[alloy_sol_types::Word],
data: &[u8],
) -> alloy_sol_types::Result<Self> {
match topics.first().copied() {
Some(<AddressSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<AddressSet as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::AddressSet)
}
Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::Initialized)
}
Some(
<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::OwnershipTransferred)
}
_ => {
alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
name: <Self as alloy_sol_types::SolEventInterface>::NAME,
log: alloy_sol_types::private::Box::new(
alloy_sol_types::private::LogData::new_unchecked(
topics.to_vec(),
data.to_vec().into(),
),
),
})
}
}
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for NewtonAddressesProviderEvents {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
match self {
Self::AddressSet(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::Initialized(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::OwnershipTransferred(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
}
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
match self {
Self::AddressSet(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::Initialized(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::OwnershipTransferred(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
}
}
}
use alloy::contract as alloy_contract;
#[inline]
pub const fn new<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
>(
address: alloy_sol_types::private::Address,
__provider: P,
) -> NewtonAddressesProviderInstance<P, N> {
NewtonAddressesProviderInstance::<P, N>::new(address, __provider)
}
#[inline]
pub fn deploy<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
>(
__provider: P,
_version: alloy::sol_types::private::String,
) -> impl ::core::future::Future<
Output = alloy_contract::Result<NewtonAddressesProviderInstance<P, N>>,
> {
NewtonAddressesProviderInstance::<P, N>::deploy(__provider, _version)
}
#[inline]
pub fn deploy_builder<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
>(
__provider: P,
_version: alloy::sol_types::private::String,
) -> alloy_contract::RawCallBuilder<P, N> {
NewtonAddressesProviderInstance::<P, N>::deploy_builder(__provider, _version)
}
#[derive(Clone)]
pub struct NewtonAddressesProviderInstance<
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 NewtonAddressesProviderInstance<P, N> {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
f.debug_tuple("NewtonAddressesProviderInstance")
.field(&self.address)
.finish()
}
}
impl<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
> NewtonAddressesProviderInstance<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,
_version: alloy::sol_types::private::String,
) -> alloy_contract::Result<NewtonAddressesProviderInstance<P, N>> {
let call_builder = Self::deploy_builder(__provider, _version);
let contract_address = call_builder.deploy().await?;
Ok(Self::new(contract_address, call_builder.provider))
}
#[inline]
pub fn deploy_builder(
__provider: P,
_version: alloy::sol_types::private::String,
) -> alloy_contract::RawCallBuilder<P, N> {
alloy_contract::RawCallBuilder::new_raw_deploy(
__provider,
[
&BYTECODE[..],
&alloy_sol_types::SolConstructor::abi_encode(
&constructorCall { _version },
)[..],
]
.concat()
.into(),
)
}
#[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> NewtonAddressesProviderInstance<&P, N> {
#[inline]
pub fn with_cloned_provider(self) -> NewtonAddressesProviderInstance<P, N> {
NewtonAddressesProviderInstance {
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,
> NewtonAddressesProviderInstance<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 ATTESTATION_VALIDATOR(
&self,
) -> alloy_contract::SolCallBuilder<&P, ATTESTATION_VALIDATORCall, N> {
self.call_builder(&ATTESTATION_VALIDATORCall)
}
pub fn BATCH_TASK_MANAGER(
&self,
) -> alloy_contract::SolCallBuilder<&P, BATCH_TASK_MANAGERCall, N> {
self.call_builder(&BATCH_TASK_MANAGERCall)
}
pub fn CHALLENGE_VERIFIER(
&self,
) -> alloy_contract::SolCallBuilder<&P, CHALLENGE_VERIFIERCall, N> {
self.call_builder(&CHALLENGE_VERIFIERCall)
}
pub fn CONFIDENTIAL_DATA_REGISTRY(
&self,
) -> alloy_contract::SolCallBuilder<&P, CONFIDENTIAL_DATA_REGISTRYCall, N> {
self.call_builder(&CONFIDENTIAL_DATA_REGISTRYCall)
}
pub fn ENCLAVE_VERSION_REGISTRY(
&self,
) -> alloy_contract::SolCallBuilder<&P, ENCLAVE_VERSION_REGISTRYCall, N> {
self.call_builder(&ENCLAVE_VERSION_REGISTRYCall)
}
pub fn EPOCH_REGISTRY(
&self,
) -> alloy_contract::SolCallBuilder<&P, EPOCH_REGISTRYCall, N> {
self.call_builder(&EPOCH_REGISTRYCall)
}
pub fn IDENTITY_REGISTRY(
&self,
) -> alloy_contract::SolCallBuilder<&P, IDENTITY_REGISTRYCall, N> {
self.call_builder(&IDENTITY_REGISTRYCall)
}
pub fn OPERATOR_REGISTRY(
&self,
) -> alloy_contract::SolCallBuilder<&P, OPERATOR_REGISTRYCall, N> {
self.call_builder(&OPERATOR_REGISTRYCall)
}
pub fn POLICY_CLIENT_REGISTRY(
&self,
) -> alloy_contract::SolCallBuilder<&P, POLICY_CLIENT_REGISTRYCall, N> {
self.call_builder(&POLICY_CLIENT_REGISTRYCall)
}
pub fn POLICY_DATA_FACTORY(
&self,
) -> alloy_contract::SolCallBuilder<&P, POLICY_DATA_FACTORYCall, N> {
self.call_builder(&POLICY_DATA_FACTORYCall)
}
pub fn POLICY_FACTORY(
&self,
) -> alloy_contract::SolCallBuilder<&P, POLICY_FACTORYCall, N> {
self.call_builder(&POLICY_FACTORYCall)
}
pub fn REGO_VERIFIER(
&self,
) -> alloy_contract::SolCallBuilder<&P, REGO_VERIFIERCall, N> {
self.call_builder(®O_VERIFIERCall)
}
pub fn SERVICE_MANAGER(
&self,
) -> alloy_contract::SolCallBuilder<&P, SERVICE_MANAGERCall, N> {
self.call_builder(&SERVICE_MANAGERCall)
}
pub fn SOCKET_REGISTRY(
&self,
) -> alloy_contract::SolCallBuilder<&P, SOCKET_REGISTRYCall, N> {
self.call_builder(&SOCKET_REGISTRYCall)
}
pub fn STATE_COMMIT_REGISTRY(
&self,
) -> alloy_contract::SolCallBuilder<&P, STATE_COMMIT_REGISTRYCall, N> {
self.call_builder(&STATE_COMMIT_REGISTRYCall)
}
pub fn TASK_MANAGER(
&self,
) -> alloy_contract::SolCallBuilder<&P, TASK_MANAGERCall, N> {
self.call_builder(&TASK_MANAGERCall)
}
pub fn VIEW_BN254_CERTIFICATE_VERIFIER(
&self,
) -> alloy_contract::SolCallBuilder<&P, VIEW_BN254_CERTIFICATE_VERIFIERCall, N> {
self.call_builder(&VIEW_BN254_CERTIFICATE_VERIFIERCall)
}
pub fn getAddress(
&self,
id: alloy::sol_types::private::FixedBytes<32>,
) -> alloy_contract::SolCallBuilder<&P, getAddressCall, N> {
self.call_builder(&getAddressCall { id })
}
pub fn getAttestationValidator(
&self,
) -> alloy_contract::SolCallBuilder<&P, getAttestationValidatorCall, N> {
self.call_builder(&getAttestationValidatorCall)
}
pub fn getBatchTaskManager(
&self,
) -> alloy_contract::SolCallBuilder<&P, getBatchTaskManagerCall, N> {
self.call_builder(&getBatchTaskManagerCall)
}
pub fn getChallengeVerifier(
&self,
) -> alloy_contract::SolCallBuilder<&P, getChallengeVerifierCall, N> {
self.call_builder(&getChallengeVerifierCall)
}
pub fn getConfidentialDataRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, getConfidentialDataRegistryCall, N> {
self.call_builder(&getConfidentialDataRegistryCall)
}
pub fn getEnclaveVersionRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, getEnclaveVersionRegistryCall, N> {
self.call_builder(&getEnclaveVersionRegistryCall)
}
pub fn getEpochRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, getEpochRegistryCall, N> {
self.call_builder(&getEpochRegistryCall)
}
pub fn getIdentityRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, getIdentityRegistryCall, N> {
self.call_builder(&getIdentityRegistryCall)
}
pub fn getOperatorRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, getOperatorRegistryCall, N> {
self.call_builder(&getOperatorRegistryCall)
}
pub fn getPolicyClientRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, getPolicyClientRegistryCall, N> {
self.call_builder(&getPolicyClientRegistryCall)
}
pub fn getPolicyDataFactory(
&self,
) -> alloy_contract::SolCallBuilder<&P, getPolicyDataFactoryCall, N> {
self.call_builder(&getPolicyDataFactoryCall)
}
pub fn getPolicyFactory(
&self,
) -> alloy_contract::SolCallBuilder<&P, getPolicyFactoryCall, N> {
self.call_builder(&getPolicyFactoryCall)
}
pub fn getRegoVerifier(
&self,
) -> alloy_contract::SolCallBuilder<&P, getRegoVerifierCall, N> {
self.call_builder(&getRegoVerifierCall)
}
pub fn getServiceManager(
&self,
) -> alloy_contract::SolCallBuilder<&P, getServiceManagerCall, N> {
self.call_builder(&getServiceManagerCall)
}
pub fn getSocketRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, getSocketRegistryCall, N> {
self.call_builder(&getSocketRegistryCall)
}
pub fn getStateCommitRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, getStateCommitRegistryCall, N> {
self.call_builder(&getStateCommitRegistryCall)
}
pub fn getTaskManager(
&self,
) -> alloy_contract::SolCallBuilder<&P, getTaskManagerCall, N> {
self.call_builder(&getTaskManagerCall)
}
pub fn getViewBN254CertificateVerifier(
&self,
) -> alloy_contract::SolCallBuilder<&P, getViewBN254CertificateVerifierCall, N> {
self.call_builder(&getViewBN254CertificateVerifierCall)
}
pub fn initialize(
&self,
_owner: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> {
self.call_builder(&initializeCall { _owner })
}
pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
self.call_builder(&ownerCall)
}
pub fn renounceOwnership(
&self,
) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
self.call_builder(&renounceOwnershipCall)
}
pub fn setAddress(
&self,
id: alloy::sol_types::private::FixedBytes<32>,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setAddressCall, N> {
self.call_builder(&setAddressCall { id, addr })
}
pub fn setAttestationValidator(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setAttestationValidatorCall, N> {
self.call_builder(
&setAttestationValidatorCall {
addr,
},
)
}
pub fn setBatchTaskManager(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setBatchTaskManagerCall, N> {
self.call_builder(&setBatchTaskManagerCall { addr })
}
pub fn setChallengeVerifier(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setChallengeVerifierCall, N> {
self.call_builder(&setChallengeVerifierCall { addr })
}
pub fn setConfidentialDataRegistry(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setConfidentialDataRegistryCall, N> {
self.call_builder(
&setConfidentialDataRegistryCall {
addr,
},
)
}
pub fn setEnclaveVersionRegistry(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setEnclaveVersionRegistryCall, N> {
self.call_builder(
&setEnclaveVersionRegistryCall {
addr,
},
)
}
pub fn setEpochRegistry(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setEpochRegistryCall, N> {
self.call_builder(&setEpochRegistryCall { addr })
}
pub fn setIdentityRegistry(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setIdentityRegistryCall, N> {
self.call_builder(&setIdentityRegistryCall { addr })
}
pub fn setOperatorRegistry(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setOperatorRegistryCall, N> {
self.call_builder(&setOperatorRegistryCall { addr })
}
pub fn setPolicyClientRegistry(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setPolicyClientRegistryCall, N> {
self.call_builder(
&setPolicyClientRegistryCall {
addr,
},
)
}
pub fn setPolicyDataFactory(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setPolicyDataFactoryCall, N> {
self.call_builder(&setPolicyDataFactoryCall { addr })
}
pub fn setPolicyFactory(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setPolicyFactoryCall, N> {
self.call_builder(&setPolicyFactoryCall { addr })
}
pub fn setRegoVerifier(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setRegoVerifierCall, N> {
self.call_builder(&setRegoVerifierCall { addr })
}
pub fn setServiceManager(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setServiceManagerCall, N> {
self.call_builder(&setServiceManagerCall { addr })
}
pub fn setSocketRegistry(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setSocketRegistryCall, N> {
self.call_builder(&setSocketRegistryCall { addr })
}
pub fn setStateCommitRegistry(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setStateCommitRegistryCall, N> {
self.call_builder(&setStateCommitRegistryCall { addr })
}
pub fn setTaskManager(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setTaskManagerCall, N> {
self.call_builder(&setTaskManagerCall { addr })
}
pub fn setViewBN254CertificateVerifier(
&self,
addr: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, setViewBN254CertificateVerifierCall, N> {
self.call_builder(
&setViewBN254CertificateVerifierCall {
addr,
},
)
}
pub fn transferOwnership(
&self,
newOwner: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
self.call_builder(&transferOwnershipCall { newOwner })
}
pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
self.call_builder(&versionCall)
}
}
impl<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
> NewtonAddressesProviderInstance<P, N> {
pub fn event_filter<E: alloy_sol_types::SolEvent>(
&self,
) -> alloy_contract::Event<&P, E, N> {
alloy_contract::Event::new_sol(&self.provider, &self.address)
}
pub fn AddressSet_filter(&self) -> alloy_contract::Event<&P, AddressSet, N> {
self.event_filter::<AddressSet>()
}
pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
self.event_filter::<Initialized>()
}
pub fn OwnershipTransferred_filter(
&self,
) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
self.event_filter::<OwnershipTransferred>()
}
}
}