Struct Coin

pub struct Coin<Specification>
where
    Specification: CoinSpecification,
{
    pub utxo_id: UtxoId,
    pub owner: Address,
    pub amount: Word,
    pub asset_id: AssetId,
    pub tx_pointer: TxPointer,
    pub witness_index: Specification::Witness,
    pub predicate_gas_used: Specification::PredicateGasUsed,
    pub predicate: Specification::Predicate,
    pub predicate_data: Specification::PredicateData,
}

It is a full representation of the coin from the specification: https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/input.md#inputcoin.

The specification defines the layout of the Coin in the serialized form for the fuel-vm. But on the business logic level, we don’t use all fields at the same time. It is why in the super::Input the coin is represented by several forms based on the usage context. Leaving some fields empty reduces the memory consumption by the structure and erases the empty useless fields.

The CoinSpecification trait specifies the sub-coin for the corresponding usage context. It allows us to write the common logic of all sub-coins without the overhead and duplication.

Sub-coin:

• Signed - means that the coin should be signed by the owner, and the signature(witness) should be stored under the witness_index index in the witnesses vector of the crate::Transaction.
• Predicate - means that the coin is not signed, and the owner is a predicate bytecode. The merkle root from the predicate should be equal to the owner.
• Full - is used during the deserialization of the coin. It should be transformed into Signed or Predicate sub-coin. If the predicate is empty, it is Signed, else Predicate.

Fields

utxo_id: UtxoId

owner: Address

amount: Word

asset_id: AssetId

tx_pointer: TxPointer

witness_index: Specification::Witness

predicate_gas_used: Specification::PredicateGasUsed

Exact amount of gas used by the predicate. If the predicate consumes different amount of gas, it’s considered to be false.

predicate: Specification::Predicate

predicate_data: Specification::PredicateData

Implementations

impl<Specification> Coin<Specification>

where Specification: CoinSpecification,

pub fn prepare_sign(&mut self)

The “Note” section from the specification: https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/input.md#inputcoin.

impl Coin<Full>

pub fn into_signed(self) -> Coin<Signed>

pub fn into_predicate(self) -> Coin<Predicate>

impl Coin<Signed>

pub fn into_full(self) -> Coin<Full>

impl Coin<Predicate>

pub fn into_full(self) -> Coin<Full>

Trait Implementations

impl<Specification> Clone for Coin<Specification>

where Specification: CoinSpecification + Clone, Specification::Witness: Clone, Specification::PredicateGasUsed: Clone, Specification::Predicate: Clone, Specification::PredicateData: Clone,

fn clone(&self) -> Coin<Specification>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Specification> Debug for Coin<Specification>

where Specification: CoinSpecification,

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

Formats the value using the given formatter.

impl<Specification> Default for Coin<Specification>

where Specification: CoinSpecification + Default, Specification::Witness: Default, Specification::PredicateGasUsed: Default, Specification::Predicate: Default, Specification::PredicateData: Default,

fn default() -> Coin<Specification>

Returns the “default value” for a type.

impl<'de, Specification> Deserialize<'de> for Coin<Specification>

where Specification: CoinSpecification, Specification::Witness: Deserialize<'de>, Specification::PredicateGasUsed: Deserialize<'de>, Specification::Predicate: Deserialize<'de>, Specification::PredicateData: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Specification> Deserialize for Coin<Specification>

where Specification: CoinSpecification, Specification::Witness: Deserialize, Specification::PredicateGasUsed: Deserialize, Specification::Predicate: Deserialize, Specification::PredicateData: Deserialize,

fn decode_static<I: Input + ?Sized>(buffer: &mut I) -> Result<Self, Error>

Decodes static part of Self from the buffer.

fn decode_dynamic<I: Input + ?Sized>( &mut self, buffer: &mut I, ) -> Result<(), Error>

Decodes dynamic part of the information from the buffer to fill Self. The default implementation does nothing. Dynamically-sized contains should override this.

fn decode<I>(buffer: &mut I) -> Result<Self, Error>

where I: Input + ?Sized,

Decodes Self from the buffer.

fn from_bytes(buffer: &[u8]) -> Result<Self, Error>

Helper method for deserializing Self from bytes.

impl<Specification> Hash for Coin<Specification>

where Specification: CoinSpecification + Hash, Specification::Witness: Hash, Specification::PredicateGasUsed: Hash, Specification::Predicate: Hash, Specification::PredicateData: Hash,

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

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<Specification> PartialEq for Coin<Specification>

where Specification: CoinSpecification + PartialEq, Specification::Witness: PartialEq, Specification::PredicateGasUsed: PartialEq, Specification::Predicate: PartialEq, Specification::PredicateData: PartialEq,

fn eq(&self, other: &Coin<Specification>) -> 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<Specification> Serialize for Coin<Specification>

where Specification: CoinSpecification, Specification::Witness: Serialize, Specification::PredicateGasUsed: Serialize, Specification::Predicate: Serialize, Specification::PredicateData: Serialize,

fn size_static(&self) -> usize

Size of the static part of the serialized object, in bytes. Saturates to usize::MAX on overflow.

fn size_dynamic(&self) -> usize

Size of the dynamic part, in bytes. Saturates to usize::MAX on overflow.

fn encode_static<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error>

Encodes staticly-sized part of Self.

fn encode_dynamic<O: Output + ?Sized>( &self, buffer: &mut O, ) -> Result<(), Error>

Encodes dynamically-sized part of Self. The default implementation does nothing. Dynamically-sized contains should override this.

fn size(&self) -> usize

Total size of the serialized object, in bytes. Saturates to usize::MAX on overflow.

fn encode<O>(&self, buffer: &mut O) -> Result<(), Error>

where O: Output + ?Sized,

Encodes Self into the buffer.

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

Encodes Self into bytes vector. Required known size.

impl<Specification> Serialize for Coin<Specification>

where Specification: CoinSpecification, Specification::Witness: Serialize, Specification::PredicateGasUsed: Serialize, Specification::Predicate: Serialize, Specification::PredicateData: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Specification> Eq for Coin<Specification>

where Specification: CoinSpecification + Eq, Specification::Witness: Eq, Specification::PredicateGasUsed: Eq, Specification::Predicate: Eq, Specification::PredicateData: Eq,

impl<Specification> StructuralPartialEq for Coin<Specification>

where Specification: CoinSpecification,