Struct ClaimReceiptV1 

pub struct ClaimReceiptV1 {
    pub version: u8,
    pub token: Address,
    pub recoveryAuthority: Address,
    pub originator: Address,
    pub recipient: Address,
    pub blockedAt: u64,
    pub blockedNonce: u64,
    pub blockedReason: u8,
    pub kind: <InboundKind as SolType>::RustType,
    pub memo: FixedBytes<32>,
}

@notice Claim receipt for one blocked inbound transfer or mint. @dev recipient is the addressed to value and may be virtual. The corresponding receiver emitted in events is the resolved account/master where funds settle.

struct ClaimReceiptV1 { uint8 version; address token; address recoveryAuthority; address originator; address recipient; uint64 blockedAt; uint64 blockedNonce; uint8 blockedReason; InboundKind kind; bytes32 memo; }

Fields

version: u8

@notice Receipt layout version. Must equal 1 for this struct.

token: Address

@notice TIP-20 token whose blocked funds are held by the guard.

recoveryAuthority: Address

@notice Address with the authority to claim the blocked funds.

originator: Address

@notice Original sender/originator of the blocked transfer or mint.

recipient: Address

@notice Addressed recipient from the inbound operation; may be a virtual address.

blockedAt: u64

@notice Block timestamp when the inbound operation was blocked.

blockedNonce: u64

@notice Guard nonce assigned when the inbound operation was blocked.

blockedReason: u8

@notice TIP-403 blocked reason encoded as a BlockedReason discriminant.

kind: <InboundKind as SolType>::RustType

@notice Whether the blocked inbound operation was a transfer or mint.

memo: FixedBytes<32>

@notice Application memo copied from the blocked inbound operation.

Implementations

impl ClaimReceiptV1

pub fn new( token: Address, recovery_auth: Address, originator: Address, recipient: Address, at: u64, nonce: u64, reason: u8, kind: InboundKind, memo: FixedBytes<32>, ) -> ClaimReceiptV1

pub fn claimed_event( &self, receiver: Address, caller: Address, to: Address, amount: Uint<256, 4>, ) -> IReceivePolicyGuardEvents

pub fn blocked_event( &self, receiver: Address, amount: Uint<256, 4>, ) -> IReceivePolicyGuardEvents

pub fn burned_event( &self, receiver: Address, caller: Address, amount: Uint<256, 4>, ) -> IReceivePolicyGuardEvents

Trait Implementations

impl Clone for ClaimReceiptV1

fn clone(&self) -> ClaimReceiptV1

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ClaimReceiptV1

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ClaimReceiptV1

fn deserialize<__D>( __deserializer: __D, ) -> Result<ClaimReceiptV1, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ClaimReceiptV1

impl EventTopic for ClaimReceiptV1

fn topic_preimage_length(rust: &<ClaimReceiptV1 as SolType>::RustType) -> usize

The number of bytes this type occupies in another topic’s preimage, usually a multiple of 32.

fn encode_topic_preimage( rust: &<ClaimReceiptV1 as SolType>::RustType, out: &mut Vec<u8>, )

Encodes this type as preimage bytes which are then hashed in complex types’ [encode_topic][EventTopic::encode_topic].

fn encode_topic(rust: &<ClaimReceiptV1 as SolType>::RustType) -> WordToken

Indexed event parameter encoding.

impl PartialEq for ClaimReceiptV1

fn eq(&self, other: &ClaimReceiptV1) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ClaimReceiptV1

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SolStruct for ClaimReceiptV1

const NAME: &'static str = "ClaimReceiptV1"

The struct name.

fn eip712_root_type() -> Cow<'static, str>

Return the root EIP-712 type. This type is used to construct the encodeType string.

fn eip712_components() -> Vec<Cow<'static, str>>

Returns component EIP-712 types. These types are used to construct the encodeType string. These are the types of the struct’s fields, and should not include the root type.

fn eip712_encode_type() -> Cow<'static, str>

The EIP-712-encoded type string.

fn eip712_encode_data(&self) -> Vec<u8>

Encodes this domain using EIP-712 encodeData.

fn eip712_type_hash(&self) -> FixedBytes<32>

Calculates the EIP-712 typeHash for this struct.

fn eip712_hash_struct(&self) -> FixedBytes<32>

Calculates the EIP-712 hashStruct for this value.

fn eip712_signing_hash(&self, domain: &Eip712Domain) -> FixedBytes<32>

Calculate the EIP-712 signing hash for this struct. Note that this does not sign the hash, only calculates it.

impl SolType for ClaimReceiptV1

const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME

The name of this type in Solidity.

const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple as alloy_sol_types::SolType>::ENCODED_SIZE

The statically-known ABI-encoded size of the type.

const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE

The statically-known Non-standard Packed Mode ABI-encoded size of the type.

type RustType = ClaimReceiptV1

The corresponding Rust type.

type Token<'a> = <(Uint<8>, Address, Address, Address, Address, Uint<64>, Uint<64>, Uint<8>, InboundKind, FixedBytes<32>) as SolType>::Token<'a>

The corresponding ABI token type.

fn valid_token(token: &<ClaimReceiptV1 as SolType>::Token<'_>) -> bool

Returns true if the given token can be detokenized with this type.

fn detokenize( token: <ClaimReceiptV1 as SolType>::Token<'_>, ) -> <ClaimReceiptV1 as SolType>::RustType

Detokenize this type’s value from the given token.

const DYNAMIC: bool = _

Whether the ABI-encoded size is dynamic.

fn abi_encoded_size<E>(rust: &E) -> usize

where E: SolTypeValue<Self> + ?Sized,

Calculate the ABI-encoded size of the data, counting both head and tail words. For a single-word type this will always be 32.

fn type_check(token: &Self::Token<'_>) -> Result<(), Error>

Returns an error if the given token cannot be detokenized with this type.

fn tokenize<E>(rust: &E) -> Self::Token<'_>

where E: SolTypeValue<Self> + ?Sized,

Tokenizes the given value into this type’s token.

fn eip712_data_word<E>(rust: &E) -> FixedBytes<32>

where E: SolTypeValue<Self> + ?Sized,

Encode this data according to EIP-712 encodeData rules, and hash it if necessary.

fn abi_packed_encoded_size<E>(rust: &E) -> usize

where E: SolTypeValue<Self> + ?Sized,

Returns the length of this value when ABI-encoded in Non-standard Packed Mode.

fn abi_encode_packed_to<E>(rust: &E, out: &mut Vec<u8>)

where E: SolTypeValue<Self> + ?Sized,

Non-standard Packed Mode ABI encoding.

fn abi_encode_packed<E>(rust: &E) -> Vec<u8>

where E: SolTypeValue<Self> + ?Sized,

Non-standard Packed Mode ABI encoding.

fn abi_encode<E>(rust: &E) -> Vec<u8>

where E: SolTypeValue<Self> + ?Sized,

Tokenizes and ABI-encodes the given value by wrapping it in a single-element sequence.

fn abi_encode_params<E>(rust: &E) -> Vec<u8>

where E: SolTypeValue<Self> + ?Sized, Self::Token<'a>: for<'a> TokenSeq<'a>,

Tokenizes and ABI-encodes the given value as function parameters.

fn abi_encode_sequence<E>(rust: &E) -> Vec<u8>

where E: SolTypeValue<Self> + ?Sized, Self::Token<'a>: for<'a> TokenSeq<'a>,

Tokenizes and ABI-encodes the given value as a sequence.

fn abi_decode(data: &[u8]) -> Result<Self::RustType, Error>

Decodes this type’s value from an ABI blob by interpreting it as a single-element sequence.

fn abi_decode_validate(data: &[u8]) -> Result<Self::RustType, Error>

Decodes this type’s value from an ABI blob by interpreting it as single-element sequence, with validation.

fn abi_decode_params<'de>(data: &'de [u8]) -> Result<Self::RustType, Error>

where Self::Token<'de>: TokenSeq<'de>,

Decodes this type’s value from an ABI blob by interpreting it as function parameters.

fn abi_decode_params_validate<'de>( data: &'de [u8], ) -> Result<Self::RustType, Error>

where Self::Token<'de>: TokenSeq<'de>,

Decodes this type’s value from an ABI blob by interpreting it as function parameters, with validation.

fn abi_decode_sequence<'de>(data: &'de [u8]) -> Result<Self::RustType, Error>

where Self::Token<'de>: TokenSeq<'de>,

Decodes this type’s value from an ABI blob by interpreting it as a sequence.

fn abi_decode_sequence_validate<'de>( data: &'de [u8], ) -> Result<Self::RustType, Error>

where Self::Token<'de>: TokenSeq<'de>,

Decodes this type’s value from an ABI blob by interpreting it as sequence, with validation.

impl SolValue for ClaimReceiptV1

type SolType = ClaimReceiptV1

The Solidity type that this type corresponds to.

fn sol_name(&self) -> &'static str

The name of the associated Solidity type.

fn tokenize(&self) -> <Self::SolType as SolType>::Token<'_>

Tokenizes the given value into this type’s token.

fn detokenize(token: <Self::SolType as SolType>::Token<'_>) -> Self

where Self: From<<Self::SolType as SolType>::RustType>,

Detokenize a value from the given token.

fn abi_encoded_size(&self) -> usize

Calculate the ABI-encoded size of the data.

fn eip712_data_word(&self) -> FixedBytes<32>

Encode this data according to EIP-712 encodeData rules, and hash it if necessary.

fn abi_encode_packed_to(&self, out: &mut Vec<u8>)

Non-standard Packed Mode ABI encoding.

fn abi_encode_packed(&self) -> Vec<u8>

Non-standard Packed Mode ABI encoding.

fn abi_encode(&self) -> Vec<u8>

ABI-encodes the value.

fn abi_encode_sequence(&self) -> Vec<u8>

where <Self::SolType as SolType>::Token<'a>: for<'a> TokenSeq<'a>,

Encodes an ABI sequence.

fn abi_encode_params(&self) -> Vec<u8>

where <Self::SolType as SolType>::Token<'a>: for<'a> TokenSeq<'a>,

Encodes an ABI sequence suitable for function parameters.

fn abi_decode(data: &[u8]) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>,

ABI-decode this type from the given data.

fn abi_decode_validate(data: &[u8]) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>,

ABI-decode this type from the given data, with validation.

fn abi_decode_params<'de>(data: &'de [u8]) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>, <Self::SolType as SolType>::Token<'de>: TokenSeq<'de>,

ABI-decode this type from the given data.

fn abi_decode_params_validate<'de>(data: &'de [u8]) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>, <Self::SolType as SolType>::Token<'de>: TokenSeq<'de>,

ABI-decode this type from the given data, with validation.

fn abi_decode_sequence<'de>(data: &'de [u8]) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>, <Self::SolType as SolType>::Token<'de>: TokenSeq<'de>,

ABI-decode this type from the given data.

fn abi_decode_sequence_validate<'de>(data: &'de [u8]) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>, <Self::SolType as SolType>::Token<'de>: TokenSeq<'de>,

ABI-decode this type from the given data, with validation.

impl StructuralPartialEq for ClaimReceiptV1

impl TryFrom<Bytes> for ClaimReceiptV1

type Error = IReceivePolicyGuardErrors

The type returned in the event of a conversion error.

fn try_from( receipt: Bytes, ) -> Result<ClaimReceiptV1, <ClaimReceiptV1 as TryFrom<Bytes>>::Error>

Performs the conversion.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 136 bytes