Enum FungibleType

#[repr(u8)]
pub enum FungibleType {
    Unsigned64Bit = 8,
}

Today we support only a single format of confidential data, because of the limitations of the underlying secp256k1-zkp library: it works only with u64 numbers. Nevertheless, homomorphic commitments can be created to everything that has up to 256 bits and commutative arithmetics, so in the future we plan to support more types. We reserve this possibility by internally encoding [ConfidentialFormat] with the same type specification details as used for [DateFormat]

Variants

Unsigned64Bit = 8

Trait Implementations

impl Clone for FungibleType

fn clone(&self) -> FungibleType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FungibleType

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

Formats the value using the given formatter.

impl Default for FungibleType

fn default() -> FungibleType

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FungibleType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for FungibleType

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

Formats the value using the given formatter.

impl PartialEq for FungibleType

fn eq(&self, other: &FungibleType) -> 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 FungibleType

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 StrictDecode for FungibleType

fn strict_decode( reader: &mut impl TypedRead, ) -> Result<FungibleType, DecodeError>

fn strict_read(lim: usize, reader: impl Read) -> Result<Self, DecodeError>

impl StrictEncode for FungibleType

fn strict_encode<W>(&self, writer: W) -> Result<W, Error>

where W: TypedWrite,

fn strict_write(&self, lim: usize, writer: impl Write) -> Result<usize, Error>

impl StrictEnum for FungibleType

fn from_variant_name(name: &FieldName) -> Result<Self, VariantError<&FieldName>>

fn strict_type_info() -> TypeInfo<Self>

impl StrictSum for FungibleType

const ALL_VARIANTS: &'static [(u8, &'static str)]

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

fn strict_check_variants()

fn variant_name_by_tag(tag: u8) -> Option<FieldName>

fn variant_ord(&self) -> u8

impl StrictType for FungibleType

const STRICT_LIB_NAME: &'static str = LIB_NAME_RGB

fn strict_name() -> Option<TypeName>

impl TryFrom<u8> for FungibleType

type Error = VariantError<u8>

The type returned in the event of a conversion error.

fn try_from( value: u8, ) -> Result<FungibleType, <FungibleType as TryFrom<u8>>::Error>

Performs the conversion.

impl Copy for FungibleType

impl Eq for FungibleType

impl StructuralPartialEq for FungibleType