#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style,
clippy::empty_structs_with_brackets
)]
pub mod IBucketFacade {
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"",
);
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct KeyValue {
#[allow(missing_docs)]
pub key: ::alloy_sol_types::private::String,
#[allow(missing_docs)]
pub value: ::alloy_sol_types::private::String,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::String,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
::alloy_sol_types::private::String,
::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<KeyValue> for UnderlyingRustTuple<'_> {
fn from(value: KeyValue) -> Self {
(value.key, value.value)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for KeyValue {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
key: tuple.0,
value: tuple.1,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolValue for KeyValue {
type SolType = Self;
}
#[automatically_derived]
impl alloy_sol_types::private::SolTypeValue<Self> for KeyValue {
#[inline]
fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
(
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.key,
),
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.value,
),
)
}
#[inline]
fn stv_abi_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
}
#[inline]
fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
<Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
}
#[inline]
fn stv_abi_encode_packed_to(
&self,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
}
#[inline]
fn stv_abi_packed_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolType for KeyValue {
type RustType = Self;
type Token<'a> = <UnderlyingSolTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::ENCODED_SIZE;
const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
#[inline]
fn valid_token(token: &Self::Token<'_>) -> bool {
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
}
#[inline]
fn detokenize(token: Self::Token<'_>) -> Self::RustType {
let tuple = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::detokenize(token);
<Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolStruct for KeyValue {
const NAME: &'static str = "KeyValue";
#[inline]
fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
alloy_sol_types::private::Cow::Borrowed(
"KeyValue(string key,string value)",
)
}
#[inline]
fn eip712_components() -> alloy_sol_types::private::Vec<
alloy_sol_types::private::Cow<'static, str>,
> {
alloy_sol_types::private::Vec::new()
}
#[inline]
fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
<Self as alloy_sol_types::SolStruct>::eip712_root_type()
}
#[inline]
fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
[
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
&self.key,
)
.0,
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
&self.value,
)
.0,
]
.concat()
}
}
#[automatically_derived]
impl alloy_sol_types::EventTopic for KeyValue {
#[inline]
fn topic_preimage_length(rust: &Self::RustType) -> usize {
0usize
+ <::alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.key,
)
+ <::alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.value,
)
}
#[inline]
fn encode_topic_preimage(
rust: &Self::RustType,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
out.reserve(
<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
);
<::alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.key,
out,
);
<::alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.value,
out,
);
}
#[inline]
fn encode_topic(
rust: &Self::RustType,
) -> alloy_sol_types::abi::token::WordToken {
let mut out = alloy_sol_types::private::Vec::new();
<Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
rust,
&mut out,
);
alloy_sol_types::abi::token::WordToken(
alloy_sol_types::private::keccak256(out),
)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct Object {
#[allow(missing_docs)]
pub key: ::alloy_sol_types::private::String,
#[allow(missing_docs)]
pub state: <ObjectState as ::alloy_sol_types::SolType>::RustType,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (::alloy_sol_types::sol_data::String, ObjectState);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
::alloy_sol_types::private::String,
<ObjectState as ::alloy_sol_types::SolType>::RustType,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<Object> for UnderlyingRustTuple<'_> {
fn from(value: Object) -> Self {
(value.key, value.state)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for Object {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
key: tuple.0,
state: tuple.1,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolValue for Object {
type SolType = Self;
}
#[automatically_derived]
impl alloy_sol_types::private::SolTypeValue<Self> for Object {
#[inline]
fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
(
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.key,
),
<ObjectState as alloy_sol_types::SolType>::tokenize(&self.state),
)
}
#[inline]
fn stv_abi_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
}
#[inline]
fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
<Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
}
#[inline]
fn stv_abi_encode_packed_to(
&self,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
}
#[inline]
fn stv_abi_packed_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolType for Object {
type RustType = Self;
type Token<'a> = <UnderlyingSolTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::ENCODED_SIZE;
const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
#[inline]
fn valid_token(token: &Self::Token<'_>) -> bool {
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
}
#[inline]
fn detokenize(token: Self::Token<'_>) -> Self::RustType {
let tuple = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::detokenize(token);
<Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolStruct for Object {
const NAME: &'static str = "Object";
#[inline]
fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
alloy_sol_types::private::Cow::Borrowed(
"Object(string key,ObjectState state)",
)
}
#[inline]
fn eip712_components() -> alloy_sol_types::private::Vec<
alloy_sol_types::private::Cow<'static, str>,
> {
let mut components = alloy_sol_types::private::Vec::with_capacity(1);
components
.push(
<ObjectState as alloy_sol_types::SolStruct>::eip712_root_type(),
);
components
.extend(
<ObjectState as alloy_sol_types::SolStruct>::eip712_components(),
);
components
}
#[inline]
fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
[
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
&self.key,
)
.0,
<ObjectState as alloy_sol_types::SolType>::eip712_data_word(
&self.state,
)
.0,
]
.concat()
}
}
#[automatically_derived]
impl alloy_sol_types::EventTopic for Object {
#[inline]
fn topic_preimage_length(rust: &Self::RustType) -> usize {
0usize
+ <::alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.key,
)
+ <ObjectState as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.state,
)
}
#[inline]
fn encode_topic_preimage(
rust: &Self::RustType,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
out.reserve(
<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
);
<::alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.key,
out,
);
<ObjectState as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.state,
out,
);
}
#[inline]
fn encode_topic(
rust: &Self::RustType,
) -> alloy_sol_types::abi::token::WordToken {
let mut out = alloy_sol_types::private::Vec::new();
<Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
rust,
&mut out,
);
alloy_sol_types::abi::token::WordToken(
alloy_sol_types::private::keccak256(out),
)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct ObjectState {
#[allow(missing_docs)]
pub blobHash: ::alloy_sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub size: u64,
#[allow(missing_docs)]
pub expiry: u64,
#[allow(missing_docs)]
pub metadata: ::alloy_sol_types::private::Vec<
<KeyValue as ::alloy_sol_types::SolType>::RustType,
>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::Uint<64>,
::alloy_sol_types::sol_data::Uint<64>,
::alloy_sol_types::sol_data::Array<KeyValue>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
::alloy_sol_types::private::FixedBytes<32>,
u64,
u64,
::alloy_sol_types::private::Vec<
<KeyValue as ::alloy_sol_types::SolType>::RustType,
>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<ObjectState> for UnderlyingRustTuple<'_> {
fn from(value: ObjectState) -> Self {
(value.blobHash, value.size, value.expiry, value.metadata)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ObjectState {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
blobHash: tuple.0,
size: tuple.1,
expiry: tuple.2,
metadata: tuple.3,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolValue for ObjectState {
type SolType = Self;
}
#[automatically_derived]
impl alloy_sol_types::private::SolTypeValue<Self> for ObjectState {
#[inline]
fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
(
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.blobHash),
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.size),
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.expiry),
<::alloy_sol_types::sol_data::Array<
KeyValue,
> as alloy_sol_types::SolType>::tokenize(&self.metadata),
)
}
#[inline]
fn stv_abi_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
}
#[inline]
fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
<Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
}
#[inline]
fn stv_abi_encode_packed_to(
&self,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
}
#[inline]
fn stv_abi_packed_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolType for ObjectState {
type RustType = Self;
type Token<'a> = <UnderlyingSolTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::ENCODED_SIZE;
const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
#[inline]
fn valid_token(token: &Self::Token<'_>) -> bool {
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
}
#[inline]
fn detokenize(token: Self::Token<'_>) -> Self::RustType {
let tuple = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::detokenize(token);
<Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolStruct for ObjectState {
const NAME: &'static str = "ObjectState";
#[inline]
fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
alloy_sol_types::private::Cow::Borrowed(
"ObjectState(bytes32 blobHash,uint64 size,uint64 expiry,KeyValue[] metadata)",
)
}
#[inline]
fn eip712_components() -> alloy_sol_types::private::Vec<
alloy_sol_types::private::Cow<'static, str>,
> {
let mut components = alloy_sol_types::private::Vec::with_capacity(1);
components
.push(<KeyValue as alloy_sol_types::SolStruct>::eip712_root_type());
components
.extend(
<KeyValue as alloy_sol_types::SolStruct>::eip712_components(),
);
components
}
#[inline]
fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
[
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::eip712_data_word(&self.blobHash)
.0,
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::eip712_data_word(&self.size)
.0,
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
.0,
<::alloy_sol_types::sol_data::Array<
KeyValue,
> as alloy_sol_types::SolType>::eip712_data_word(&self.metadata)
.0,
]
.concat()
}
}
#[automatically_derived]
impl alloy_sol_types::EventTopic for ObjectState {
#[inline]
fn topic_preimage_length(rust: &Self::RustType) -> usize {
0usize
+ <::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.blobHash,
)
+ <::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.size)
+ <::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.expiry,
)
+ <::alloy_sol_types::sol_data::Array<
KeyValue,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.metadata,
)
}
#[inline]
fn encode_topic_preimage(
rust: &Self::RustType,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
out.reserve(
<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
);
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.blobHash,
out,
);
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.size,
out,
);
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.expiry,
out,
);
<::alloy_sol_types::sol_data::Array<
KeyValue,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.metadata,
out,
);
}
#[inline]
fn encode_topic(
rust: &Self::RustType,
) -> alloy_sol_types::abi::token::WordToken {
let mut out = alloy_sol_types::private::Vec::new();
<Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
rust,
&mut out,
);
alloy_sol_types::abi::token::WordToken(
alloy_sol_types::private::keccak256(out),
)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct ObjectValue {
#[allow(missing_docs)]
pub blobHash: ::alloy_sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub recoveryHash: ::alloy_sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub size: u64,
#[allow(missing_docs)]
pub expiry: u64,
#[allow(missing_docs)]
pub metadata: ::alloy_sol_types::private::Vec<
<KeyValue as ::alloy_sol_types::SolType>::RustType,
>,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::Uint<64>,
::alloy_sol_types::sol_data::Uint<64>,
::alloy_sol_types::sol_data::Array<KeyValue>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
::alloy_sol_types::private::FixedBytes<32>,
::alloy_sol_types::private::FixedBytes<32>,
u64,
u64,
::alloy_sol_types::private::Vec<
<KeyValue as ::alloy_sol_types::SolType>::RustType,
>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<ObjectValue> for UnderlyingRustTuple<'_> {
fn from(value: ObjectValue) -> Self {
(
value.blobHash,
value.recoveryHash,
value.size,
value.expiry,
value.metadata,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for ObjectValue {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
blobHash: tuple.0,
recoveryHash: tuple.1,
size: tuple.2,
expiry: tuple.3,
metadata: tuple.4,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolValue for ObjectValue {
type SolType = Self;
}
#[automatically_derived]
impl alloy_sol_types::private::SolTypeValue<Self> for ObjectValue {
#[inline]
fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
(
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.blobHash),
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.recoveryHash),
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.size),
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.expiry),
<::alloy_sol_types::sol_data::Array<
KeyValue,
> as alloy_sol_types::SolType>::tokenize(&self.metadata),
)
}
#[inline]
fn stv_abi_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
}
#[inline]
fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
<Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
}
#[inline]
fn stv_abi_encode_packed_to(
&self,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
}
#[inline]
fn stv_abi_packed_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolType for ObjectValue {
type RustType = Self;
type Token<'a> = <UnderlyingSolTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::ENCODED_SIZE;
const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
#[inline]
fn valid_token(token: &Self::Token<'_>) -> bool {
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
}
#[inline]
fn detokenize(token: Self::Token<'_>) -> Self::RustType {
let tuple = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::detokenize(token);
<Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolStruct for ObjectValue {
const NAME: &'static str = "ObjectValue";
#[inline]
fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
alloy_sol_types::private::Cow::Borrowed(
"ObjectValue(bytes32 blobHash,bytes32 recoveryHash,uint64 size,uint64 expiry,KeyValue[] metadata)",
)
}
#[inline]
fn eip712_components() -> alloy_sol_types::private::Vec<
alloy_sol_types::private::Cow<'static, str>,
> {
let mut components = alloy_sol_types::private::Vec::with_capacity(1);
components
.push(<KeyValue as alloy_sol_types::SolStruct>::eip712_root_type());
components
.extend(
<KeyValue as alloy_sol_types::SolStruct>::eip712_components(),
);
components
}
#[inline]
fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
[
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::eip712_data_word(&self.blobHash)
.0,
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::eip712_data_word(&self.recoveryHash)
.0,
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::eip712_data_word(&self.size)
.0,
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
.0,
<::alloy_sol_types::sol_data::Array<
KeyValue,
> as alloy_sol_types::SolType>::eip712_data_word(&self.metadata)
.0,
]
.concat()
}
}
#[automatically_derived]
impl alloy_sol_types::EventTopic for ObjectValue {
#[inline]
fn topic_preimage_length(rust: &Self::RustType) -> usize {
0usize
+ <::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.blobHash,
)
+ <::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.recoveryHash,
)
+ <::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.size)
+ <::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.expiry,
)
+ <::alloy_sol_types::sol_data::Array<
KeyValue,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.metadata,
)
}
#[inline]
fn encode_topic_preimage(
rust: &Self::RustType,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
out.reserve(
<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
);
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.blobHash,
out,
);
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.recoveryHash,
out,
);
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.size,
out,
);
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.expiry,
out,
);
<::alloy_sol_types::sol_data::Array<
KeyValue,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.metadata,
out,
);
}
#[inline]
fn encode_topic(
rust: &Self::RustType,
) -> alloy_sol_types::abi::token::WordToken {
let mut out = alloy_sol_types::private::Vec::new();
<Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
rust,
&mut out,
);
alloy_sol_types::abi::token::WordToken(
alloy_sol_types::private::keccak256(out),
)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct Query {
#[allow(missing_docs)]
pub objects: ::alloy_sol_types::private::Vec<
<Object as ::alloy_sol_types::SolType>::RustType,
>,
#[allow(missing_docs)]
pub commonPrefixes: ::alloy_sol_types::private::Vec<
::alloy_sol_types::private::String,
>,
#[allow(missing_docs)]
pub nextKey: ::alloy_sol_types::private::String,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
::alloy_sol_types::sol_data::Array<Object>,
::alloy_sol_types::sol_data::Array<::alloy_sol_types::sol_data::String>,
::alloy_sol_types::sol_data::String,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
::alloy_sol_types::private::Vec<
<Object as ::alloy_sol_types::SolType>::RustType,
>,
::alloy_sol_types::private::Vec<::alloy_sol_types::private::String>,
::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<Query> for UnderlyingRustTuple<'_> {
fn from(value: Query) -> Self {
(value.objects, value.commonPrefixes, value.nextKey)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for Query {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
objects: tuple.0,
commonPrefixes: tuple.1,
nextKey: tuple.2,
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolValue for Query {
type SolType = Self;
}
#[automatically_derived]
impl alloy_sol_types::private::SolTypeValue<Self> for Query {
#[inline]
fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
(
<::alloy_sol_types::sol_data::Array<
Object,
> as alloy_sol_types::SolType>::tokenize(&self.objects),
<::alloy_sol_types::sol_data::Array<
::alloy_sol_types::sol_data::String,
> as alloy_sol_types::SolType>::tokenize(&self.commonPrefixes),
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.nextKey,
),
)
}
#[inline]
fn stv_abi_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
}
#[inline]
fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
<Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
}
#[inline]
fn stv_abi_encode_packed_to(
&self,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
}
#[inline]
fn stv_abi_packed_encoded_size(&self) -> usize {
if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
return size;
}
let tuple = <UnderlyingRustTuple<
'_,
> as ::core::convert::From<Self>>::from(self.clone());
<UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolType for Query {
type RustType = Self;
type Token<'a> = <UnderlyingSolTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::ENCODED_SIZE;
const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
#[inline]
fn valid_token(token: &Self::Token<'_>) -> bool {
<UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
}
#[inline]
fn detokenize(token: Self::Token<'_>) -> Self::RustType {
let tuple = <UnderlyingSolTuple<
'_,
> as alloy_sol_types::SolType>::detokenize(token);
<Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
}
}
#[automatically_derived]
impl alloy_sol_types::SolStruct for Query {
const NAME: &'static str = "Query";
#[inline]
fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
alloy_sol_types::private::Cow::Borrowed(
"Query(Object[] objects,string[] commonPrefixes,string nextKey)",
)
}
#[inline]
fn eip712_components() -> alloy_sol_types::private::Vec<
alloy_sol_types::private::Cow<'static, str>,
> {
let mut components = alloy_sol_types::private::Vec::with_capacity(1);
components
.push(<Object as alloy_sol_types::SolStruct>::eip712_root_type());
components
.extend(<Object as alloy_sol_types::SolStruct>::eip712_components());
components
}
#[inline]
fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
[
<::alloy_sol_types::sol_data::Array<
Object,
> as alloy_sol_types::SolType>::eip712_data_word(&self.objects)
.0,
<::alloy_sol_types::sol_data::Array<
::alloy_sol_types::sol_data::String,
> as alloy_sol_types::SolType>::eip712_data_word(
&self.commonPrefixes,
)
.0,
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
&self.nextKey,
)
.0,
]
.concat()
}
}
#[automatically_derived]
impl alloy_sol_types::EventTopic for Query {
#[inline]
fn topic_preimage_length(rust: &Self::RustType) -> usize {
0usize
+ <::alloy_sol_types::sol_data::Array<
Object,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.objects,
)
+ <::alloy_sol_types::sol_data::Array<
::alloy_sol_types::sol_data::String,
> as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.commonPrefixes,
)
+ <::alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
&rust.nextKey,
)
}
#[inline]
fn encode_topic_preimage(
rust: &Self::RustType,
out: &mut alloy_sol_types::private::Vec<u8>,
) {
out.reserve(
<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
);
<::alloy_sol_types::sol_data::Array<
Object,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.objects,
out,
);
<::alloy_sol_types::sol_data::Array<
::alloy_sol_types::sol_data::String,
> as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.commonPrefixes,
out,
);
<::alloy_sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
&rust.nextKey,
out,
);
}
#[inline]
fn encode_topic(
rust: &Self::RustType,
) -> alloy_sol_types::abi::token::WordToken {
let mut out = alloy_sol_types::private::Vec::new();
<Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
rust,
&mut out,
);
alloy_sol_types::abi::token::WordToken(
alloy_sol_types::private::keccak256(out),
)
}
}
};
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
#[derive(Clone)]
pub struct ObjectAdded {
#[allow(missing_docs)]
pub key: ::alloy_sol_types::private::Bytes,
#[allow(missing_docs)]
pub blobHash: ::alloy_sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub metadata: ::alloy_sol_types::private::Bytes,
}
#[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 ObjectAdded {
type DataTuple<'a> = (
::alloy_sol_types::sol_data::Bytes,
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::Bytes,
);
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 = "ObjectAdded(bytes,bytes32,bytes)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
60u8,
244u8,
165u8,
122u8,
108u8,
97u8,
36u8,
44u8,
9u8,
38u8,
217u8,
252u8,
9u8,
163u8,
130u8,
219u8,
163u8,
106u8,
110u8,
146u8,
98u8,
140u8,
119u8,
127u8,
18u8,
68u8,
196u8,
89u8,
184u8,
9u8,
121u8,
60u8,
]);
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 {
key: data.0,
blobHash: data.1,
metadata: data.2,
}
}
#[inline]
fn check_signature(
topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
) -> alloy_sol_types::Result<()> {
if topics.0 != Self::SIGNATURE_HASH {
return Err(
alloy_sol_types::Error::invalid_event_signature_hash(
Self::SIGNATURE,
topics.0,
Self::SIGNATURE_HASH,
),
);
}
Ok(())
}
#[inline]
fn tokenize_body(&self) -> Self::DataToken<'_> {
(
<::alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
&self.key,
),
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.blobHash),
<::alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
&self.metadata,
),
)
}
#[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 ObjectAdded {
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<&ObjectAdded> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &ObjectAdded) -> 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,
clippy::style
)]
#[derive(Clone)]
pub struct ObjectDeleted {
#[allow(missing_docs)]
pub key: ::alloy_sol_types::private::Bytes,
#[allow(missing_docs)]
pub blobHash: ::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 ObjectDeleted {
type DataTuple<'a> = (
::alloy_sol_types::sol_data::Bytes,
::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>,);
const SIGNATURE: &'static str = "ObjectDeleted(bytes,bytes32)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
113u8,
40u8,
100u8,
34u8,
143u8,
54u8,
156u8,
194u8,
0u8,
69u8,
202u8,
23u8,
58u8,
171u8,
116u8,
85u8,
175u8,
88u8,
250u8,
159u8,
109u8,
186u8,
7u8,
73u8,
16u8,
146u8,
201u8,
61u8,
44u8,
247u8,
251u8,
6u8,
]);
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 {
key: data.0,
blobHash: 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::Bytes as alloy_sol_types::SolType>::tokenize(
&self.key,
),
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.blobHash),
)
}
#[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 ObjectDeleted {
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<&ObjectDeleted> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &ObjectDeleted) -> 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,
clippy::style
)]
#[derive(Clone)]
pub struct ObjectMetadataUpdated {
#[allow(missing_docs)]
pub key: ::alloy_sol_types::private::Bytes,
#[allow(missing_docs)]
pub metadata: ::alloy_sol_types::private::Bytes,
}
#[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 ObjectMetadataUpdated {
type DataTuple<'a> = (
::alloy_sol_types::sol_data::Bytes,
::alloy_sol_types::sol_data::Bytes,
);
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 = "ObjectMetadataUpdated(bytes,bytes)";
const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
165u8,
63u8,
104u8,
146u8,
29u8,
139u8,
166u8,
53u8,
110u8,
66u8,
48u8,
119u8,
167u8,
86u8,
255u8,
42u8,
40u8,
42u8,
230u8,
222u8,
93u8,
78u8,
204u8,
97u8,
125u8,
160u8,
155u8,
1u8,
234u8,
213u8,
214u8,
64u8,
]);
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 {
key: data.0,
metadata: 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::Bytes as alloy_sol_types::SolType>::tokenize(
&self.key,
),
<::alloy_sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
&self.metadata,
),
)
}
#[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 ObjectMetadataUpdated {
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<&ObjectMetadataUpdated> for alloy_sol_types::private::LogData {
#[inline]
fn from(this: &ObjectMetadataUpdated) -> 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 addObject_0Call {
#[allow(missing_docs)]
pub source: ::alloy_sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub key: ::alloy_sol_types::private::String,
#[allow(missing_docs)]
pub hash: ::alloy_sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub recoveryHash: ::alloy_sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub size: u64,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addObject_0Return {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::Uint<64>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
::alloy_sol_types::private::FixedBytes<32>,
::alloy_sol_types::private::String,
::alloy_sol_types::private::FixedBytes<32>,
::alloy_sol_types::private::FixedBytes<32>,
u64,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<addObject_0Call> for UnderlyingRustTuple<'_> {
fn from(value: addObject_0Call) -> Self {
(value.source, value.key, value.hash, value.recoveryHash, value.size)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for addObject_0Call {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
source: tuple.0,
key: tuple.1,
hash: tuple.2,
recoveryHash: tuple.3,
size: tuple.4,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<addObject_0Return> for UnderlyingRustTuple<'_> {
fn from(value: addObject_0Return) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for addObject_0Return {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for addObject_0Call {
type Parameters<'a> = (
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::Uint<64>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = addObject_0Return;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "addObject(bytes32,string,bytes32,bytes32,uint64)";
const SELECTOR: [u8; 4] = [45u8, 111u8, 37u8, 80u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.source),
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.key,
),
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.hash),
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.recoveryHash),
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.size),
)
}
#[inline]
fn abi_decode_returns(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
.map(Into::into)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addObject_1Call {
#[allow(missing_docs)]
pub source: ::alloy_sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub key: ::alloy_sol_types::private::String,
#[allow(missing_docs)]
pub hash: ::alloy_sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub recoveryHash: ::alloy_sol_types::private::FixedBytes<32>,
#[allow(missing_docs)]
pub size: u64,
#[allow(missing_docs)]
pub ttl: u64,
#[allow(missing_docs)]
pub metadata: ::alloy_sol_types::private::Vec<
<KeyValue as ::alloy_sol_types::SolType>::RustType,
>,
#[allow(missing_docs)]
pub overwrite: bool,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct addObject_1Return {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::Uint<64>,
::alloy_sol_types::sol_data::Uint<64>,
::alloy_sol_types::sol_data::Array<KeyValue>,
::alloy_sol_types::sol_data::Bool,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
::alloy_sol_types::private::FixedBytes<32>,
::alloy_sol_types::private::String,
::alloy_sol_types::private::FixedBytes<32>,
::alloy_sol_types::private::FixedBytes<32>,
u64,
u64,
::alloy_sol_types::private::Vec<
<KeyValue as ::alloy_sol_types::SolType>::RustType,
>,
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<addObject_1Call> for UnderlyingRustTuple<'_> {
fn from(value: addObject_1Call) -> Self {
(
value.source,
value.key,
value.hash,
value.recoveryHash,
value.size,
value.ttl,
value.metadata,
value.overwrite,
)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for addObject_1Call {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
source: tuple.0,
key: tuple.1,
hash: tuple.2,
recoveryHash: tuple.3,
size: tuple.4,
ttl: tuple.5,
metadata: tuple.6,
overwrite: tuple.7,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<addObject_1Return> for UnderlyingRustTuple<'_> {
fn from(value: addObject_1Return) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for addObject_1Return {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for addObject_1Call {
type Parameters<'a> = (
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::FixedBytes<32>,
::alloy_sol_types::sol_data::Uint<64>,
::alloy_sol_types::sol_data::Uint<64>,
::alloy_sol_types::sol_data::Array<KeyValue>,
::alloy_sol_types::sol_data::Bool,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = addObject_1Return;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "addObject(bytes32,string,bytes32,bytes32,uint64,uint64,(string,string)[],bool)";
const SELECTOR: [u8; 4] = [119u8, 67u8, 67u8, 254u8];
#[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.source),
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.key,
),
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.hash),
<::alloy_sol_types::sol_data::FixedBytes<
32,
> as alloy_sol_types::SolType>::tokenize(&self.recoveryHash),
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.size),
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.ttl),
<::alloy_sol_types::sol_data::Array<
KeyValue,
> as alloy_sol_types::SolType>::tokenize(&self.metadata),
<::alloy_sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
&self.overwrite,
),
)
}
#[inline]
fn abi_decode_returns(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
.map(Into::into)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct deleteObjectCall {
#[allow(missing_docs)]
pub key: ::alloy_sol_types::private::String,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct deleteObjectReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (::alloy_sol_types::sol_data::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<deleteObjectCall> for UnderlyingRustTuple<'_> {
fn from(value: deleteObjectCall) -> Self {
(value.key,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for deleteObjectCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { key: tuple.0 }
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<deleteObjectReturn> for UnderlyingRustTuple<'_> {
fn from(value: deleteObjectReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for deleteObjectReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for deleteObjectCall {
type Parameters<'a> = (::alloy_sol_types::sol_data::String,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = deleteObjectReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "deleteObject(string)";
const SELECTOR: [u8; 4] = [45u8, 124u8, 182u8, 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::String as alloy_sol_types::SolType>::tokenize(
&self.key,
),
)
}
#[inline]
fn abi_decode_returns(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
.map(Into::into)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct getObjectCall {
#[allow(missing_docs)]
pub key: ::alloy_sol_types::private::String,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct getObjectReturn {
#[allow(missing_docs)]
pub _0: <ObjectValue as ::alloy_sol_types::SolType>::RustType,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
{
#[doc(hidden)]
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<getObjectCall> for UnderlyingRustTuple<'_> {
fn from(value: getObjectCall) -> Self {
(value.key,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for getObjectCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { key: tuple.0 }
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (ObjectValue,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
<ObjectValue as ::alloy_sol_types::SolType>::RustType,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<getObjectReturn> for UnderlyingRustTuple<'_> {
fn from(value: getObjectReturn) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for getObjectReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for getObjectCall {
type Parameters<'a> = (::alloy_sol_types::sol_data::String,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = getObjectReturn;
type ReturnTuple<'a> = (ObjectValue,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "getObject(string)";
const SELECTOR: [u8; 4] = [1u8, 83u8, 234u8, 145u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.key,
),
)
}
#[inline]
fn abi_decode_returns(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
.map(Into::into)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queryObjects_0Call {
#[allow(missing_docs)]
pub prefix: ::alloy_sol_types::private::String,
#[allow(missing_docs)]
pub delimiter: ::alloy_sol_types::private::String,
#[allow(missing_docs)]
pub startKey: ::alloy_sol_types::private::String,
#[allow(missing_docs)]
pub limit: u64,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queryObjects_0Return {
#[allow(missing_docs)]
pub _0: <Query as ::alloy_sol_types::SolType>::RustType,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::Uint<64>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
::alloy_sol_types::private::String,
::alloy_sol_types::private::String,
::alloy_sol_types::private::String,
u64,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<queryObjects_0Call> for UnderlyingRustTuple<'_> {
fn from(value: queryObjects_0Call) -> Self {
(value.prefix, value.delimiter, value.startKey, value.limit)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryObjects_0Call {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
prefix: tuple.0,
delimiter: tuple.1,
startKey: tuple.2,
limit: tuple.3,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (Query,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
<Query as ::alloy_sol_types::SolType>::RustType,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<queryObjects_0Return>
for UnderlyingRustTuple<'_> {
fn from(value: queryObjects_0Return) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queryObjects_0Return {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for queryObjects_0Call {
type Parameters<'a> = (
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::Uint<64>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = queryObjects_0Return;
type ReturnTuple<'a> = (Query,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "queryObjects(string,string,string,uint64)";
const SELECTOR: [u8; 4] = [23u8, 211u8, 82u8, 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::String as alloy_sol_types::SolType>::tokenize(
&self.prefix,
),
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.delimiter,
),
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.startKey,
),
<::alloy_sol_types::sol_data::Uint<
64,
> as alloy_sol_types::SolType>::tokenize(&self.limit),
)
}
#[inline]
fn abi_decode_returns(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
.map(Into::into)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queryObjects_1Call {
#[allow(missing_docs)]
pub prefix: ::alloy_sol_types::private::String,
#[allow(missing_docs)]
pub delimiter: ::alloy_sol_types::private::String,
#[allow(missing_docs)]
pub startKey: ::alloy_sol_types::private::String,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queryObjects_1Return {
#[allow(missing_docs)]
pub _0: <Query as ::alloy_sol_types::SolType>::RustType,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::String,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
::alloy_sol_types::private::String,
::alloy_sol_types::private::String,
::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<queryObjects_1Call> for UnderlyingRustTuple<'_> {
fn from(value: queryObjects_1Call) -> Self {
(value.prefix, value.delimiter, value.startKey)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryObjects_1Call {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
prefix: tuple.0,
delimiter: tuple.1,
startKey: tuple.2,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (Query,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
<Query as ::alloy_sol_types::SolType>::RustType,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<queryObjects_1Return>
for UnderlyingRustTuple<'_> {
fn from(value: queryObjects_1Return) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queryObjects_1Return {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for queryObjects_1Call {
type Parameters<'a> = (
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::String,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = queryObjects_1Return;
type ReturnTuple<'a> = (Query,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "queryObjects(string,string,string)";
const SELECTOR: [u8; 4] = [76u8, 83u8, 234u8, 181u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.prefix,
),
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.delimiter,
),
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.startKey,
),
)
}
#[inline]
fn abi_decode_returns(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
.map(Into::into)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queryObjects_2Call {
#[allow(missing_docs)]
pub prefix: ::alloy_sol_types::private::String,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queryObjects_2Return {
#[allow(missing_docs)]
pub _0: <Query as ::alloy_sol_types::SolType>::RustType,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
{
#[doc(hidden)]
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<queryObjects_2Call> for UnderlyingRustTuple<'_> {
fn from(value: queryObjects_2Call) -> Self {
(value.prefix,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryObjects_2Call {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { prefix: tuple.0 }
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (Query,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
<Query as ::alloy_sol_types::SolType>::RustType,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<queryObjects_2Return>
for UnderlyingRustTuple<'_> {
fn from(value: queryObjects_2Return) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queryObjects_2Return {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for queryObjects_2Call {
type Parameters<'a> = (::alloy_sol_types::sol_data::String,);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = queryObjects_2Return;
type ReturnTuple<'a> = (Query,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "queryObjects(string)";
const SELECTOR: [u8; 4] = [98u8, 148u8, 233u8, 163u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.prefix,
),
)
}
#[inline]
fn abi_decode_returns(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
.map(Into::into)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queryObjects_3Call {}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queryObjects_3Return {
#[allow(missing_docs)]
pub _0: <Query as ::alloy_sol_types::SolType>::RustType,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
{
#[doc(hidden)]
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<queryObjects_3Call> for UnderlyingRustTuple<'_> {
fn from(value: queryObjects_3Call) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryObjects_3Call {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (Query,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
<Query as ::alloy_sol_types::SolType>::RustType,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<queryObjects_3Return>
for UnderlyingRustTuple<'_> {
fn from(value: queryObjects_3Return) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queryObjects_3Return {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for queryObjects_3Call {
type Parameters<'a> = ();
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = queryObjects_3Return;
type ReturnTuple<'a> = (Query,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "queryObjects()";
const SELECTOR: [u8; 4] = [164u8, 67u8, 168u8, 63u8];
#[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_returns(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
.map(Into::into)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queryObjects_4Call {
#[allow(missing_docs)]
pub prefix: ::alloy_sol_types::private::String,
#[allow(missing_docs)]
pub delimiter: ::alloy_sol_types::private::String,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct queryObjects_4Return {
#[allow(missing_docs)]
pub _0: <Query as ::alloy_sol_types::SolType>::RustType,
}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::String,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
::alloy_sol_types::private::String,
::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<queryObjects_4Call> for UnderlyingRustTuple<'_> {
fn from(value: queryObjects_4Call) -> Self {
(value.prefix, value.delimiter)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>> for queryObjects_4Call {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
prefix: tuple.0,
delimiter: tuple.1,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (Query,);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
<Query as ::alloy_sol_types::SolType>::RustType,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<queryObjects_4Return>
for UnderlyingRustTuple<'_> {
fn from(value: queryObjects_4Return) -> Self {
(value._0,)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for queryObjects_4Return {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self { _0: tuple.0 }
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for queryObjects_4Call {
type Parameters<'a> = (
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::String,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = queryObjects_4Return;
type ReturnTuple<'a> = (Query,);
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "queryObjects(string,string)";
const SELECTOR: [u8; 4] = [201u8, 174u8, 239u8, 129u8];
#[inline]
fn new<'a>(
tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
) -> Self {
tuple.into()
}
#[inline]
fn tokenize(&self) -> Self::Token<'_> {
(
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.prefix,
),
<::alloy_sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
&self.delimiter,
),
)
}
#[inline]
fn abi_decode_returns(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
.map(Into::into)
}
}
};
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct updateObjectMetadataCall {
#[allow(missing_docs)]
pub key: ::alloy_sol_types::private::String,
#[allow(missing_docs)]
pub metadata: ::alloy_sol_types::private::Vec<
<KeyValue as ::alloy_sol_types::SolType>::RustType,
>,
}
#[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
#[derive(Clone)]
pub struct updateObjectMetadataReturn {}
#[allow(
non_camel_case_types,
non_snake_case,
clippy::pub_underscore_fields,
clippy::style
)]
const _: () = {
use ::alloy_sol_types as alloy_sol_types;
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = (
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::Array<KeyValue>,
);
#[doc(hidden)]
type UnderlyingRustTuple<'a> = (
::alloy_sol_types::private::String,
::alloy_sol_types::private::Vec<
<KeyValue as ::alloy_sol_types::SolType>::RustType,
>,
);
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<updateObjectMetadataCall>
for UnderlyingRustTuple<'_> {
fn from(value: updateObjectMetadataCall) -> Self {
(value.key, value.metadata)
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for updateObjectMetadataCall {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {
key: tuple.0,
metadata: tuple.1,
}
}
}
}
{
#[doc(hidden)]
type UnderlyingSolTuple<'a> = ();
#[doc(hidden)]
type UnderlyingRustTuple<'a> = ();
#[cfg(test)]
#[allow(dead_code, unreachable_patterns)]
fn _type_assertion(
_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
) {
match _t {
alloy_sol_types::private::AssertTypeEq::<
<UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
>(_) => {}
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<updateObjectMetadataReturn>
for UnderlyingRustTuple<'_> {
fn from(value: updateObjectMetadataReturn) -> Self {
()
}
}
#[automatically_derived]
#[doc(hidden)]
impl ::core::convert::From<UnderlyingRustTuple<'_>>
for updateObjectMetadataReturn {
fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
Self {}
}
}
}
#[automatically_derived]
impl alloy_sol_types::SolCall for updateObjectMetadataCall {
type Parameters<'a> = (
::alloy_sol_types::sol_data::String,
::alloy_sol_types::sol_data::Array<KeyValue>,
);
type Token<'a> = <Self::Parameters<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
type Return = updateObjectMetadataReturn;
type ReturnTuple<'a> = ();
type ReturnToken<'a> = <Self::ReturnTuple<
'a,
> as alloy_sol_types::SolType>::Token<'a>;
const SIGNATURE: &'static str = "updateObjectMetadata(string,(string,string)[])";
const SELECTOR: [u8; 4] = [111u8, 10u8, 79u8, 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::String as alloy_sol_types::SolType>::tokenize(
&self.key,
),
<::alloy_sol_types::sol_data::Array<
KeyValue,
> as alloy_sol_types::SolType>::tokenize(&self.metadata),
)
}
#[inline]
fn abi_decode_returns(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<Self::Return> {
<Self::ReturnTuple<
'_,
> as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
.map(Into::into)
}
}
};
pub enum IBucketFacadeCalls {
#[allow(missing_docs)]
addObject_0(addObject_0Call),
#[allow(missing_docs)]
addObject_1(addObject_1Call),
#[allow(missing_docs)]
deleteObject(deleteObjectCall),
#[allow(missing_docs)]
getObject(getObjectCall),
#[allow(missing_docs)]
queryObjects_0(queryObjects_0Call),
#[allow(missing_docs)]
queryObjects_1(queryObjects_1Call),
#[allow(missing_docs)]
queryObjects_2(queryObjects_2Call),
#[allow(missing_docs)]
queryObjects_3(queryObjects_3Call),
#[allow(missing_docs)]
queryObjects_4(queryObjects_4Call),
#[allow(missing_docs)]
updateObjectMetadata(updateObjectMetadataCall),
}
#[automatically_derived]
impl IBucketFacadeCalls {
pub const SELECTORS: &'static [[u8; 4usize]] = &[
[1u8, 83u8, 234u8, 145u8],
[23u8, 211u8, 82u8, 192u8],
[45u8, 111u8, 37u8, 80u8],
[45u8, 124u8, 182u8, 0u8],
[76u8, 83u8, 234u8, 181u8],
[98u8, 148u8, 233u8, 163u8],
[111u8, 10u8, 79u8, 244u8],
[119u8, 67u8, 67u8, 254u8],
[164u8, 67u8, 168u8, 63u8],
[201u8, 174u8, 239u8, 129u8],
];
}
#[automatically_derived]
impl alloy_sol_types::SolInterface for IBucketFacadeCalls {
const NAME: &'static str = "IBucketFacadeCalls";
const MIN_DATA_LENGTH: usize = 0usize;
const COUNT: usize = 10usize;
#[inline]
fn selector(&self) -> [u8; 4] {
match self {
Self::addObject_0(_) => {
<addObject_0Call as alloy_sol_types::SolCall>::SELECTOR
}
Self::addObject_1(_) => {
<addObject_1Call as alloy_sol_types::SolCall>::SELECTOR
}
Self::deleteObject(_) => {
<deleteObjectCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::getObject(_) => {
<getObjectCall as alloy_sol_types::SolCall>::SELECTOR
}
Self::queryObjects_0(_) => {
<queryObjects_0Call as alloy_sol_types::SolCall>::SELECTOR
}
Self::queryObjects_1(_) => {
<queryObjects_1Call as alloy_sol_types::SolCall>::SELECTOR
}
Self::queryObjects_2(_) => {
<queryObjects_2Call as alloy_sol_types::SolCall>::SELECTOR
}
Self::queryObjects_3(_) => {
<queryObjects_3Call as alloy_sol_types::SolCall>::SELECTOR
}
Self::queryObjects_4(_) => {
<queryObjects_4Call as alloy_sol_types::SolCall>::SELECTOR
}
Self::updateObjectMetadata(_) => {
<updateObjectMetadataCall 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],
validate: bool,
) -> alloy_sol_types::Result<Self> {
static DECODE_SHIMS: &[fn(
&[u8],
bool,
) -> alloy_sol_types::Result<IBucketFacadeCalls>] = &[
{
fn getObject(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<IBucketFacadeCalls> {
<getObjectCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
validate,
)
.map(IBucketFacadeCalls::getObject)
}
getObject
},
{
fn queryObjects_0(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<IBucketFacadeCalls> {
<queryObjects_0Call as alloy_sol_types::SolCall>::abi_decode_raw(
data,
validate,
)
.map(IBucketFacadeCalls::queryObjects_0)
}
queryObjects_0
},
{
fn addObject_0(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<IBucketFacadeCalls> {
<addObject_0Call as alloy_sol_types::SolCall>::abi_decode_raw(
data,
validate,
)
.map(IBucketFacadeCalls::addObject_0)
}
addObject_0
},
{
fn deleteObject(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<IBucketFacadeCalls> {
<deleteObjectCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
validate,
)
.map(IBucketFacadeCalls::deleteObject)
}
deleteObject
},
{
fn queryObjects_1(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<IBucketFacadeCalls> {
<queryObjects_1Call as alloy_sol_types::SolCall>::abi_decode_raw(
data,
validate,
)
.map(IBucketFacadeCalls::queryObjects_1)
}
queryObjects_1
},
{
fn queryObjects_2(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<IBucketFacadeCalls> {
<queryObjects_2Call as alloy_sol_types::SolCall>::abi_decode_raw(
data,
validate,
)
.map(IBucketFacadeCalls::queryObjects_2)
}
queryObjects_2
},
{
fn updateObjectMetadata(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<IBucketFacadeCalls> {
<updateObjectMetadataCall as alloy_sol_types::SolCall>::abi_decode_raw(
data,
validate,
)
.map(IBucketFacadeCalls::updateObjectMetadata)
}
updateObjectMetadata
},
{
fn addObject_1(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<IBucketFacadeCalls> {
<addObject_1Call as alloy_sol_types::SolCall>::abi_decode_raw(
data,
validate,
)
.map(IBucketFacadeCalls::addObject_1)
}
addObject_1
},
{
fn queryObjects_3(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<IBucketFacadeCalls> {
<queryObjects_3Call as alloy_sol_types::SolCall>::abi_decode_raw(
data,
validate,
)
.map(IBucketFacadeCalls::queryObjects_3)
}
queryObjects_3
},
{
fn queryObjects_4(
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<IBucketFacadeCalls> {
<queryObjects_4Call as alloy_sol_types::SolCall>::abi_decode_raw(
data,
validate,
)
.map(IBucketFacadeCalls::queryObjects_4)
}
queryObjects_4
},
];
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, validate)
}
#[inline]
fn abi_encoded_size(&self) -> usize {
match self {
Self::addObject_0(inner) => {
<addObject_0Call as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::addObject_1(inner) => {
<addObject_1Call as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::deleteObject(inner) => {
<deleteObjectCall as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::getObject(inner) => {
<getObjectCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
}
Self::queryObjects_0(inner) => {
<queryObjects_0Call as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::queryObjects_1(inner) => {
<queryObjects_1Call as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::queryObjects_2(inner) => {
<queryObjects_2Call as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::queryObjects_3(inner) => {
<queryObjects_3Call as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::queryObjects_4(inner) => {
<queryObjects_4Call as alloy_sol_types::SolCall>::abi_encoded_size(
inner,
)
}
Self::updateObjectMetadata(inner) => {
<updateObjectMetadataCall 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::addObject_0(inner) => {
<addObject_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::addObject_1(inner) => {
<addObject_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::deleteObject(inner) => {
<deleteObjectCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::getObject(inner) => {
<getObjectCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::queryObjects_0(inner) => {
<queryObjects_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::queryObjects_1(inner) => {
<queryObjects_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::queryObjects_2(inner) => {
<queryObjects_2Call as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::queryObjects_3(inner) => {
<queryObjects_3Call as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::queryObjects_4(inner) => {
<queryObjects_4Call as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
Self::updateObjectMetadata(inner) => {
<updateObjectMetadataCall as alloy_sol_types::SolCall>::abi_encode_raw(
inner,
out,
)
}
}
}
}
pub enum IBucketFacadeEvents {
#[allow(missing_docs)]
ObjectAdded(ObjectAdded),
#[allow(missing_docs)]
ObjectDeleted(ObjectDeleted),
#[allow(missing_docs)]
ObjectMetadataUpdated(ObjectMetadataUpdated),
}
#[automatically_derived]
impl IBucketFacadeEvents {
pub const SELECTORS: &'static [[u8; 32usize]] = &[
[
60u8,
244u8,
165u8,
122u8,
108u8,
97u8,
36u8,
44u8,
9u8,
38u8,
217u8,
252u8,
9u8,
163u8,
130u8,
219u8,
163u8,
106u8,
110u8,
146u8,
98u8,
140u8,
119u8,
127u8,
18u8,
68u8,
196u8,
89u8,
184u8,
9u8,
121u8,
60u8,
],
[
113u8,
40u8,
100u8,
34u8,
143u8,
54u8,
156u8,
194u8,
0u8,
69u8,
202u8,
23u8,
58u8,
171u8,
116u8,
85u8,
175u8,
88u8,
250u8,
159u8,
109u8,
186u8,
7u8,
73u8,
16u8,
146u8,
201u8,
61u8,
44u8,
247u8,
251u8,
6u8,
],
[
165u8,
63u8,
104u8,
146u8,
29u8,
139u8,
166u8,
53u8,
110u8,
66u8,
48u8,
119u8,
167u8,
86u8,
255u8,
42u8,
40u8,
42u8,
230u8,
222u8,
93u8,
78u8,
204u8,
97u8,
125u8,
160u8,
155u8,
1u8,
234u8,
213u8,
214u8,
64u8,
],
];
}
#[automatically_derived]
impl alloy_sol_types::SolEventInterface for IBucketFacadeEvents {
const NAME: &'static str = "IBucketFacadeEvents";
const COUNT: usize = 3usize;
fn decode_raw_log(
topics: &[alloy_sol_types::Word],
data: &[u8],
validate: bool,
) -> alloy_sol_types::Result<Self> {
match topics.first().copied() {
Some(<ObjectAdded as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<ObjectAdded as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
validate,
)
.map(Self::ObjectAdded)
}
Some(<ObjectDeleted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
<ObjectDeleted as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
validate,
)
.map(Self::ObjectDeleted)
}
Some(
<ObjectMetadataUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
) => {
<ObjectMetadataUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
topics,
data,
validate,
)
.map(Self::ObjectMetadataUpdated)
}
_ => {
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 IBucketFacadeEvents {
fn to_log_data(&self) -> alloy_sol_types::private::LogData {
match self {
Self::ObjectAdded(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::ObjectDeleted(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
Self::ObjectMetadataUpdated(inner) => {
alloy_sol_types::private::IntoLogData::to_log_data(inner)
}
}
}
fn into_log_data(self) -> alloy_sol_types::private::LogData {
match self {
Self::ObjectAdded(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::ObjectDeleted(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
Self::ObjectMetadataUpdated(inner) => {
alloy_sol_types::private::IntoLogData::into_log_data(inner)
}
}
}
}
}