Struct exonum::explorer::CommittedTransaction

pub struct CommittedTransaction<T = Box<dyn Transaction>> { /* fields omitted */ }

Information about a particular transaction in the blockchain.

The type parameter corresponds to some representation of Box<Transaction>. This generalization is needed to deserialize CommittedTransactions.

JSON presentation

Name	Equivalent type	Description
content	Box<Transaction>	Transaction as recorded in the blockchain
location	TxLocation	Location of the transaction in the block
location_proof	ListProof<Hash>	Proof of transaction inclusion into a block
status	(custom; see below)	Execution status

status field

The status field is a more readable version of the TransactionResult type.

For successfully executed transactions, status is equal to

{ "type": "success" }

For transactions that return an ExecutionError, status contains the error code and an optional description, i.e., has the following type in the Flow / TypeScript notation:

{ type: 'error', code: number, description?: string }

For transactions that have resulted in a panic, status contains an optional description as well:

{ type: 'panic', description?: string }

Examples

Use of the custom type parameter for deserialization:

transactions! {
    Transactions {
        const SERVICE_ID = 1000;

        struct CreateWallet {
            public_key: &PublicKey,
            name: &str,
        }
        // other transaction types...
    }
}

let json = json!({
    "content": {
        "protocol_version": 0,
        "service_id": 1000,
        "message_id": 0,
        "body": {
            "public_key": // ...
            "name": "Alice"
        },
        "signature": // ...
    },
    "location": { "block_height": "1", "position_in_block": "0" },
    "location_proof": // ...
    "status": { "type": "success" }
});

let parsed: CommittedTransaction<CreateWallet> =
    serde_json::from_value(json).unwrap();
assert_eq!(parsed.location().block_height(), Height(1));
assert_eq!(parsed.content().name(), "Alice");

Methods

impl<T> CommittedTransaction<T>

pub fn content(&self) -> &T

Returns the content of the transaction.

pub fn location(&self) -> &TxLocation

Returns the transaction location in block.

pub fn location_proof(&self) -> &ListProof<Hash>

Returns a proof that transaction is recorded in the blockchain.

pub fn status(&self) -> Result<(), &TransactionError>

Returns the status of the transaction execution.

Trait Implementations

impl<T: Debug> Debug for CommittedTransaction<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for CommittedTransaction<T> where     T: Deserialize<'de>,

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

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for CommittedTransaction<T> where     T: SerializeContent,

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

Serialize this value into the given Serde serializer.