Struct diem_types::transaction::RawTransaction

pub struct RawTransaction { /* fields omitted */ }

RawTransaction is the portion of a transaction that a client signs.

Implementations

impl RawTransaction

pub fn new(
    sender: AccountAddress,
    sequence_number: u64,
    payload: TransactionPayload,
    max_gas_amount: u64,
    gas_unit_price: u64,
    gas_currency_code: String,
    expiration_timestamp_secs: u64,
    chain_id: ChainId
) -> Self

Create a new RawTransaction with a payload.

It can be either to publish a module, to execute a script, or to issue a writeset transaction.

pub fn new_script(
    sender: AccountAddress,
    sequence_number: u64,
    script: Script,
    max_gas_amount: u64,
    gas_unit_price: u64,
    gas_currency_code: String,
    expiration_timestamp_secs: u64,
    chain_id: ChainId
) -> Self

Create a new RawTransaction with a script.

A script transaction contains only code to execute. No publishing is allowed in scripts.

pub fn new_script_function(
    sender: AccountAddress,
    sequence_number: u64,
    script_function: ScriptFunction,
    max_gas_amount: u64,
    gas_unit_price: u64,
    gas_currency_code: String,
    expiration_timestamp_secs: u64,
    chain_id: ChainId
) -> Self

Create a new RawTransaction with a script function.

A script transaction contains only code to execute. No publishing is allowed in scripts.

pub fn new_module(
    sender: AccountAddress,
    sequence_number: u64,
    module: Module,
    max_gas_amount: u64,
    gas_unit_price: u64,
    gas_currency_code: String,
    expiration_timestamp_secs: u64,
    chain_id: ChainId
) -> Self

Create a new RawTransaction with a module to publish.

A module transaction is the only way to publish code. Only one module per transaction can be published.

pub fn new_module_bundle(
    sender: AccountAddress,
    sequence_number: u64,
    modules: ModuleBundle,
    max_gas_amount: u64,
    gas_unit_price: u64,
    gas_currency_code: String,
    expiration_timestamp_secs: u64,
    chain_id: ChainId
) -> Self

Create a new RawTransaction with a list of modules to publish.

A module transaction is the only way to publish code. Multiple modules per transaction can be published.

pub fn new_write_set(
    sender: AccountAddress,
    sequence_number: u64,
    write_set: WriteSet,
    chain_id: ChainId
) -> Self

pub fn new_change_set(
    sender: AccountAddress,
    sequence_number: u64,
    change_set: ChangeSet,
    chain_id: ChainId
) -> Self

pub fn new_writeset_script(
    sender: AccountAddress,
    sequence_number: u64,
    script: Script,
    signer: AccountAddress,
    chain_id: ChainId
) -> Self

pub fn sign(
    self,
    private_key: &Ed25519PrivateKey,
    public_key: Ed25519PublicKey
) -> Result<SignatureCheckedTransaction>

Signs the given RawTransaction. Note that this consumes the RawTransaction and turns it into a SignatureCheckedTransaction.

For a transaction that has just been signed, its signature is expected to be valid.

pub fn sign_multi_agent(
    self,
    sender_private_key: &Ed25519PrivateKey,
    secondary_signers: Vec<AccountAddress>,
    secondary_private_keys: Vec<&Ed25519PrivateKey>
) -> Result<SignatureCheckedTransaction>

Signs the given multi-agent RawTransaction, which is a transaction with secondary signers in addition to a sender. The private keys of the sender and the secondary signers are used to sign the transaction.

The order and length of the secondary keys provided here have to match the order and length of the secondary_signers.

pub fn multi_sign_for_testing(
    self,
    private_key: &Ed25519PrivateKey,
    public_key: Ed25519PublicKey
) -> Result<SignatureCheckedTransaction>

pub fn into_payload(self) -> TransactionPayload

pub fn format_for_client(
    &self,
    get_transaction_name: impl Fn(&[u8]) -> String
) -> String

pub fn sender(&self) -> AccountAddress

Return the sender of this transaction.

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

Return the signing message for creating transaction signature.

Trait Implementations

impl Arbitrary for RawTransaction

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

fn arbitrary_with(_args: ()) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

type Strategy = BoxedStrategy<Self>

The type of Strategy used to generate values of type Self.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for RawTransaction

fn clone(&self) -> RawTransaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CryptoHash for RawTransaction

type Hasher = RawTransactionHasher

The associated Hasher type which comes with a unique salt for this type.

fn hash(&self) -> HashValue

Hashes the object and produces a HashValue.

impl Debug for RawTransaction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RawTransaction

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

Deserialize this value from the given Serde deserializer.

impl Hash for RawTransaction

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, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<RawTransaction> for RawTransaction

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

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

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

This method tests for !=.

impl Serialize for RawTransaction

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 RawTransaction

impl StructuralEq for RawTransaction

impl StructuralPartialEq for RawTransaction