Struct FungibleProof

pub struct FungibleProof(pub Proof);

Tuple Fields

0: Proof

Trait Implementations

impl AsRef<Proof> for FungibleProof

fn as_ref(&self) -> &Proof

Converts this type into a shared reference of the (usually inferred) input type.

impl Categorize<ScryptoCustomValueKind> for FungibleProof

fn value_kind() -> ValueKind<ScryptoCustomValueKind>

impl Debug for FungibleProof

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

Formats the value using the given formatter.

impl<D> Decode<ScryptoCustomValueKind, D> for FungibleProof

where D: Decoder<ScryptoCustomValueKind>,

fn decode_body_with_value_kind( decoder: &mut D, value_kind: ValueKind<ScryptoCustomValueKind>, ) -> Result<FungibleProof, DecodeError>

Decodes the type from the decoder, which should match a preloaded value kind.

impl Describe<ScryptoCustomTypeKind> for FungibleProof

const TYPE_ID: RustTypeId

The TYPE_ID should give a unique identifier for its SBOR schema type. An SBOR schema type capture details about the SBOR payload, how it should be interpreted, validated and displayed.

fn type_data() -> TypeData<ScryptoCustomTypeKind, RustTypeId>

Returns the local schema for the given type.

fn add_all_dependencies(aggregator: &mut TypeAggregator<C>)

For each type referenced in get_local_type_data, we need to ensure that the type and all of its own references get added to the aggregator.

impl<E> Encode<ScryptoCustomValueKind, E> for FungibleProof

where E: Encoder<ScryptoCustomValueKind>,

fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError>

Encodes the SBOR value’s kind to the encoder

fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError>

Encodes the SBOR body of the type to the encoder.

impl From<FungibleProof> for Proof

fn from(value: FungibleProof) -> Proof

Converts to this type from the input type.

impl Hash for FungibleProof

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for FungibleProof

fn eq(&self, other: &FungibleProof) -> 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 SborEnum<ScryptoCustomValueKind> for FungibleProof

where &'b_ Proof: for<'b_> SborEnum<ScryptoCustomValueKind>,

fn get_discriminator(&self) -> u8

fn get_length(&self) -> usize

impl SborTuple<ScryptoCustomValueKind> for FungibleProof

where &'b_ Proof: for<'b_> SborTuple<ScryptoCustomValueKind>,

fn get_length(&self) -> usize

impl ScryptoUncheckedProof for FungibleProof

type CheckedProofType = CheckedFungibleProof

type ResourceManagerType = FungibleResourceManager

fn check( self, expected_resource_address: ResourceAddress, ) -> <FungibleProof as ScryptoUncheckedProof>::CheckedProofType

Checks the resource address of this proof and panics if it’s unexpected.

fn check_with_message<S>( self, expected_resource_address: ResourceAddress, custom_error_message: S, ) -> <FungibleProof as ScryptoUncheckedProof>::CheckedProofType

where S: ToString,

Checks the resource address of this proof and panics with custom error message if it’s unexpected.

fn skip_checking( self, ) -> <FungibleProof as ScryptoUncheckedProof>::CheckedProofType

Skips checking and converts this proof into a “checked” proof.

fn resource_address(&self) -> ResourceAddress

fn resource_manager( &self, ) -> <FungibleProof as ScryptoUncheckedProof>::ResourceManagerType

fn drop(self)

fn clone(&self) -> FungibleProof

fn authorize<F, O>(&self, f: F) -> O

where F: FnOnce() -> O,

impl SpecializedProof for FungibleProof

type ResourceManager = ResourceManager

fn from_proof_of_correct_type(proof: Proof) -> FungibleProof

Purposefully not From because we want to only use this when we are confident it’s the correct type

impl Eq for FungibleProof

impl NativeFungibleProof for FungibleProof

impl StructuralPartialEq for FungibleProof