#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style,
clippy::empty_structs_with_brackets
)]
pub mod IdentityRegistry {
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 InvalidAccountNonce {
#[allow(missing_docs)]
pub account: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub currentNonce: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<InvalidAccountNonce> for UnderlyingRustTuple<'_> {
fn from(value: InvalidAccountNonce) -> Self {
(value.account, value.currentNonce)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAccountNonce {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
account: tuple.0,
currentNonce: tuple.1,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InvalidAccountNonce {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InvalidAccountNonce(address,uint256)";
const SELECTOR: [u8; 4] = [117u8, 45u8, 136u8, 192u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.account,
),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self.currentNonce),
)
}
#[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 InvalidClientRegistryAddress;
#[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<InvalidClientRegistryAddress>
for UnderlyingRustTuple<'_> {
fn from(value: InvalidClientRegistryAddress) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for InvalidClientRegistryAddress {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InvalidClientRegistryAddress {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InvalidClientRegistryAddress()";
const SELECTOR: [u8; 4] = [201u8, 13u8, 89u8, 187u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn 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 InvalidIdentityDomain;
#[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<InvalidIdentityDomain> for UnderlyingRustTuple<'_> {
fn from(value: InvalidIdentityDomain) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidIdentityDomain {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InvalidIdentityDomain {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InvalidIdentityDomain()";
const SELECTOR: [u8; 4] = [225u8, 130u8, 129u8, 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 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 InvalidIdentitySubmitter;
#[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<InvalidIdentitySubmitter>
for UnderlyingRustTuple<'_> {
fn from(value: InvalidIdentitySubmitter) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for InvalidIdentitySubmitter {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InvalidIdentitySubmitter {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InvalidIdentitySubmitter()";
const SELECTOR: [u8; 4] = [223u8, 128u8, 165u8, 142u8];
#[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 InvalidOperatorRegistryAddress;
#[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<InvalidOperatorRegistryAddress>
for UnderlyingRustTuple<'_> {
fn from(value: InvalidOperatorRegistryAddress) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for InvalidOperatorRegistryAddress {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InvalidOperatorRegistryAddress {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InvalidOperatorRegistryAddress()";
const SELECTOR: [u8; 4] = [184u8, 168u8, 140u8, 154u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(Self::new)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct InvalidSignature;
#[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<InvalidSignature> for UnderlyingRustTuple<'_> {
fn from(value: InvalidSignature) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSignature {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InvalidSignature {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InvalidSignature()";
const SELECTOR: [u8; 4] = [139u8, 170u8, 87u8, 159u8];
#[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 InvalidUnlinker;
#[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<InvalidUnlinker> for UnderlyingRustTuple<'_> {
fn from(value: InvalidUnlinker) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidUnlinker {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for InvalidUnlinker {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "InvalidUnlinker()";
const SELECTOR: [u8; 4] = [78u8, 182u8, 109u8, 143u8];
#[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 LinkAlreadyExists {
#[allow(missing_docs)]
pub policyClient: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub clientUser: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub identityDomain: 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::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::FixedBytes<32>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Address,
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<LinkAlreadyExists> for UnderlyingRustTuple<'_> {
fn from(value: LinkAlreadyExists) -> Self {
(value.policyClient, value.clientUser, value.identityDomain)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for LinkAlreadyExists {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
policyClient: tuple.0,
clientUser: tuple.1,
identityDomain: tuple.2,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for LinkAlreadyExists {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "LinkAlreadyExists(address,address,bytes32)";
const SELECTOR: [u8; 4] = [90u8, 214u8, 195u8, 95u8];
#[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.policyClient,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.clientUser,
),
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.identityDomain),
)
}
#[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 NoEmptyDomainsArray;
#[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<NoEmptyDomainsArray> for UnderlyingRustTuple<'_> {
fn from(value: NoEmptyDomainsArray) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for NoEmptyDomainsArray {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for NoEmptyDomainsArray {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "NoEmptyDomainsArray()";
const SELECTOR: [u8; 4] = [96u8, 6u8, 254u8, 48u8];
#[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 PolicyClientNotRegistered {
#[allow(missing_docs)]
pub client: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<PolicyClientNotRegistered>
for UnderlyingRustTuple<'_> {
fn from(value: PolicyClientNotRegistered) -> Self {
(value.client,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for PolicyClientNotRegistered {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { client: tuple.0 }
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for PolicyClientNotRegistered {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "PolicyClientNotRegistered(address)";
const SELECTOR: [u8; 4] = [90u8, 12u8, 81u8, 55u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.client,
),
)
}
#[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 SignatureExpired;
#[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<SignatureExpired> for UnderlyingRustTuple<'_> {
fn from(value: SignatureExpired) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureExpired {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for SignatureExpired {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "SignatureExpired()";
const SELECTOR: [u8; 4] = [8u8, 25u8, 189u8, 205u8];
#[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 TooManyDomainsAtOnce;
#[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<TooManyDomainsAtOnce> for UnderlyingRustTuple<'_> {
fn from(value: TooManyDomainsAtOnce) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for TooManyDomainsAtOnce {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
#[automatically_derived]
impl alloy_sol_types::SolError for TooManyDomainsAtOnce {
type Parameters<'a> = UnderlyingSolTuple<'a>;
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "TooManyDomainsAtOnce()";
const SELECTOR: [u8; 4] = [236u8, 213u8, 66u8, 176u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
<Self::Parameters<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(Self::new)
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct EIP712DomainChanged;
#[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 EIP712DomainChanged {
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>,);
const SIGNATURE: &'static str = "EIP712DomainChanged()";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
10u8, 99u8, 135u8, 201u8, 234u8, 54u8, 40u8, 184u8, 138u8, 99u8, 59u8,
180u8, 243u8, 177u8, 81u8, 119u8, 15u8, 112u8, 8u8, 81u8, 23u8, 161u8,
95u8, 155u8, 243u8, 120u8, 124u8, 218u8, 83u8, 241u8, 61u8, 49u8,
]);
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 {}
}
#[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(),)
}
#[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 EIP712DomainChanged {
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<&EIP712DomainChanged> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &EIP712DomainChanged) -> 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 IdentityBound {
#[allow(missing_docs)]
pub identityOwner: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub identityDomain: alloy::sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub identityData: 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;
#[automatically_derived]
impl alloy_sol_types::SolEvent for IdentityBound {
type DataTuple<'a> = (
alloy::sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::String,
);
type DataToken<'a> = <Self::DataTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (
alloy_sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
);
const SIGNATURE: &'static str = "IdentityBound(address,bytes32,string)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
103u8, 16u8, 119u8, 247u8, 120u8, 69u8, 36u8, 150u8, 162u8, 177u8, 40u8,
238u8, 177u8, 200u8, 148u8, 52u8, 54u8, 140u8, 132u8, 179u8, 181u8, 98u8,
46u8, 254u8, 223u8, 71u8, 177u8, 187u8, 174u8, 116u8, 192u8, 190u8,
]);
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 {
identityOwner: topics.1,
identityDomain: data.0,
identityData: data.1,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(
alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
),
);
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.identityDomain),
<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.identityData,
),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(Self::SIGNATURE_HASH.into(), self.identityOwner.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.identityOwner,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for IdentityBound {
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<&IdentityBound> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &IdentityBound) -> 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 IdentityLinked {
#[allow(missing_docs)]
pub identityOwner: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub policyClient: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub policyClientUser: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub identityDomain: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for IdentityLinked {
type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type DataToken<'a> = <Self::DataTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (
alloy_sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
const SIGNATURE: &'static str = "IdentityLinked(address,address,address,bytes32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
198u8, 243u8, 159u8, 136u8, 13u8, 74u8, 170u8, 29u8, 190u8, 199u8, 97u8,
143u8, 92u8, 171u8, 117u8, 47u8, 27u8, 246u8, 251u8, 138u8, 19u8, 87u8,
234u8, 237u8, 97u8, 234u8, 98u8, 227u8, 135u8, 123u8, 158u8, 100u8,
]);
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 {
identityOwner: topics.1,
policyClient: topics.2,
policyClientUser: topics.3,
identityDomain: 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::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.identityDomain),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(
Self::SIGNATURE_HASH.into(),
self.identityOwner.clone(),
self.policyClient.clone(),
self.policyClientUser.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.identityOwner,
);
out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.policyClient,
);
out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.policyClientUser,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for IdentityLinked {
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<&IdentityLinked> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &IdentityLinked) -> 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 IdentityUnlinked {
#[allow(missing_docs)]
pub identityOwner: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub policyClient: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub policyClientUser: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub identityDomain: alloy::sol_types::private::FixedBytes<32>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
#[automatically_derived]
impl alloy_sol_types::SolEvent for IdentityUnlinked {
type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
type DataToken<'a> = <Self::DataTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type TopicList = (
alloy_sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
const SIGNATURE: &'static str = "IdentityUnlinked(address,address,address,bytes32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
98u8, 248u8, 54u8, 248u8, 80u8, 173u8, 148u8, 42u8, 230u8, 19u8, 12u8,
29u8, 159u8, 92u8, 166u8, 92u8, 125u8, 128u8, 104u8, 237u8, 198u8, 15u8,
246u8, 229u8, 7u8, 106u8, 132u8, 185u8, 68u8, 7u8, 55u8, 46u8,
]);
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 {
identityOwner: topics.1,
policyClient: topics.2,
policyClientUser: topics.3,
identityDomain: 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::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.identityDomain),
)
}
#[inline]
fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
(
Self::SIGNATURE_HASH.into(),
self.identityOwner.clone(),
self.policyClient.clone(),
self.policyClientUser.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.identityOwner,
);
out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.policyClient,
);
out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
&self.policyClientUser,
);
Ok(())
}
}
#[automatically_derived]
impl alloy_sol_types::private::IntoLogData for IdentityUnlinked {
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<&IdentityUnlinked> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &IdentityUnlinked) -> 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)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct constructorCall {
#[allow(missing_docs)]
pub _provider: alloy::sol_types::private::Address,
}
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<constructorCall> for UnderlyingRustTuple<'_> {
fn from(value: constructorCall) -> Self {
(value._provider,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _provider: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolConstructor for constructorCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
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::Address as alloy_sol_types::SolType>::tokenize(
&self._provider,
),
)
}
}
};
#[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 LINK_SIGNER_TYPEHASHCall;
#[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 LINK_SIGNER_TYPEHASHReturn {
#[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<LINK_SIGNER_TYPEHASHCall>
for UnderlyingRustTuple<'_> {
fn from(value: LINK_SIGNER_TYPEHASHCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for LINK_SIGNER_TYPEHASHCall {
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<LINK_SIGNER_TYPEHASHReturn>
for UnderlyingRustTuple<'_> {
fn from(value: LINK_SIGNER_TYPEHASHReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for LINK_SIGNER_TYPEHASHReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for LINK_SIGNER_TYPEHASHCall {
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 = "LINK_SIGNER_TYPEHASH()";
const SELECTOR: [u8; 4] = [62u8, 200u8, 20u8, 3u8];
#[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: LINK_SIGNER_TYPEHASHReturn = 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: LINK_SIGNER_TYPEHASHReturn = 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 LINK_USER_TYPEHASHCall;
#[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 LINK_USER_TYPEHASHReturn {
#[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<LINK_USER_TYPEHASHCall>
for UnderlyingRustTuple<'_> {
fn from(value: LINK_USER_TYPEHASHCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for LINK_USER_TYPEHASHCall {
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<LINK_USER_TYPEHASHReturn>
for UnderlyingRustTuple<'_> {
fn from(value: LINK_USER_TYPEHASHReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for LINK_USER_TYPEHASHReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for LINK_USER_TYPEHASHCall {
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 = "LINK_USER_TYPEHASH()";
const SELECTOR: [u8; 4] = [107u8, 25u8, 3u8, 131u8];
#[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: LINK_USER_TYPEHASHReturn = 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: LINK_USER_TYPEHASHReturn = 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 MAX_LINKSCall;
#[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 MAX_LINKSReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<MAX_LINKSCall> for UnderlyingRustTuple<'_> {
fn from(value: MAX_LINKSCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for MAX_LINKSCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<MAX_LINKSReturn> for UnderlyingRustTuple<'_> {
fn from(value: MAX_LINKSReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for MAX_LINKSReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for MAX_LINKSCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::primitives::aliases::U256;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "MAX_LINKS()";
const SELECTOR: [u8; 4] = [178u8, 216u8, 38u8, 216u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: MAX_LINKSReturn = 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: MAX_LINKSReturn = 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 REGISTER_IDENTITY_TYPEHASHCall;
#[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 REGISTER_IDENTITY_TYPEHASHReturn {
#[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<REGISTER_IDENTITY_TYPEHASHCall>
for UnderlyingRustTuple<'_> {
fn from(value: REGISTER_IDENTITY_TYPEHASHCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for REGISTER_IDENTITY_TYPEHASHCall {
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<REGISTER_IDENTITY_TYPEHASHReturn>
for UnderlyingRustTuple<'_> {
fn from(value: REGISTER_IDENTITY_TYPEHASHReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for REGISTER_IDENTITY_TYPEHASHReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for REGISTER_IDENTITY_TYPEHASHCall {
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 = "REGISTER_IDENTITY_TYPEHASH()";
const SELECTOR: [u8; 4] = [111u8, 124u8, 118u8, 88u8];
#[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: REGISTER_IDENTITY_TYPEHASHReturn = 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: REGISTER_IDENTITY_TYPEHASHReturn = 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 addressesProviderCall;
#[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 addressesProviderReturn {
#[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<addressesProviderCall>
for UnderlyingRustTuple<'_> {
fn from(value: addressesProviderCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for addressesProviderCall {
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<addressesProviderReturn>
for UnderlyingRustTuple<'_> {
fn from(value: addressesProviderReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for addressesProviderReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for addressesProviderCall {
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 = "addressesProvider()";
const SELECTOR: [u8; 4] = [199u8, 44u8, 77u8, 16u8];
#[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: addressesProviderReturn = 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: addressesProviderReturn = 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 attestationValidatorCall;
#[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 attestationValidatorReturn {
#[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<attestationValidatorCall>
for UnderlyingRustTuple<'_> {
fn from(value: attestationValidatorCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for attestationValidatorCall {
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<attestationValidatorReturn>
for UnderlyingRustTuple<'_> {
fn from(value: attestationValidatorReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for attestationValidatorReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for attestationValidatorCall {
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 = "attestationValidator()";
const SELECTOR: [u8; 4] = [199u8, 98u8, 31u8, 118u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn 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: attestationValidatorReturn = 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: attestationValidatorReturn = 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 batchTaskManagerCall;
#[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 batchTaskManagerReturn {
#[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<batchTaskManagerCall>
for UnderlyingRustTuple<'_> {
fn from(value: batchTaskManagerCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for batchTaskManagerCall {
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<batchTaskManagerReturn>
for UnderlyingRustTuple<'_> {
fn from(value: batchTaskManagerReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for batchTaskManagerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for batchTaskManagerCall {
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 = "batchTaskManager()";
const SELECTOR: [u8; 4] = [171u8, 212u8, 118u8, 210u8];
#[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: batchTaskManagerReturn = 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: batchTaskManagerReturn = 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 challengeVerifierCall;
#[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 challengeVerifierReturn {
#[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<challengeVerifierCall>
for UnderlyingRustTuple<'_> {
fn from(value: challengeVerifierCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for challengeVerifierCall {
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<challengeVerifierReturn>
for UnderlyingRustTuple<'_> {
fn from(value: challengeVerifierReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for challengeVerifierReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for challengeVerifierCall {
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 = "challengeVerifier()";
const SELECTOR: [u8; 4] = [224u8, 248u8, 77u8, 251u8];
#[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: challengeVerifierReturn = 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: challengeVerifierReturn = 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 eip712DomainCall;
#[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 eip712DomainReturn {
#[allow(missing_docs)]
pub fields: alloy::sol_types::private::FixedBytes<1>,
#[allow(missing_docs)]
pub name: alloy::sol_types::private::String,
#[allow(missing_docs)]
pub version: alloy::sol_types::private::String,
#[allow(missing_docs)]
pub chainId: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub verifyingContract: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub salt: alloy::sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub extensions: alloy::sol_types::private::Vec<
alloy::sol_types::private::primitives::aliases::U256,
>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<eip712DomainCall> for UnderlyingRustTuple<'_> {
fn from(value: eip712DomainCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for eip712DomainCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::FixedBytes<1>,
alloy::sol_types::sol_data::String,
alloy::sol_types::sol_data::String,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::FixedBytes<1>,
alloy::sol_types::private::String,
alloy::sol_types::private::String,
alloy::sol_types::private::primitives::aliases::U256,
alloy::sol_types::private::Address,
alloy::sol_types::private::FixedBytes<32>,
alloy::sol_types::private::Vec<
alloy::sol_types::private::primitives::aliases::U256,
>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<eip712DomainReturn> for UnderlyingRustTuple<'_> {
fn from(value: eip712DomainReturn) -> Self {
(
value.fields,
value.name,
value.version,
value.chainId,
value.verifyingContract,
value.salt,
value.extensions,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for eip712DomainReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
fields: tuple.0,
name: tuple.1,
version: tuple.2,
chainId: tuple.3,
verifyingContract: tuple.4,
salt: tuple.5,
extensions: tuple.6,
}
}
}
}
impl eip712DomainReturn {
fn _tokenize(
&self,
) -> <eip712DomainCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::FixedBytes<
1,
> as alloy_sol_types::SolType>::tokenize(&self.fields),
<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.name,
),
<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.version,
),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self.chainId),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.verifyingContract,
),
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.salt),
<alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::Uint<256>,
> as alloy_sol_types::SolType>::tokenize(&self.extensions),
)
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for eip712DomainCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = eip712DomainReturn;
type ReturnTuple<'a> = (
alloy::sol_types::sol_data::FixedBytes<1>,
alloy::sol_types::sol_data::String,
alloy::sol_types::sol_data::String,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "eip712Domain()";
const SELECTOR: [u8; 4] = [132u8, 176u8, 25u8, 110u8];
#[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<'_> {
eip712DomainReturn::_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 getLinkedDomainsCall {
#[allow(missing_docs)]
pub policyClient: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub clientUser: alloy::sol_types::private::Address,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct getLinkedDomainsReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Vec<
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::Address,
alloy::sol_types::sol_data::Address,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Address,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getLinkedDomainsCall>
for UnderlyingRustTuple<'_> {
fn from(value: getLinkedDomainsCall) -> Self {
(value.policyClient, value.clientUser)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getLinkedDomainsCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
policyClient: tuple.0,
clientUser: tuple.1,
}
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Vec<
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<getLinkedDomainsReturn>
for UnderlyingRustTuple<'_> {
fn from(value: getLinkedDomainsReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for getLinkedDomainsReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getLinkedDomainsCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>;
type ReturnTuple<'a> = (
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getLinkedDomains(address,address)";
const SELECTOR: [u8; 4] = [240u8, 58u8, 219u8, 157u8];
#[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.policyClient,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.clientUser,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Array<
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: getLinkedDomainsReturn = 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: getLinkedDomainsReturn = 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 hasLinkedIdentityCall {
#[allow(missing_docs)]
pub policyClient: alloy::sol_types::private::Address,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct hasLinkedIdentityReturn {
#[allow(missing_docs)]
pub _0: bool,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::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<hasLinkedIdentityCall>
for UnderlyingRustTuple<'_> {
fn from(value: hasLinkedIdentityCall) -> Self {
(value.policyClient,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for hasLinkedIdentityCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { policyClient: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (bool,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<hasLinkedIdentityReturn>
for UnderlyingRustTuple<'_> {
fn from(value: hasLinkedIdentityReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for hasLinkedIdentityReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for hasLinkedIdentityCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = bool;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "hasLinkedIdentity(address)";
const SELECTOR: [u8; 4] = [157u8, 205u8, 193u8, 41u8];
#[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.policyClient,
),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: hasLinkedIdentityReturn = 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: hasLinkedIdentityReturn = 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 identityDataCall {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _1: 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 identityDataReturn {
#[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> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::FixedBytes<32>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
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<identityDataCall> for UnderlyingRustTuple<'_> {
fn from(value: identityDataCall) -> Self {
(value._0, value._1)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for identityDataCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0, _1: tuple.1 }
}
}
}
{
#[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<identityDataReturn> for UnderlyingRustTuple<'_> {
fn from(value: identityDataReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for identityDataReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for identityDataCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
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::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 = "identityData(address,bytes32)";
const SELECTOR: [u8; 4] = [33u8, 33u8, 98u8, 208u8];
#[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._0,
),
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self._1),
)
}
#[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: identityDataReturn = 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: identityDataReturn = 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(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> = ();
#[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<initializeCall> for UnderlyingRustTuple<'_> {
fn from(value: initializeCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
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<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> = ();
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()";
const SELECTOR: [u8; 4] = [129u8, 41u8, 252u8, 28u8];
#[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<'_> {
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 linkIdentityCall {
#[allow(missing_docs)]
pub _identityOwner: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _clientUser: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _policyClient: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _identityDomains: alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
#[allow(missing_docs)]
pub _identityOwnerSignature: alloy::sol_types::private::Bytes,
#[allow(missing_docs)]
pub _identityOwnerNonce: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub _identityOwnerDeadline: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub _clientUserSignature: alloy::sol_types::private::Bytes,
#[allow(missing_docs)]
pub _clientUserNonce: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub _clientUserDeadline: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct linkIdentityReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Address,
alloy::sol_types::private::Address,
alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
alloy::sol_types::private::Bytes,
alloy::sol_types::private::primitives::aliases::U256,
alloy::sol_types::private::primitives::aliases::U256,
alloy::sol_types::private::Bytes,
alloy::sol_types::private::primitives::aliases::U256,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<linkIdentityCall> for UnderlyingRustTuple<'_> {
fn from(value: linkIdentityCall) -> Self {
(
value._identityOwner,
value._clientUser,
value._policyClient,
value._identityDomains,
value._identityOwnerSignature,
value._identityOwnerNonce,
value._identityOwnerDeadline,
value._clientUserSignature,
value._clientUserNonce,
value._clientUserDeadline,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for linkIdentityCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
_identityOwner: tuple.0,
_clientUser: tuple.1,
_policyClient: tuple.2,
_identityDomains: tuple.3,
_identityOwnerSignature: tuple.4,
_identityOwnerNonce: tuple.5,
_identityOwnerDeadline: tuple.6,
_clientUserSignature: tuple.7,
_clientUserNonce: tuple.8,
_clientUserDeadline: tuple.9,
}
}
}
}
{
#[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<linkIdentityReturn> for UnderlyingRustTuple<'_> {
fn from(value: linkIdentityReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for linkIdentityReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl linkIdentityReturn {
fn _tokenize(
&self,
) -> <linkIdentityCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for linkIdentityCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = linkIdentityReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "linkIdentity(address,address,address,bytes32[],bytes,uint256,uint256,bytes,uint256,uint256)";
const SELECTOR: [u8; 4] = [149u8, 180u8, 179u8, 255u8];
#[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._identityOwner,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self._clientUser,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self._policyClient,
),
<alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
> as alloy_sol_types::SolType>::tokenize(&self._identityDomains),
<alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
&self._identityOwnerSignature,
),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self._identityOwnerNonce),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(
&self._identityOwnerDeadline,
),
<alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
&self._clientUserSignature,
),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self._clientUserNonce),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self._clientUserDeadline),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
linkIdentityReturn::_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 linkIdentityAsSignerCall {
#[allow(missing_docs)]
pub _policyClient: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _identityDomains: alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
#[allow(missing_docs)]
pub _clientUser: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _signature: alloy::sol_types::private::Bytes,
#[allow(missing_docs)]
pub _nonce: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub _deadline: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct linkIdentityAsSignerReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
alloy::sol_types::private::Address,
alloy::sol_types::private::Bytes,
alloy::sol_types::private::primitives::aliases::U256,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<linkIdentityAsSignerCall>
for UnderlyingRustTuple<'_> {
fn from(value: linkIdentityAsSignerCall) -> Self {
(
value._policyClient,
value._identityDomains,
value._clientUser,
value._signature,
value._nonce,
value._deadline,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for linkIdentityAsSignerCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
_policyClient: tuple.0,
_identityDomains: tuple.1,
_clientUser: tuple.2,
_signature: tuple.3,
_nonce: tuple.4,
_deadline: tuple.5,
}
}
}
}
{
#[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<linkIdentityAsSignerReturn>
for UnderlyingRustTuple<'_> {
fn from(value: linkIdentityAsSignerReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for linkIdentityAsSignerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl linkIdentityAsSignerReturn {
fn _tokenize(
&self,
) -> <linkIdentityAsSignerCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for linkIdentityAsSignerCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = linkIdentityAsSignerReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "linkIdentityAsSigner(address,bytes32[],address,bytes,uint256,uint256)";
const SELECTOR: [u8; 4] = [245u8, 84u8, 201u8, 98u8];
#[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._policyClient,
),
<alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
> as alloy_sol_types::SolType>::tokenize(&self._identityDomains),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self._clientUser,
),
<alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
&self._signature,
),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self._nonce),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self._deadline),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
linkIdentityAsSignerReturn::_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 linkIdentityAsSignerAndUserCall {
#[allow(missing_docs)]
pub _policyClient: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _identityDomains: alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct linkIdentityAsSignerAndUserReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Vec<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<linkIdentityAsSignerAndUserCall>
for UnderlyingRustTuple<'_> {
fn from(value: linkIdentityAsSignerAndUserCall) -> Self {
(value._policyClient, value._identityDomains)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for linkIdentityAsSignerAndUserCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
_policyClient: tuple.0,
_identityDomains: 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<linkIdentityAsSignerAndUserReturn>
for UnderlyingRustTuple<'_> {
fn from(value: linkIdentityAsSignerAndUserReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for linkIdentityAsSignerAndUserReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl linkIdentityAsSignerAndUserReturn {
fn _tokenize(
&self,
) -> <linkIdentityAsSignerAndUserCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for linkIdentityAsSignerAndUserCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = linkIdentityAsSignerAndUserReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "linkIdentityAsSignerAndUser(address,bytes32[])";
const SELECTOR: [u8; 4] = [234u8, 195u8, 209u8, 164u8];
#[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._policyClient,
),
<alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
> as alloy_sol_types::SolType>::tokenize(&self._identityDomains),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
linkIdentityAsSignerAndUserReturn::_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 linkIdentityAsUserCall {
#[allow(missing_docs)]
pub _identityOwner: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _policyClient: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _identityDomains: alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
#[allow(missing_docs)]
pub _signature: alloy::sol_types::private::Bytes,
#[allow(missing_docs)]
pub _nonce: alloy::sol_types::private::primitives::aliases::U256,
#[allow(missing_docs)]
pub _deadline: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct linkIdentityAsUserReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Address,
alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
alloy::sol_types::private::Bytes,
alloy::sol_types::private::primitives::aliases::U256,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<linkIdentityAsUserCall>
for UnderlyingRustTuple<'_> {
fn from(value: linkIdentityAsUserCall) -> Self {
(
value._identityOwner,
value._policyClient,
value._identityDomains,
value._signature,
value._nonce,
value._deadline,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for linkIdentityAsUserCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
_identityOwner: tuple.0,
_policyClient: tuple.1,
_identityDomains: tuple.2,
_signature: tuple.3,
_nonce: tuple.4,
_deadline: tuple.5,
}
}
}
}
{
#[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<linkIdentityAsUserReturn>
for UnderlyingRustTuple<'_> {
fn from(value: linkIdentityAsUserReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for linkIdentityAsUserReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl linkIdentityAsUserReturn {
fn _tokenize(
&self,
) -> <linkIdentityAsUserCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for linkIdentityAsUserCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Uint<256>,
alloy::sol_types::sol_data::Uint<256>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = linkIdentityAsUserReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "linkIdentityAsUser(address,address,bytes32[],bytes,uint256,uint256)";
const SELECTOR: [u8; 4] = [8u8, 228u8, 132u8, 147u8];
#[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._identityOwner,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self._policyClient,
),
<alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
> as alloy_sol_types::SolType>::tokenize(&self._identityDomains),
<alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
&self._signature,
),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self._nonce),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self._deadline),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
linkIdentityAsUserReturn::_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 noncesCall {
#[allow(missing_docs)]
pub owner: alloy::sol_types::private::Address,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct noncesReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::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<noncesCall> for UnderlyingRustTuple<'_> {
fn from(value: noncesCall) -> Self {
(value.owner,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { owner: tuple.0 }
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<noncesReturn> for UnderlyingRustTuple<'_> {
fn from(value: noncesReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for noncesReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for noncesCall {
type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::primitives::aliases::U256;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "nonces(address)";
const SELECTOR: [u8; 4] = [126u8, 206u8, 190u8, 0u8];
#[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<'_> {
(
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(ret),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: noncesReturn = 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: noncesReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct operatorRegistryCall;
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct operatorRegistryReturn {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<operatorRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: operatorRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for operatorRegistryCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<operatorRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: operatorRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for operatorRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for operatorRegistryCall {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = alloy::sol_types::private::Address;
type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "operatorRegistry()";
const SELECTOR: [u8; 4] = [88u8, 194u8, 34u8, 91u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
ret,
),
)
}
#[inline]
fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data)
.map(|r| {
let r: operatorRegistryReturn = r.into();
r._0
})
}
#[inline]
fn abi_decode_returns_validate(
data: &[u8],
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
.map(|r| {
let r: operatorRegistryReturn = r.into();
r._0
})
}
}
};
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Default, Debug, PartialEq, Eq, Hash)]
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct policyClientLinksCall {
#[allow(missing_docs)]
pub _0: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _1: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _2: 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 policyClientLinksReturn {
#[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::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::FixedBytes<32>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Address,
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<policyClientLinksCall>
for UnderlyingRustTuple<'_> {
fn from(value: policyClientLinksCall) -> Self {
(value._0, value._1, value._2)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for policyClientLinksCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
_0: tuple.0,
_1: tuple.1,
_2: tuple.2,
}
}
}
}
{
#[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<policyClientLinksReturn>
for UnderlyingRustTuple<'_> {
fn from(value: policyClientLinksReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for policyClientLinksReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for policyClientLinksCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
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 = "policyClientLinks(address,address,bytes32)";
const SELECTOR: [u8; 4] = [238u8, 14u8, 90u8, 127u8];
#[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._0,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self._1,
),
<alloy::sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self._2),
)
}
#[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: policyClientLinksReturn = 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: policyClientLinksReturn = 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 policyClientRegistryCall;
#[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 policyClientRegistryReturn {
#[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<policyClientRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: policyClientRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for policyClientRegistryCall {
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<policyClientRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: policyClientRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for policyClientRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for policyClientRegistryCall {
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 = "policyClientRegistry()";
const SELECTOR: [u8; 4] = [169u8, 221u8, 180u8, 133u8];
#[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: policyClientRegistryReturn = 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: policyClientRegistryReturn = 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 registerIdentityDataCall {
#[allow(missing_docs)]
pub _identityDomain: alloy::sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub _dataRefId: alloy::sol_types::private::String,
#[allow(missing_docs)]
pub _gatewaySignature: alloy::sol_types::private::Bytes,
#[allow(missing_docs)]
pub _deadline: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct registerIdentityDataReturn {}
#[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::String,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::FixedBytes<32>,
alloy::sol_types::private::String,
alloy::sol_types::private::Bytes,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<registerIdentityDataCall>
for UnderlyingRustTuple<'_> {
fn from(value: registerIdentityDataCall) -> Self {
(
value._identityDomain,
value._dataRefId,
value._gatewaySignature,
value._deadline,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for registerIdentityDataCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
_identityDomain: tuple.0,
_dataRefId: tuple.1,
_gatewaySignature: tuple.2,
_deadline: tuple.3,
}
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<registerIdentityDataReturn>
for UnderlyingRustTuple<'_> {
fn from(value: registerIdentityDataReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for registerIdentityDataReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl registerIdentityDataReturn {
fn _tokenize(
&self,
) -> <registerIdentityDataCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for registerIdentityDataCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::FixedBytes<32>,
alloy::sol_types::sol_data::String,
alloy::sol_types::sol_data::Bytes,
alloy::sol_types::sol_data::Uint<256>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = registerIdentityDataReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "registerIdentityData(bytes32,string,bytes,uint256)";
const SELECTOR: [u8; 4] = [194u8, 214u8, 43u8, 151u8];
#[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._identityDomain),
<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self._dataRefId,
),
<alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
&self._gatewaySignature,
),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self._deadline),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
registerIdentityDataReturn::_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 regoVerifierCall;
#[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 regoVerifierReturn {
#[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<regoVerifierCall> for UnderlyingRustTuple<'_> {
fn from(value: regoVerifierCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for regoVerifierCall {
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<regoVerifierReturn> for UnderlyingRustTuple<'_> {
fn from(value: regoVerifierReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for regoVerifierReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for regoVerifierCall {
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 = "regoVerifier()";
const SELECTOR: [u8; 4] = [163u8, 154u8, 110u8, 225u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn 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: regoVerifierReturn = 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: regoVerifierReturn = 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 seedLinkCountCall {
#[allow(missing_docs)]
pub policyClient: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub count: alloy::sol_types::private::primitives::aliases::U256,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct seedLinkCountReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<256>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::primitives::aliases::U256,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<seedLinkCountCall> for UnderlyingRustTuple<'_> {
fn from(value: seedLinkCountCall) -> Self {
(value.policyClient, value.count)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for seedLinkCountCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
policyClient: tuple.0,
count: 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<seedLinkCountReturn> for UnderlyingRustTuple<'_> {
fn from(value: seedLinkCountReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for seedLinkCountReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl seedLinkCountReturn {
fn _tokenize(
&self,
) -> <seedLinkCountCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for seedLinkCountCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Uint<256>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = seedLinkCountReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "seedLinkCount(address,uint256)";
const SELECTOR: [u8; 4] = [252u8, 120u8, 130u8, 203u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self.policyClient,
),
<alloy::sol_types::sol_data::Uint<
256,
> as alloy_sol_types::SolType>::tokenize(&self.count),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
seedLinkCountReturn::_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 serviceManagerCall;
#[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 serviceManagerReturn {
#[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<serviceManagerCall> for UnderlyingRustTuple<'_> {
fn from(value: serviceManagerCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for serviceManagerCall {
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<serviceManagerReturn>
for UnderlyingRustTuple<'_> {
fn from(value: serviceManagerReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for serviceManagerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for serviceManagerCall {
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 = "serviceManager()";
const SELECTOR: [u8; 4] = [57u8, 152u8, 253u8, 211u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
(
<alloy::sol_types::sol_data::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: serviceManagerReturn = 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: serviceManagerReturn = 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 socketRegistryCall;
#[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 socketRegistryReturn {
#[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<socketRegistryCall> for UnderlyingRustTuple<'_> {
fn from(value: socketRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for socketRegistryCall {
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<socketRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: socketRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for socketRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for socketRegistryCall {
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 = "socketRegistry()";
const SELECTOR: [u8; 4] = [234u8, 50u8, 175u8, 174u8];
#[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: socketRegistryReturn = 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: socketRegistryReturn = 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 stateCommitRegistryCall;
#[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 stateCommitRegistryReturn {
#[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<stateCommitRegistryCall>
for UnderlyingRustTuple<'_> {
fn from(value: stateCommitRegistryCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for stateCommitRegistryCall {
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<stateCommitRegistryReturn>
for UnderlyingRustTuple<'_> {
fn from(value: stateCommitRegistryReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for stateCommitRegistryReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for stateCommitRegistryCall {
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 = "stateCommitRegistry()";
const SELECTOR: [u8; 4] = [209u8, 240u8, 177u8, 164u8];
#[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: stateCommitRegistryReturn = 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: stateCommitRegistryReturn = 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 taskManagerCall;
#[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 taskManagerReturn {
#[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<taskManagerCall> for UnderlyingRustTuple<'_> {
fn from(value: taskManagerCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for taskManagerCall {
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<taskManagerReturn> for UnderlyingRustTuple<'_> {
fn from(value: taskManagerReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for taskManagerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for taskManagerCall {
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 = "taskManager()";
const SELECTOR: [u8; 4] = [165u8, 10u8, 100u8, 14u8];
#[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: taskManagerReturn = 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: taskManagerReturn = 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 unlinkIdentityAsSignerCall {
#[allow(missing_docs)]
pub _clientUser: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _policyClient: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _identityDomains: alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct unlinkIdentityAsSignerReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Address,
alloy::sol_types::private::Vec<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<unlinkIdentityAsSignerCall>
for UnderlyingRustTuple<'_> {
fn from(value: unlinkIdentityAsSignerCall) -> Self {
(value._clientUser, value._policyClient, value._identityDomains)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for unlinkIdentityAsSignerCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
_clientUser: tuple.0,
_policyClient: tuple.1,
_identityDomains: tuple.2,
}
}
}
}
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<unlinkIdentityAsSignerReturn>
for UnderlyingRustTuple<'_> {
fn from(value: unlinkIdentityAsSignerReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for unlinkIdentityAsSignerReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl unlinkIdentityAsSignerReturn {
fn _tokenize(
&self,
) -> <unlinkIdentityAsSignerCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for unlinkIdentityAsSignerCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = unlinkIdentityAsSignerReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "unlinkIdentityAsSigner(address,address,bytes32[])";
const SELECTOR: [u8; 4] = [70u8, 124u8, 95u8, 81u8];
#[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._clientUser,
),
<alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
&self._policyClient,
),
<alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
> as alloy_sol_types::SolType>::tokenize(&self._identityDomains),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
unlinkIdentityAsSignerReturn::_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 unlinkIdentityAsUserCall {
#[allow(missing_docs)]
pub _policyClient: alloy::sol_types::private::Address,
#[allow(missing_docs)]
pub _identityDomains: alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct unlinkIdentityAsUserReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use alloy::sol_types as alloy_sol_types;
{
#[doc(hidden)]
#[allow(dead_code)]
type UnderlyingSolTuple<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
alloy::sol_types::private::Address,
alloy::sol_types::private::Vec<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<unlinkIdentityAsUserCall>
for UnderlyingRustTuple<'_> {
fn from(value: unlinkIdentityAsUserCall) -> Self {
(value._policyClient, value._identityDomains)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for unlinkIdentityAsUserCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
_policyClient: tuple.0,
_identityDomains: 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<unlinkIdentityAsUserReturn>
for UnderlyingRustTuple<'_> {
fn from(value: unlinkIdentityAsUserReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for unlinkIdentityAsUserReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
impl unlinkIdentityAsUserReturn {
fn _tokenize(
&self,
) -> <unlinkIdentityAsUserCall as alloy_sol_types::SolCall>::ReturnToken<
'_,
> {
()
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for unlinkIdentityAsUserCall {
type Parameters<'a> = (
alloy::sol_types::sol_data::Address,
alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = unlinkIdentityAsUserReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "unlinkIdentityAsUser(address,bytes32[])";
const SELECTOR: [u8; 4] = [248u8, 34u8, 58u8, 244u8];
#[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._policyClient,
),
<alloy::sol_types::sol_data::Array<
alloy::sol_types::sol_data::FixedBytes<32>,
> as alloy_sol_types::SolType>::tokenize(&self._identityDomains),
)
}
#[inline]
fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
unlinkIdentityAsUserReturn::_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 viewBN254CertificateVerifierCall;
#[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 viewBN254CertificateVerifierReturn {
#[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<viewBN254CertificateVerifierCall>
for UnderlyingRustTuple<'_> {
fn from(value: viewBN254CertificateVerifierCall) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for viewBN254CertificateVerifierCall {
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<viewBN254CertificateVerifierReturn>
for UnderlyingRustTuple<'_> {
fn from(value: viewBN254CertificateVerifierReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for viewBN254CertificateVerifierReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for viewBN254CertificateVerifierCall {
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 = "viewBN254CertificateVerifier()";
const SELECTOR: [u8; 4] = [82u8, 115u8, 221u8, 181u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
()
}
#[inline]
fn 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: viewBN254CertificateVerifierReturn = 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: viewBN254CertificateVerifierReturn = r.into();
r._0
})
}
}
};
#[derive(Clone)]
#[derive(serde::Serialize, serde::Deserialize)]
#[derive()]
pub enum IdentityRegistryCalls {
#[allow(missing_docs)]
LINK_SIGNER_TYPEHASH(LINK_SIGNER_TYPEHASHCall),
#[allow(missing_docs)]
LINK_USER_TYPEHASH(LINK_USER_TYPEHASHCall),
#[allow(missing_docs)]
MAX_LINKS(MAX_LINKSCall),
#[allow(missing_docs)]
REGISTER_IDENTITY_TYPEHASH(REGISTER_IDENTITY_TYPEHASHCall),
#[allow(missing_docs)]
addressesProvider(addressesProviderCall),
#[allow(missing_docs)]
attestationValidator(attestationValidatorCall),
#[allow(missing_docs)]
batchTaskManager(batchTaskManagerCall),
#[allow(missing_docs)]
challengeVerifier(challengeVerifierCall),
#[allow(missing_docs)]
eip712Domain(eip712DomainCall),
#[allow(missing_docs)]
getLinkedDomains(getLinkedDomainsCall),
#[allow(missing_docs)]
hasLinkedIdentity(hasLinkedIdentityCall),
#[allow(missing_docs)]
identityData(identityDataCall),
#[allow(missing_docs)]
initialize(initializeCall),
#[allow(missing_docs)]
linkIdentity(linkIdentityCall),
#[allow(missing_docs)]
linkIdentityAsSigner(linkIdentityAsSignerCall),
#[allow(missing_docs)]
linkIdentityAsSignerAndUser(linkIdentityAsSignerAndUserCall),
#[allow(missing_docs)]
linkIdentityAsUser(linkIdentityAsUserCall),
#[allow(missing_docs)]
nonces(noncesCall),
#[allow(missing_docs)]
operatorRegistry(operatorRegistryCall),
#[allow(missing_docs)]
policyClientLinks(policyClientLinksCall),
#[allow(missing_docs)]
policyClientRegistry(policyClientRegistryCall),
#[allow(missing_docs)]
registerIdentityData(registerIdentityDataCall),
#[allow(missing_docs)]
regoVerifier(regoVerifierCall),
#[allow(missing_docs)]
seedLinkCount(seedLinkCountCall),
#[allow(missing_docs)]
serviceManager(serviceManagerCall),
#[allow(missing_docs)]
socketRegistry(socketRegistryCall),
#[allow(missing_docs)]
stateCommitRegistry(stateCommitRegistryCall),
#[allow(missing_docs)]
taskManager(taskManagerCall),
#[allow(missing_docs)]
unlinkIdentityAsSigner(unlinkIdentityAsSignerCall),
#[allow(missing_docs)]
unlinkIdentityAsUser(unlinkIdentityAsUserCall),
#[allow(missing_docs)]
viewBN254CertificateVerifier(viewBN254CertificateVerifierCall),
}
impl IdentityRegistryCalls {
pub const SELECTORS: &'static [[u8; 4usize]] = &[
[8u8, 228u8, 132u8, 147u8],
[33u8, 33u8, 98u8, 208u8],
[57u8, 152u8, 253u8, 211u8],
[62u8, 200u8, 20u8, 3u8],
[70u8, 124u8, 95u8, 81u8],
[82u8, 115u8, 221u8, 181u8],
[88u8, 194u8, 34u8, 91u8],
[107u8, 25u8, 3u8, 131u8],
[111u8, 124u8, 118u8, 88u8],
[126u8, 206u8, 190u8, 0u8],
[129u8, 41u8, 252u8, 28u8],
[132u8, 176u8, 25u8, 110u8],
[149u8, 180u8, 179u8, 255u8],
[157u8, 205u8, 193u8, 41u8],
[163u8, 154u8, 110u8, 225u8],
[165u8, 10u8, 100u8, 14u8],
[169u8, 221u8, 180u8, 133u8],
[171u8, 212u8, 118u8, 210u8],
[178u8, 216u8, 38u8, 216u8],
[194u8, 214u8, 43u8, 151u8],
[199u8, 44u8, 77u8, 16u8],
[199u8, 98u8, 31u8, 118u8],
[209u8, 240u8, 177u8, 164u8],
[224u8, 248u8, 77u8, 251u8],
[234u8, 50u8, 175u8, 174u8],
[234u8, 195u8, 209u8, 164u8],
[238u8, 14u8, 90u8, 127u8],
[240u8, 58u8, 219u8, 157u8],
[245u8, 84u8, 201u8, 98u8],
[248u8, 34u8, 58u8, 244u8],
[252u8, 120u8, 130u8, 203u8],
];
pub const VARIANT_NAMES: &'static [&'static str] = &[
::core::stringify!(linkIdentityAsUser),
::core::stringify!(identityData),
::core::stringify!(serviceManager),
::core::stringify!(LINK_SIGNER_TYPEHASH),
::core::stringify!(unlinkIdentityAsSigner),
::core::stringify!(viewBN254CertificateVerifier),
::core::stringify!(operatorRegistry),
::core::stringify!(LINK_USER_TYPEHASH),
::core::stringify!(REGISTER_IDENTITY_TYPEHASH),
::core::stringify!(nonces),
::core::stringify!(initialize),
::core::stringify!(eip712Domain),
::core::stringify!(linkIdentity),
::core::stringify!(hasLinkedIdentity),
::core::stringify!(regoVerifier),
::core::stringify!(taskManager),
::core::stringify!(policyClientRegistry),
::core::stringify!(batchTaskManager),
::core::stringify!(MAX_LINKS),
::core::stringify!(registerIdentityData),
::core::stringify!(addressesProvider),
::core::stringify!(attestationValidator),
::core::stringify!(stateCommitRegistry),
::core::stringify!(challengeVerifier),
::core::stringify!(socketRegistry),
::core::stringify!(linkIdentityAsSignerAndUser),
::core::stringify!(policyClientLinks),
::core::stringify!(getLinkedDomains),
::core::stringify!(linkIdentityAsSigner),
::core::stringify!(unlinkIdentityAsUser),
::core::stringify!(seedLinkCount),
];
pub const SIGNATURES: &'static [&'static str] = &[
<linkIdentityAsUserCall as alloy_sol_types::SolCall>::SIGNATURE,
<identityDataCall as alloy_sol_types::SolCall>::SIGNATURE,
<serviceManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
<LINK_SIGNER_TYPEHASHCall as alloy_sol_types::SolCall>::SIGNATURE,
<unlinkIdentityAsSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
<viewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::SIGNATURE,
<operatorRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<LINK_USER_TYPEHASHCall as alloy_sol_types::SolCall>::SIGNATURE,
<REGISTER_IDENTITY_TYPEHASHCall as alloy_sol_types::SolCall>::SIGNATURE,
<noncesCall as alloy_sol_types::SolCall>::SIGNATURE,
<initializeCall as alloy_sol_types::SolCall>::SIGNATURE,
<eip712DomainCall as alloy_sol_types::SolCall>::SIGNATURE,
<linkIdentityCall as alloy_sol_types::SolCall>::SIGNATURE,
<hasLinkedIdentityCall as alloy_sol_types::SolCall>::SIGNATURE,
<regoVerifierCall as alloy_sol_types::SolCall>::SIGNATURE,
<taskManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
<policyClientRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<batchTaskManagerCall as alloy_sol_types::SolCall>::SIGNATURE,
<MAX_LINKSCall as alloy_sol_types::SolCall>::SIGNATURE,
<registerIdentityDataCall as alloy_sol_types::SolCall>::SIGNATURE,
<addressesProviderCall as alloy_sol_types::SolCall>::SIGNATURE,
<attestationValidatorCall as alloy_sol_types::SolCall>::SIGNATURE,
<stateCommitRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<challengeVerifierCall as alloy_sol_types::SolCall>::SIGNATURE,
<socketRegistryCall as alloy_sol_types::SolCall>::SIGNATURE,
<linkIdentityAsSignerAndUserCall as alloy_sol_types::SolCall>::SIGNATURE,
<policyClientLinksCall as alloy_sol_types::SolCall>::SIGNATURE,
<getLinkedDomainsCall as alloy_sol_types::SolCall>::SIGNATURE,
<linkIdentityAsSignerCall as alloy_sol_types::SolCall>::SIGNATURE,
<unlinkIdentityAsUserCall as alloy_sol_types::SolCall>::SIGNATURE,
<seedLinkCountCall 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 IdentityRegistryCalls {
const NAME: &'static str = "IdentityRegistryCalls";
const MIN_DATA_LENGTH: usize = 0usize;
const COUNT: usize = 31usize;
#[inline]
fn selector(&self) -> [u8; 4] {
match self {
Self::LINK_SIGNER_TYPEHASH(_) => {
<LINK_SIGNER_TYPEHASHCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::LINK_USER_TYPEHASH(_) => {
<LINK_USER_TYPEHASHCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::MAX_LINKS(_) => {
<MAX_LINKSCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::REGISTER_IDENTITY_TYPEHASH(_) => {
<REGISTER_IDENTITY_TYPEHASHCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::addressesProvider(_) => {
<addressesProviderCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::attestationValidator(_) => {
<attestationValidatorCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::batchTaskManager(_) => {
<batchTaskManagerCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::challengeVerifier(_) => {
<challengeVerifierCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::eip712Domain(_) => {
<eip712DomainCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getLinkedDomains(_) => {
<getLinkedDomainsCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::hasLinkedIdentity(_) => {
<hasLinkedIdentityCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::identityData(_) => {
<identityDataCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::initialize(_) => {
<initializeCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::linkIdentity(_) => {
<linkIdentityCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::linkIdentityAsSigner(_) => {
<linkIdentityAsSignerCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::linkIdentityAsSignerAndUser(_) => {
<linkIdentityAsSignerAndUserCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::linkIdentityAsUser(_) => {
<linkIdentityAsUserCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::nonces(_) => <noncesCall as alloy_sol_types::SolCall>::SELECTOR,
Self::operatorRegistry(_) => {
<operatorRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::policyClientLinks(_) => {
<policyClientLinksCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::policyClientRegistry(_) => {
<policyClientRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::registerIdentityData(_) => {
<registerIdentityDataCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::regoVerifier(_) => {
<regoVerifierCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::seedLinkCount(_) => {
<seedLinkCountCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::serviceManager(_) => {
<serviceManagerCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::socketRegistry(_) => {
<socketRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::stateCommitRegistry(_) => {
<stateCommitRegistryCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::taskManager(_) => {
<taskManagerCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::unlinkIdentityAsSigner(_) => {
<unlinkIdentityAsSignerCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::unlinkIdentityAsUser(_) => {
<unlinkIdentityAsUserCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::viewBN254CertificateVerifier(_) => {
<viewBN254CertificateVerifierCall 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<IdentityRegistryCalls>] = &[
{
fn linkIdentityAsUser(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<linkIdentityAsUserCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::linkIdentityAsUser)
}
linkIdentityAsUser
},
{
fn identityData(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<identityDataCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::identityData)
}
identityData
},
{
fn serviceManager(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<serviceManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::serviceManager)
}
serviceManager
},
{
fn LINK_SIGNER_TYPEHASH(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<LINK_SIGNER_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::LINK_SIGNER_TYPEHASH)
}
LINK_SIGNER_TYPEHASH
},
{
fn unlinkIdentityAsSigner(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<unlinkIdentityAsSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::unlinkIdentityAsSigner)
}
unlinkIdentityAsSigner
},
{
fn viewBN254CertificateVerifier(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<viewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::viewBN254CertificateVerifier)
}
viewBN254CertificateVerifier
},
{
fn operatorRegistry(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<operatorRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::operatorRegistry)
}
operatorRegistry
},
{
fn LINK_USER_TYPEHASH(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<LINK_USER_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::LINK_USER_TYPEHASH)
}
LINK_USER_TYPEHASH
},
{
fn REGISTER_IDENTITY_TYPEHASH(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<REGISTER_IDENTITY_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::REGISTER_IDENTITY_TYPEHASH)
}
REGISTER_IDENTITY_TYPEHASH
},
{
fn nonces(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<noncesCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IdentityRegistryCalls::nonces)
}
nonces
},
{
fn initialize(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::initialize)
}
initialize
},
{
fn eip712Domain(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<eip712DomainCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::eip712Domain)
}
eip712Domain
},
{
fn linkIdentity(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<linkIdentityCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::linkIdentity)
}
linkIdentity
},
{
fn hasLinkedIdentity(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<hasLinkedIdentityCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::hasLinkedIdentity)
}
hasLinkedIdentity
},
{
fn regoVerifier(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<regoVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::regoVerifier)
}
regoVerifier
},
{
fn taskManager(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<taskManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::taskManager)
}
taskManager
},
{
fn policyClientRegistry(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<policyClientRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::policyClientRegistry)
}
policyClientRegistry
},
{
fn batchTaskManager(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<batchTaskManagerCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::batchTaskManager)
}
batchTaskManager
},
{
fn MAX_LINKS(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<MAX_LINKSCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
.map(IdentityRegistryCalls::MAX_LINKS)
}
MAX_LINKS
},
{
fn registerIdentityData(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<registerIdentityDataCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::registerIdentityData)
}
registerIdentityData
},
{
fn addressesProvider(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<addressesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::addressesProvider)
}
addressesProvider
},
{
fn attestationValidator(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<attestationValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::attestationValidator)
}
attestationValidator
},
{
fn stateCommitRegistry(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<stateCommitRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::stateCommitRegistry)
}
stateCommitRegistry
},
{
fn challengeVerifier(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<challengeVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::challengeVerifier)
}
challengeVerifier
},
{
fn socketRegistry(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<socketRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::socketRegistry)
}
socketRegistry
},
{
fn linkIdentityAsSignerAndUser(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<linkIdentityAsSignerAndUserCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::linkIdentityAsSignerAndUser)
}
linkIdentityAsSignerAndUser
},
{
fn policyClientLinks(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<policyClientLinksCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::policyClientLinks)
}
policyClientLinks
},
{
fn getLinkedDomains(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<getLinkedDomainsCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::getLinkedDomains)
}
getLinkedDomains
},
{
fn linkIdentityAsSigner(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<linkIdentityAsSignerCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::linkIdentityAsSigner)
}
linkIdentityAsSigner
},
{
fn unlinkIdentityAsUser(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<unlinkIdentityAsUserCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::unlinkIdentityAsUser)
}
unlinkIdentityAsUser
},
{
fn seedLinkCount(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<seedLinkCountCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
)
.map(IdentityRegistryCalls::seedLinkCount)
}
seedLinkCount
},
];
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<IdentityRegistryCalls>] = &[
{
fn linkIdentityAsUser(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<linkIdentityAsUserCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::linkIdentityAsUser)
}
linkIdentityAsUser
},
{
fn identityData(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<identityDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::identityData)
}
identityData
},
{
fn serviceManager(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<serviceManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::serviceManager)
}
serviceManager
},
{
fn LINK_SIGNER_TYPEHASH(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<LINK_SIGNER_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::LINK_SIGNER_TYPEHASH)
}
LINK_SIGNER_TYPEHASH
},
{
fn unlinkIdentityAsSigner(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<unlinkIdentityAsSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::unlinkIdentityAsSigner)
}
unlinkIdentityAsSigner
},
{
fn viewBN254CertificateVerifier(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<viewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::viewBN254CertificateVerifier)
}
viewBN254CertificateVerifier
},
{
fn operatorRegistry(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<operatorRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::operatorRegistry)
}
operatorRegistry
},
{
fn LINK_USER_TYPEHASH(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<LINK_USER_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::LINK_USER_TYPEHASH)
}
LINK_USER_TYPEHASH
},
{
fn REGISTER_IDENTITY_TYPEHASH(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<REGISTER_IDENTITY_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::REGISTER_IDENTITY_TYPEHASH)
}
REGISTER_IDENTITY_TYPEHASH
},
{
fn nonces(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<noncesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::nonces)
}
nonces
},
{
fn initialize(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<initializeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::initialize)
}
initialize
},
{
fn eip712Domain(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<eip712DomainCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::eip712Domain)
}
eip712Domain
},
{
fn linkIdentity(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<linkIdentityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::linkIdentity)
}
linkIdentity
},
{
fn hasLinkedIdentity(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<hasLinkedIdentityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::hasLinkedIdentity)
}
hasLinkedIdentity
},
{
fn regoVerifier(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<regoVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::regoVerifier)
}
regoVerifier
},
{
fn taskManager(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<taskManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::taskManager)
}
taskManager
},
{
fn policyClientRegistry(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<policyClientRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::policyClientRegistry)
}
policyClientRegistry
},
{
fn batchTaskManager(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<batchTaskManagerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::batchTaskManager)
}
batchTaskManager
},
{
fn MAX_LINKS(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<MAX_LINKSCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::MAX_LINKS)
}
MAX_LINKS
},
{
fn registerIdentityData(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<registerIdentityDataCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::registerIdentityData)
}
registerIdentityData
},
{
fn addressesProvider(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<addressesProviderCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::addressesProvider)
}
addressesProvider
},
{
fn attestationValidator(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<attestationValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::attestationValidator)
}
attestationValidator
},
{
fn stateCommitRegistry(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<stateCommitRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::stateCommitRegistry)
}
stateCommitRegistry
},
{
fn challengeVerifier(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<challengeVerifierCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::challengeVerifier)
}
challengeVerifier
},
{
fn socketRegistry(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<socketRegistryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::socketRegistry)
}
socketRegistry
},
{
fn linkIdentityAsSignerAndUser(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<linkIdentityAsSignerAndUserCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::linkIdentityAsSignerAndUser)
}
linkIdentityAsSignerAndUser
},
{
fn policyClientLinks(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<policyClientLinksCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::policyClientLinks)
}
policyClientLinks
},
{
fn getLinkedDomains(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<getLinkedDomainsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::getLinkedDomains)
}
getLinkedDomains
},
{
fn linkIdentityAsSigner(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<linkIdentityAsSignerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::linkIdentityAsSigner)
}
linkIdentityAsSigner
},
{
fn unlinkIdentityAsUser(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<unlinkIdentityAsUserCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::unlinkIdentityAsUser)
}
unlinkIdentityAsUser
},
{
fn seedLinkCount(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryCalls> {
<seedLinkCountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryCalls::seedLinkCount)
}
seedLinkCount
},
];
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::LINK_SIGNER_TYPEHASH(inner) => {
<LINK_SIGNER_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::LINK_USER_TYPEHASH(inner) => {
<LINK_USER_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::MAX_LINKS(inner) => {
<MAX_LINKSCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::REGISTER_IDENTITY_TYPEHASH(inner) => {
<REGISTER_IDENTITY_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::addressesProvider(inner) => {
<addressesProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::attestationValidator(inner) => {
<attestationValidatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::batchTaskManager(inner) => {
<batchTaskManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::challengeVerifier(inner) => {
<challengeVerifierCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::eip712Domain(inner) => {
<eip712DomainCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getLinkedDomains(inner) => {
<getLinkedDomainsCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::hasLinkedIdentity(inner) => {
<hasLinkedIdentityCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::identityData(inner) => {
<identityDataCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::initialize(inner) => {
<initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::linkIdentity(inner) => {
<linkIdentityCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::linkIdentityAsSigner(inner) => {
<linkIdentityAsSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::linkIdentityAsSignerAndUser(inner) => {
<linkIdentityAsSignerAndUserCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::linkIdentityAsUser(inner) => {
<linkIdentityAsUserCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::nonces(inner) => {
<noncesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::operatorRegistry(inner) => {
<operatorRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::policyClientLinks(inner) => {
<policyClientLinksCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::policyClientRegistry(inner) => {
<policyClientRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::registerIdentityData(inner) => {
<registerIdentityDataCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::regoVerifier(inner) => {
<regoVerifierCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::seedLinkCount(inner) => {
<seedLinkCountCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::serviceManager(inner) => {
<serviceManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::socketRegistry(inner) => {
<socketRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::stateCommitRegistry(inner) => {
<stateCommitRegistryCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::taskManager(inner) => {
<taskManagerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::unlinkIdentityAsSigner(inner) => {
<unlinkIdentityAsSignerCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::unlinkIdentityAsUser(inner) => {
<unlinkIdentityAsUserCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::viewBN254CertificateVerifier(inner) => {
<viewBN254CertificateVerifierCall 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::LINK_SIGNER_TYPEHASH(inner) => {
<LINK_SIGNER_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::LINK_USER_TYPEHASH(inner) => {
<LINK_USER_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::MAX_LINKS(inner) => {
<MAX_LINKSCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::REGISTER_IDENTITY_TYPEHASH(inner) => {
<REGISTER_IDENTITY_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::addressesProvider(inner) => {
<addressesProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::attestationValidator(inner) => {
<attestationValidatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::batchTaskManager(inner) => {
<batchTaskManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::challengeVerifier(inner) => {
<challengeVerifierCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::eip712Domain(inner) => {
<eip712DomainCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getLinkedDomains(inner) => {
<getLinkedDomainsCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::hasLinkedIdentity(inner) => {
<hasLinkedIdentityCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::identityData(inner) => {
<identityDataCall 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::linkIdentity(inner) => {
<linkIdentityCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::linkIdentityAsSigner(inner) => {
<linkIdentityAsSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::linkIdentityAsSignerAndUser(inner) => {
<linkIdentityAsSignerAndUserCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::linkIdentityAsUser(inner) => {
<linkIdentityAsUserCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::nonces(inner) => {
<noncesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
}
Self::operatorRegistry(inner) => {
<operatorRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::policyClientLinks(inner) => {
<policyClientLinksCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::policyClientRegistry(inner) => {
<policyClientRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::registerIdentityData(inner) => {
<registerIdentityDataCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::regoVerifier(inner) => {
<regoVerifierCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::seedLinkCount(inner) => {
<seedLinkCountCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::serviceManager(inner) => {
<serviceManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::socketRegistry(inner) => {
<socketRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::stateCommitRegistry(inner) => {
<stateCommitRegistryCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::taskManager(inner) => {
<taskManagerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::unlinkIdentityAsSigner(inner) => {
<unlinkIdentityAsSignerCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::unlinkIdentityAsUser(inner) => {
<unlinkIdentityAsUserCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::viewBN254CertificateVerifier(inner) => {
<viewBN254CertificateVerifierCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
}
}
}
#[derive(Clone)]
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Debug, PartialEq, Eq, Hash)]
pub enum IdentityRegistryErrors {
#[allow(missing_docs)]
InvalidAccountNonce(InvalidAccountNonce),
#[allow(missing_docs)]
InvalidClientRegistryAddress(InvalidClientRegistryAddress),
#[allow(missing_docs)]
InvalidIdentityDomain(InvalidIdentityDomain),
#[allow(missing_docs)]
InvalidIdentitySubmitter(InvalidIdentitySubmitter),
#[allow(missing_docs)]
InvalidOperatorRegistryAddress(InvalidOperatorRegistryAddress),
#[allow(missing_docs)]
InvalidSignature(InvalidSignature),
#[allow(missing_docs)]
InvalidUnlinker(InvalidUnlinker),
#[allow(missing_docs)]
LinkAlreadyExists(LinkAlreadyExists),
#[allow(missing_docs)]
NoEmptyDomainsArray(NoEmptyDomainsArray),
#[allow(missing_docs)]
PolicyClientNotRegistered(PolicyClientNotRegistered),
#[allow(missing_docs)]
SignatureExpired(SignatureExpired),
#[allow(missing_docs)]
TooManyDomainsAtOnce(TooManyDomainsAtOnce),
}
impl IdentityRegistryErrors {
pub const SELECTORS: &'static [[u8; 4usize]] = &[
[8u8, 25u8, 189u8, 205u8],
[78u8, 182u8, 109u8, 143u8],
[90u8, 12u8, 81u8, 55u8],
[90u8, 214u8, 195u8, 95u8],
[96u8, 6u8, 254u8, 48u8],
[117u8, 45u8, 136u8, 192u8],
[139u8, 170u8, 87u8, 159u8],
[184u8, 168u8, 140u8, 154u8],
[201u8, 13u8, 89u8, 187u8],
[223u8, 128u8, 165u8, 142u8],
[225u8, 130u8, 129u8, 178u8],
[236u8, 213u8, 66u8, 176u8],
];
pub const VARIANT_NAMES: &'static [&'static str] = &[
::core::stringify!(SignatureExpired),
::core::stringify!(InvalidUnlinker),
::core::stringify!(PolicyClientNotRegistered),
::core::stringify!(LinkAlreadyExists),
::core::stringify!(NoEmptyDomainsArray),
::core::stringify!(InvalidAccountNonce),
::core::stringify!(InvalidSignature),
::core::stringify!(InvalidOperatorRegistryAddress),
::core::stringify!(InvalidClientRegistryAddress),
::core::stringify!(InvalidIdentitySubmitter),
::core::stringify!(InvalidIdentityDomain),
::core::stringify!(TooManyDomainsAtOnce),
];
pub const SIGNATURES: &'static [&'static str] = &[
<SignatureExpired as alloy_sol_types::SolError>::SIGNATURE,
<InvalidUnlinker as alloy_sol_types::SolError>::SIGNATURE,
<PolicyClientNotRegistered as alloy_sol_types::SolError>::SIGNATURE,
<LinkAlreadyExists as alloy_sol_types::SolError>::SIGNATURE,
<NoEmptyDomainsArray as alloy_sol_types::SolError>::SIGNATURE,
<InvalidAccountNonce as alloy_sol_types::SolError>::SIGNATURE,
<InvalidSignature as alloy_sol_types::SolError>::SIGNATURE,
<InvalidOperatorRegistryAddress as alloy_sol_types::SolError>::SIGNATURE,
<InvalidClientRegistryAddress as alloy_sol_types::SolError>::SIGNATURE,
<InvalidIdentitySubmitter as alloy_sol_types::SolError>::SIGNATURE,
<InvalidIdentityDomain as alloy_sol_types::SolError>::SIGNATURE,
<TooManyDomainsAtOnce 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 IdentityRegistryErrors {
const NAME: &'static str = "IdentityRegistryErrors";
const MIN_DATA_LENGTH: usize = 0usize;
const COUNT: usize = 12usize;
#[inline]
fn selector(&self) -> [u8; 4] {
match self {
Self::InvalidAccountNonce(_) => {
<InvalidAccountNonce as alloy_sol_types::SolError>::SELECTOR
}
Self::InvalidClientRegistryAddress(_) => {
<InvalidClientRegistryAddress as alloy_sol_types::SolError>::SELECTOR
}
Self::InvalidIdentityDomain(_) => {
<InvalidIdentityDomain as alloy_sol_types::SolError>::SELECTOR
}
Self::InvalidIdentitySubmitter(_) => {
<InvalidIdentitySubmitter as alloy_sol_types::SolError>::SELECTOR
}
Self::InvalidOperatorRegistryAddress(_) => {
<InvalidOperatorRegistryAddress as alloy_sol_types::SolError>::SELECTOR
}
Self::InvalidSignature(_) => {
<InvalidSignature as alloy_sol_types::SolError>::SELECTOR
}
Self::InvalidUnlinker(_) => {
<InvalidUnlinker as alloy_sol_types::SolError>::SELECTOR
}
Self::LinkAlreadyExists(_) => {
<LinkAlreadyExists as alloy_sol_types::SolError>::SELECTOR
}
Self::NoEmptyDomainsArray(_) => {
<NoEmptyDomainsArray as alloy_sol_types::SolError>::SELECTOR
}
Self::PolicyClientNotRegistered(_) => {
<PolicyClientNotRegistered as alloy_sol_types::SolError>::SELECTOR
}
Self::SignatureExpired(_) => {
<SignatureExpired as alloy_sol_types::SolError>::SELECTOR
}
Self::TooManyDomainsAtOnce(_) => {
<TooManyDomainsAtOnce 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<IdentityRegistryErrors>] = &[
{
fn SignatureExpired(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<SignatureExpired as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IdentityRegistryErrors::SignatureExpired)
}
SignatureExpired
},
{
fn InvalidUnlinker(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidUnlinker as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IdentityRegistryErrors::InvalidUnlinker)
}
InvalidUnlinker
},
{
fn PolicyClientNotRegistered(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<PolicyClientNotRegistered as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IdentityRegistryErrors::PolicyClientNotRegistered)
}
PolicyClientNotRegistered
},
{
fn LinkAlreadyExists(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<LinkAlreadyExists as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IdentityRegistryErrors::LinkAlreadyExists)
}
LinkAlreadyExists
},
{
fn NoEmptyDomainsArray(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<NoEmptyDomainsArray as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IdentityRegistryErrors::NoEmptyDomainsArray)
}
NoEmptyDomainsArray
},
{
fn InvalidAccountNonce(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidAccountNonce as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IdentityRegistryErrors::InvalidAccountNonce)
}
InvalidAccountNonce
},
{
fn InvalidSignature(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidSignature as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IdentityRegistryErrors::InvalidSignature)
}
InvalidSignature
},
{
fn InvalidOperatorRegistryAddress(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidOperatorRegistryAddress as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IdentityRegistryErrors::InvalidOperatorRegistryAddress)
}
InvalidOperatorRegistryAddress
},
{
fn InvalidClientRegistryAddress(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidClientRegistryAddress as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IdentityRegistryErrors::InvalidClientRegistryAddress)
}
InvalidClientRegistryAddress
},
{
fn InvalidIdentitySubmitter(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidIdentitySubmitter as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IdentityRegistryErrors::InvalidIdentitySubmitter)
}
InvalidIdentitySubmitter
},
{
fn InvalidIdentityDomain(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidIdentityDomain as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IdentityRegistryErrors::InvalidIdentityDomain)
}
InvalidIdentityDomain
},
{
fn TooManyDomainsAtOnce(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<TooManyDomainsAtOnce as alloy_sol_types::SolError>::abi_decode_raw(
data,
)
.map(IdentityRegistryErrors::TooManyDomainsAtOnce)
}
TooManyDomainsAtOnce
},
];
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<IdentityRegistryErrors>] = &[
{
fn SignatureExpired(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<SignatureExpired as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryErrors::SignatureExpired)
}
SignatureExpired
},
{
fn InvalidUnlinker(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidUnlinker as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryErrors::InvalidUnlinker)
}
InvalidUnlinker
},
{
fn PolicyClientNotRegistered(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<PolicyClientNotRegistered as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryErrors::PolicyClientNotRegistered)
}
PolicyClientNotRegistered
},
{
fn LinkAlreadyExists(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<LinkAlreadyExists as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryErrors::LinkAlreadyExists)
}
LinkAlreadyExists
},
{
fn NoEmptyDomainsArray(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<NoEmptyDomainsArray as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryErrors::NoEmptyDomainsArray)
}
NoEmptyDomainsArray
},
{
fn InvalidAccountNonce(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidAccountNonce as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryErrors::InvalidAccountNonce)
}
InvalidAccountNonce
},
{
fn InvalidSignature(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidSignature as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryErrors::InvalidSignature)
}
InvalidSignature
},
{
fn InvalidOperatorRegistryAddress(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidOperatorRegistryAddress as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryErrors::InvalidOperatorRegistryAddress)
}
InvalidOperatorRegistryAddress
},
{
fn InvalidClientRegistryAddress(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidClientRegistryAddress as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryErrors::InvalidClientRegistryAddress)
}
InvalidClientRegistryAddress
},
{
fn InvalidIdentitySubmitter(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidIdentitySubmitter as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryErrors::InvalidIdentitySubmitter)
}
InvalidIdentitySubmitter
},
{
fn InvalidIdentityDomain(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<InvalidIdentityDomain as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryErrors::InvalidIdentityDomain)
}
InvalidIdentityDomain
},
{
fn TooManyDomainsAtOnce(
data: &[u8],
) -> alloy_sol_types::Result<IdentityRegistryErrors> {
<TooManyDomainsAtOnce as alloy_sol_types::SolError>::abi_decode_raw_validate(
data,
)
.map(IdentityRegistryErrors::TooManyDomainsAtOnce)
}
TooManyDomainsAtOnce
},
];
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::InvalidAccountNonce(inner) => {
<InvalidAccountNonce as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::InvalidClientRegistryAddress(inner) => {
<InvalidClientRegistryAddress as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::InvalidIdentityDomain(inner) => {
<InvalidIdentityDomain as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::InvalidIdentitySubmitter(inner) => {
<InvalidIdentitySubmitter as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::InvalidOperatorRegistryAddress(inner) => {
<InvalidOperatorRegistryAddress as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::InvalidSignature(inner) => {
<InvalidSignature as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::InvalidUnlinker(inner) => {
<InvalidUnlinker as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::LinkAlreadyExists(inner) => {
<LinkAlreadyExists as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::NoEmptyDomainsArray(inner) => {
<NoEmptyDomainsArray as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::PolicyClientNotRegistered(inner) => {
<PolicyClientNotRegistered as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::SignatureExpired(inner) => {
<SignatureExpired as alloy_sol_types::SolError>::abi_encoded_size(
inner,
)
}
Self::TooManyDomainsAtOnce(inner) => {
<TooManyDomainsAtOnce 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::InvalidAccountNonce(inner) => {
<InvalidAccountNonce as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::InvalidClientRegistryAddress(inner) => {
<InvalidClientRegistryAddress as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::InvalidIdentityDomain(inner) => {
<InvalidIdentityDomain as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::InvalidIdentitySubmitter(inner) => {
<InvalidIdentitySubmitter as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::InvalidOperatorRegistryAddress(inner) => {
<InvalidOperatorRegistryAddress as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::InvalidSignature(inner) => {
<InvalidSignature as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::InvalidUnlinker(inner) => {
<InvalidUnlinker as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::LinkAlreadyExists(inner) => {
<LinkAlreadyExists as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::NoEmptyDomainsArray(inner) => {
<NoEmptyDomainsArray as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::PolicyClientNotRegistered(inner) => {
<PolicyClientNotRegistered as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::SignatureExpired(inner) => {
<SignatureExpired as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
Self::TooManyDomainsAtOnce(inner) => {
<TooManyDomainsAtOnce as alloy_sol_types::SolError>::abi_encode_raw(
inner,
out,
)
}
}
}
}
#[derive(Clone)]
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Debug, PartialEq, Eq, Hash)]
pub enum IdentityRegistryEvents {
#[allow(missing_docs)]
EIP712DomainChanged(EIP712DomainChanged),
#[allow(missing_docs)]
IdentityBound(IdentityBound),
#[allow(missing_docs)]
IdentityLinked(IdentityLinked),
#[allow(missing_docs)]
IdentityUnlinked(IdentityUnlinked),
#[allow(missing_docs)]
Initialized(Initialized),
}
impl IdentityRegistryEvents {
pub const SELECTORS: &'static [[u8; 32usize]] = &[
[
10u8, 99u8, 135u8, 201u8, 234u8, 54u8, 40u8, 184u8, 138u8, 99u8, 59u8,
180u8, 243u8, 177u8, 81u8, 119u8, 15u8, 112u8, 8u8, 81u8, 23u8, 161u8,
95u8, 155u8, 243u8, 120u8, 124u8, 218u8, 83u8, 241u8, 61u8, 49u8,
],
[
98u8, 248u8, 54u8, 248u8, 80u8, 173u8, 148u8, 42u8, 230u8, 19u8, 12u8,
29u8, 159u8, 92u8, 166u8, 92u8, 125u8, 128u8, 104u8, 237u8, 198u8, 15u8,
246u8, 229u8, 7u8, 106u8, 132u8, 185u8, 68u8, 7u8, 55u8, 46u8,
],
[
103u8, 16u8, 119u8, 247u8, 120u8, 69u8, 36u8, 150u8, 162u8, 177u8, 40u8,
238u8, 177u8, 200u8, 148u8, 52u8, 54u8, 140u8, 132u8, 179u8, 181u8, 98u8,
46u8, 254u8, 223u8, 71u8, 177u8, 187u8, 174u8, 116u8, 192u8, 190u8,
],
[
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,
],
[
198u8, 243u8, 159u8, 136u8, 13u8, 74u8, 170u8, 29u8, 190u8, 199u8, 97u8,
143u8, 92u8, 171u8, 117u8, 47u8, 27u8, 246u8, 251u8, 138u8, 19u8, 87u8,
234u8, 237u8, 97u8, 234u8, 98u8, 227u8, 135u8, 123u8, 158u8, 100u8,
],
];
pub const VARIANT_NAMES: &'static [&'static str] = &[
::core::stringify!(EIP712DomainChanged),
::core::stringify!(IdentityUnlinked),
::core::stringify!(IdentityBound),
::core::stringify!(Initialized),
::core::stringify!(IdentityLinked),
];
pub const SIGNATURES: &'static [&'static str] = &[
<EIP712DomainChanged as alloy_sol_types::SolEvent>::SIGNATURE,
<IdentityUnlinked as alloy_sol_types::SolEvent>::SIGNATURE,
<IdentityBound as alloy_sol_types::SolEvent>::SIGNATURE,
<Initialized as alloy_sol_types::SolEvent>::SIGNATURE,
<IdentityLinked 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 IdentityRegistryEvents {
const NAME: &'static str = "IdentityRegistryEvents";
const COUNT: usize = 5usize;
fn decode_raw_log(
topics: &[alloy_sol_types::Word],
data: &[u8],
) -> alloy_sol_types::Result<Self> {
match topics.first().copied() {
Some(
<EIP712DomainChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<EIP712DomainChanged as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::EIP712DomainChanged)
}
Some(<IdentityBound as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<IdentityBound as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::IdentityBound)
}
Some(<IdentityLinked as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<IdentityLinked as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::IdentityLinked)
}
Some(<IdentityUnlinked as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<IdentityUnlinked as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::IdentityUnlinked)
}
Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
)
.map(Self::Initialized)
}
_ => {
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 IdentityRegistryEvents {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
match self {
Self::EIP712DomainChanged(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::IdentityBound(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::IdentityLinked(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::IdentityUnlinked(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::Initialized(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
}
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
match self {
Self::EIP712DomainChanged(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::IdentityBound(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::IdentityLinked(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::IdentityUnlinked(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::Initialized(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,
) -> IdentityRegistryInstance<P, N> {
IdentityRegistryInstance::<P, N>::new(address, __provider)
}
#[inline]
pub fn deploy<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
>(
__provider: P,
_provider: alloy::sol_types::private::Address,
) -> impl ::core::future::Future<
Output = alloy_contract::Result<IdentityRegistryInstance<P, N>>,
> {
IdentityRegistryInstance::<P, N>::deploy(__provider, _provider)
}
#[inline]
pub fn deploy_builder<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
>(
__provider: P,
_provider: alloy::sol_types::private::Address,
) -> alloy_contract::RawCallBuilder<P, N> {
IdentityRegistryInstance::<P, N>::deploy_builder(__provider, _provider)
}
#[derive(Clone)]
pub struct IdentityRegistryInstance<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 IdentityRegistryInstance<P, N> {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
f.debug_tuple("IdentityRegistryInstance").field(&self.address).finish()
}
}
impl<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
> IdentityRegistryInstance<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,
_provider: alloy::sol_types::private::Address,
) -> alloy_contract::Result<IdentityRegistryInstance<P, N>> {
let call_builder = Self::deploy_builder(__provider, _provider);
let contract_address = call_builder.deploy().await?;
Ok(Self::new(contract_address, call_builder.provider))
}
#[inline]
pub fn deploy_builder(
__provider: P,
_provider: alloy::sol_types::private::Address,
) -> alloy_contract::RawCallBuilder<P, N> {
alloy_contract::RawCallBuilder::new_raw_deploy(
__provider,
[
&BYTECODE[..],
&alloy_sol_types::SolConstructor::abi_encode(
&constructorCall { _provider },
)[..],
]
.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> IdentityRegistryInstance<&P, N> {
#[inline]
pub fn with_cloned_provider(self) -> IdentityRegistryInstance<P, N> {
IdentityRegistryInstance {
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,
> IdentityRegistryInstance<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 LINK_SIGNER_TYPEHASH(
&self,
) -> alloy_contract::SolCallBuilder<&P, LINK_SIGNER_TYPEHASHCall, N> {
self.call_builder(&LINK_SIGNER_TYPEHASHCall)
}
pub fn LINK_USER_TYPEHASH(
&self,
) -> alloy_contract::SolCallBuilder<&P, LINK_USER_TYPEHASHCall, N> {
self.call_builder(&LINK_USER_TYPEHASHCall)
}
pub fn MAX_LINKS(&self) -> alloy_contract::SolCallBuilder<&P, MAX_LINKSCall, N> {
self.call_builder(&MAX_LINKSCall)
}
pub fn REGISTER_IDENTITY_TYPEHASH(
&self,
) -> alloy_contract::SolCallBuilder<&P, REGISTER_IDENTITY_TYPEHASHCall, N> {
self.call_builder(®ISTER_IDENTITY_TYPEHASHCall)
}
pub fn addressesProvider(
&self,
) -> alloy_contract::SolCallBuilder<&P, addressesProviderCall, N> {
self.call_builder(&addressesProviderCall)
}
pub fn attestationValidator(
&self,
) -> alloy_contract::SolCallBuilder<&P, attestationValidatorCall, N> {
self.call_builder(&attestationValidatorCall)
}
pub fn batchTaskManager(
&self,
) -> alloy_contract::SolCallBuilder<&P, batchTaskManagerCall, N> {
self.call_builder(&batchTaskManagerCall)
}
pub fn challengeVerifier(
&self,
) -> alloy_contract::SolCallBuilder<&P, challengeVerifierCall, N> {
self.call_builder(&challengeVerifierCall)
}
pub fn eip712Domain(
&self,
) -> alloy_contract::SolCallBuilder<&P, eip712DomainCall, N> {
self.call_builder(&eip712DomainCall)
}
pub fn getLinkedDomains(
&self,
policyClient: alloy::sol_types::private::Address,
clientUser: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, getLinkedDomainsCall, N> {
self.call_builder(
&getLinkedDomainsCall {
policyClient,
clientUser,
},
)
}
pub fn hasLinkedIdentity(
&self,
policyClient: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, hasLinkedIdentityCall, N> {
self.call_builder(
&hasLinkedIdentityCall {
policyClient,
},
)
}
pub fn identityData(
&self,
_0: alloy::sol_types::private::Address,
_1: alloy::sol_types::private::FixedBytes<32>,
) -> alloy_contract::SolCallBuilder<&P, identityDataCall, N> {
self.call_builder(&identityDataCall { _0, _1 })
}
pub fn initialize(
&self,
) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> {
self.call_builder(&initializeCall)
}
pub fn linkIdentity(
&self,
_identityOwner: alloy::sol_types::private::Address,
_clientUser: alloy::sol_types::private::Address,
_policyClient: alloy::sol_types::private::Address,
_identityDomains: alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
_identityOwnerSignature: alloy::sol_types::private::Bytes,
_identityOwnerNonce: alloy::sol_types::private::primitives::aliases::U256,
_identityOwnerDeadline: alloy::sol_types::private::primitives::aliases::U256,
_clientUserSignature: alloy::sol_types::private::Bytes,
_clientUserNonce: alloy::sol_types::private::primitives::aliases::U256,
_clientUserDeadline: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, linkIdentityCall, N> {
self.call_builder(
&linkIdentityCall {
_identityOwner,
_clientUser,
_policyClient,
_identityDomains,
_identityOwnerSignature,
_identityOwnerNonce,
_identityOwnerDeadline,
_clientUserSignature,
_clientUserNonce,
_clientUserDeadline,
},
)
}
pub fn linkIdentityAsSigner(
&self,
_policyClient: alloy::sol_types::private::Address,
_identityDomains: alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
_clientUser: alloy::sol_types::private::Address,
_signature: alloy::sol_types::private::Bytes,
_nonce: alloy::sol_types::private::primitives::aliases::U256,
_deadline: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, linkIdentityAsSignerCall, N> {
self.call_builder(
&linkIdentityAsSignerCall {
_policyClient,
_identityDomains,
_clientUser,
_signature,
_nonce,
_deadline,
},
)
}
pub fn linkIdentityAsSignerAndUser(
&self,
_policyClient: alloy::sol_types::private::Address,
_identityDomains: alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
) -> alloy_contract::SolCallBuilder<&P, linkIdentityAsSignerAndUserCall, N> {
self.call_builder(
&linkIdentityAsSignerAndUserCall {
_policyClient,
_identityDomains,
},
)
}
pub fn linkIdentityAsUser(
&self,
_identityOwner: alloy::sol_types::private::Address,
_policyClient: alloy::sol_types::private::Address,
_identityDomains: alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
_signature: alloy::sol_types::private::Bytes,
_nonce: alloy::sol_types::private::primitives::aliases::U256,
_deadline: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, linkIdentityAsUserCall, N> {
self.call_builder(
&linkIdentityAsUserCall {
_identityOwner,
_policyClient,
_identityDomains,
_signature,
_nonce,
_deadline,
},
)
}
pub fn nonces(
&self,
owner: alloy::sol_types::private::Address,
) -> alloy_contract::SolCallBuilder<&P, noncesCall, N> {
self.call_builder(&noncesCall { owner })
}
pub fn operatorRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, operatorRegistryCall, N> {
self.call_builder(&operatorRegistryCall)
}
pub fn policyClientLinks(
&self,
_0: alloy::sol_types::private::Address,
_1: alloy::sol_types::private::Address,
_2: alloy::sol_types::private::FixedBytes<32>,
) -> alloy_contract::SolCallBuilder<&P, policyClientLinksCall, N> {
self.call_builder(
&policyClientLinksCall {
_0,
_1,
_2,
},
)
}
pub fn policyClientRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, policyClientRegistryCall, N> {
self.call_builder(&policyClientRegistryCall)
}
pub fn registerIdentityData(
&self,
_identityDomain: alloy::sol_types::private::FixedBytes<32>,
_dataRefId: alloy::sol_types::private::String,
_gatewaySignature: alloy::sol_types::private::Bytes,
_deadline: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, registerIdentityDataCall, N> {
self.call_builder(
®isterIdentityDataCall {
_identityDomain,
_dataRefId,
_gatewaySignature,
_deadline,
},
)
}
pub fn regoVerifier(
&self,
) -> alloy_contract::SolCallBuilder<&P, regoVerifierCall, N> {
self.call_builder(®oVerifierCall)
}
pub fn seedLinkCount(
&self,
policyClient: alloy::sol_types::private::Address,
count: alloy::sol_types::private::primitives::aliases::U256,
) -> alloy_contract::SolCallBuilder<&P, seedLinkCountCall, N> {
self.call_builder(
&seedLinkCountCall {
policyClient,
count,
},
)
}
pub fn serviceManager(
&self,
) -> alloy_contract::SolCallBuilder<&P, serviceManagerCall, N> {
self.call_builder(&serviceManagerCall)
}
pub fn socketRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, socketRegistryCall, N> {
self.call_builder(&socketRegistryCall)
}
pub fn stateCommitRegistry(
&self,
) -> alloy_contract::SolCallBuilder<&P, stateCommitRegistryCall, N> {
self.call_builder(&stateCommitRegistryCall)
}
pub fn taskManager(
&self,
) -> alloy_contract::SolCallBuilder<&P, taskManagerCall, N> {
self.call_builder(&taskManagerCall)
}
pub fn unlinkIdentityAsSigner(
&self,
_clientUser: alloy::sol_types::private::Address,
_policyClient: alloy::sol_types::private::Address,
_identityDomains: alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
) -> alloy_contract::SolCallBuilder<&P, unlinkIdentityAsSignerCall, N> {
self.call_builder(
&unlinkIdentityAsSignerCall {
_clientUser,
_policyClient,
_identityDomains,
},
)
}
pub fn unlinkIdentityAsUser(
&self,
_policyClient: alloy::sol_types::private::Address,
_identityDomains: alloy::sol_types::private::Vec<
alloy::sol_types::private::FixedBytes<32>,
>,
) -> alloy_contract::SolCallBuilder<&P, unlinkIdentityAsUserCall, N> {
self.call_builder(
&unlinkIdentityAsUserCall {
_policyClient,
_identityDomains,
},
)
}
pub fn viewBN254CertificateVerifier(
&self,
) -> alloy_contract::SolCallBuilder<&P, viewBN254CertificateVerifierCall, N> {
self.call_builder(&viewBN254CertificateVerifierCall)
}
}
impl<
P: alloy_contract::private::Provider<N>,
N: alloy_contract::private::Network,
> IdentityRegistryInstance<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 EIP712DomainChanged_filter(
&self,
) -> alloy_contract::Event<&P, EIP712DomainChanged, N> {
self.event_filter::<EIP712DomainChanged>()
}
pub fn IdentityBound_filter(
&self,
) -> alloy_contract::Event<&P, IdentityBound, N> {
self.event_filter::<IdentityBound>()
}
pub fn IdentityLinked_filter(
&self,
) -> alloy_contract::Event<&P, IdentityLinked, N> {
self.event_filter::<IdentityLinked>()
}
pub fn IdentityUnlinked_filter(
&self,
) -> alloy_contract::Event<&P, IdentityUnlinked, N> {
self.event_filter::<IdentityUnlinked>()
}
pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
self.event_filter::<Initialized>()
}
}
}