Struct cryptoapis::models::decode_raw_transaction_hex_risb22::DecodeRawTransactionHexRisb22

pub struct DecodeRawTransactionHexRisb22 {

    pub approximate_fee: Option<String>,
    pub approximate_minimum_required_fee: Option<String>,
    pub gas_limit: String,
    pub gas_paid_for_data: Option<String>,
    pub gas_price: Option<String>,
    pub input_data: Option<String>,
    pub nonce: i32,
    pub r: Option<String>,
    pub recipient: String,
    pub s: Option<String>,
    pub sender: String,
    pub _type: i32,
    pub v: Option<String>,
    pub value: Option<String>,
}

DecodeRawTransactionHexRisb22 : Binance Smart Chain

Fields

approximate_fee: Option<String>

Defines the approximate fee value. When isConfirmed is True - Defines the amount of the transaction fee When isConfirmed is False - For ETH-based blockchains this attribute represents the max fee value.

approximate_minimum_required_fee: Option<String>

Defines the approximate minimum fee that is required for the transaction.

gas_limit: String

Represents the amount of gas used by this specific transaction alone.

gas_paid_for_data: Option<String>

Represents the amount of gas paid for the data in the transaction.

gas_price: Option<String>

Represents the price offered to the miner to purchase this amount of gas.

input_data: Option<String>

Represents additional information that is required for the transaction.

nonce: i32

Represents the sequential running number for an address, starting from 0 for the first transaction. E.g., if the nonce of a transaction is 10, it would be the 11th transaction sent from the sender’s address.

r: Option<String>

Represents output of an ECDSA signature.

recipient: String

The address which receives this transaction. In UTXO-based protocols like Bitcoin there could be several senders while in account-based protocols like Ethereum there is always only one recipient.

s: Option<String>

Represents output of an ECDSA signature.

sender: String

Represents the address which sends this transaction. In UTXO-based protocols like Bitcoin there could be several senders while in account-based protocols like Ethereum there is always only one sender.

_type: i32

Specifies the transaction type as one from three options: if response returns a \"0\" it means the raw transaction includes legacy transaction data, if it is \"1\" - includes access lists for EIP2930, and if it is \"2\" - EIP1559 data.

v: Option<String>

Defines the the recovery id.

value: Option<String>

Represents the sent/received amount.

Implementations

impl DecodeRawTransactionHexRisb22

pub fn new(
    gas_limit: String,
    nonce: i32,
    recipient: String,
    sender: String,
    _type: i32
) -> DecodeRawTransactionHexRisb22

Binance Smart Chain

Trait Implementations

impl Clone for DecodeRawTransactionHexRisb22

fn clone(&self) -> DecodeRawTransactionHexRisb22

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DecodeRawTransactionHexRisb22

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DecodeRawTransactionHexRisb22

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

Deserialize this value from the given Serde deserializer.

impl PartialEq<DecodeRawTransactionHexRisb22> for DecodeRawTransactionHexRisb22

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for DecodeRawTransactionHexRisb22

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DecodeRawTransactionHexRisb22