Struct Payload 

pub struct Payload {
    pub chain_id: u8,
    pub sender: PublicKey,
    pub receiver: PublicKey,
    pub value: u64,
    pub deposit: u64,
    pub fee: Fee,
    pub nonce: u64,
    pub data: Option<TransactionData>,
}

The payload for a moonlight transaction.

Fields

chain_id: u8

ID of the chain for this transaction to execute on.

sender: PublicKey

Key of the sender of this transaction.

receiver: PublicKey

Key of the receiver of the funds.

value: u64

Value to be transferred.

deposit: u64

Deposit for a contract.

fee: Fee

Data used to calculate the transaction fee and refund unspent gas.

nonce: u64

Nonce used for replay protection. Moonlight nonces are strictly increasing and incremental, meaning that for a transaction to be valid, only the current nonce + 1 can be used.

The current nonce is queryable via the transfer contract.

data: Option<TransactionData>

Data to do a contract call, deployment, or insert a memo.

Implementations

impl Payload

pub fn to_var_bytes(&self) -> Vec<u8>

Serialize the payload into a byte buffer.

pub fn from_slice(buf: &[u8]) -> Result<Self, BytesError>

Deserialize the payload from bytes slice.

Errors

Errors when the bytes are not canonical.

pub fn signature_message(&self) -> Vec<u8>

Return input bytes to hash the payload.

Note: The result of this function is only meant to be used as an input for hashing and cannot be used to deserialize the payload again.

Trait Implementations

impl Archive for Payload

where u8: Archive, AccountPublicKey: Archive, u64: Archive, Fee: Archive, Option<TransactionData>: Archive,

type Archived = ArchivedPayload

The archived representation of this type.

type Resolver = PayloadResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for Payload

fn clone(&self) -> Payload

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Payload

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<Payload, __D> for Archived<Payload>

where u8: Archive, Archived<u8>: Deserialize<u8, __D>, AccountPublicKey: Archive, Archived<AccountPublicKey>: Deserialize<AccountPublicKey, __D>, u64: Archive, Archived<u64>: Deserialize<u64, __D>, Fee: Archive, Archived<Fee>: Deserialize<Fee, __D>, Option<TransactionData>: Archive, Archived<Option<TransactionData>>: Deserialize<Option<TransactionData>, __D>,

fn deserialize(&self, deserializer: &mut __D) -> Result<Payload, __D::Error>

Deserializes using the given deserializer

impl PartialEq for Payload

fn eq(&self, other: &Payload) -> 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<__S: Fallible + ?Sized> Serialize<__S> for Payload

where u8: Serialize<__S>, AccountPublicKey: Serialize<__S>, u64: Serialize<__S>, Fee: Serialize<__S>, Option<TransactionData>: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Eq for Payload

impl StructuralPartialEq for Payload