Struct RTransaction

pub struct RTransaction {

    pub hash: H256,
    pub size: u64,
    pub version: u8,
    pub nonce: u64,
    pub sender: String,
    pub sys_fee: String,
    pub net_fee: String,
    pub valid_until_block: u64,
    pub signers: Vec<RTransactionSigner>,
    pub attributes: Vec<TransactionAttributeEnum>,
    pub script: String,
    pub witnesses: Vec<NeoWitness>,
    pub block_hash: H256,
    pub confirmations: i32,
    pub block_time: i64,
    pub vmstate: VMState,
}

Fields

hash: H256

size: u64

version: u8

nonce: u64

sender: String

sys_fee: String

net_fee: String

valid_until_block: u64

signers: Vec<RTransactionSigner>

attributes: Vec<TransactionAttributeEnum>

script: String

witnesses: Vec<NeoWitness>

block_hash: H256

confirmations: i32

block_time: i64

vmstate: VMState

Implementations

impl RTransaction

pub fn hash(&self) -> &H256

pub fn size(&self) -> &u64

pub fn version(&self) -> &u8

pub fn nonce(&self) -> &u64

pub fn sender(&self) -> &String

pub fn sys_fee(&self) -> &String

pub fn net_fee(&self) -> &String

pub fn valid_until_block(&self) -> &u64

pub fn signers(&self) -> &Vec<RTransactionSigner>

pub fn attributes(&self) -> &Vec<TransactionAttributeEnum>

pub fn script(&self) -> &String

pub fn witnesses(&self) -> &Vec<NeoWitness>

pub fn block_hash(&self) -> &H256

pub fn confirmations(&self) -> &i32

pub fn block_time(&self) -> &i64

pub fn vmstate(&self) -> &VMState

impl RTransaction

pub fn set_hash(&mut self, val: H256) -> &mut Self

pub fn set_size(&mut self, val: u64) -> &mut Self

pub fn set_version(&mut self, val: u8) -> &mut Self

pub fn set_nonce(&mut self, val: u64) -> &mut Self

pub fn set_sender(&mut self, val: String) -> &mut Self

pub fn set_sys_fee(&mut self, val: String) -> &mut Self

pub fn set_net_fee(&mut self, val: String) -> &mut Self

pub fn set_valid_until_block(&mut self, val: u64) -> &mut Self

pub fn set_signers(&mut self, val: Vec<RTransactionSigner>) -> &mut Self

pub fn set_attributes( &mut self, val: Vec<TransactionAttributeEnum>, ) -> &mut Self

pub fn set_script(&mut self, val: String) -> &mut Self

pub fn set_witnesses(&mut self, val: Vec<NeoWitness>) -> &mut Self

pub fn set_block_hash(&mut self, val: H256) -> &mut Self

pub fn set_confirmations(&mut self, val: i32) -> &mut Self

pub fn set_block_time(&mut self, val: i64) -> &mut Self

pub fn set_vmstate(&mut self, val: VMState) -> &mut Self

impl RTransaction

pub fn new( hash: H256, size: u64, version: u8, nonce: u64, sender: String, sys_fee: String, net_fee: String, valid_until_block: u64, signers: Vec<RTransactionSigner>, attributes: Vec<TransactionAttributeEnum>, script: String, witnesses: Vec<NeoWitness>, ) -> Self

pub fn get_first_signer(&self) -> Result<&RTransactionSigner, TypeError>

pub fn get_signer(&self, index: usize) -> Result<&RTransactionSigner, TypeError>

pub fn get_first_attribute( &self, ) -> Result<&TransactionAttributeEnum, TypeError>

pub fn get_attribute( &self, index: usize, ) -> Result<&TransactionAttributeEnum, TypeError>

Trait Implementations

impl Clone for RTransaction

fn clone(&self) -> RTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RTransaction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RTransaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RTransaction

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

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

const 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 RTransaction

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RTransaction