Enum TransactionFilter 

#[non_exhaustive]
pub enum TransactionFilter {
    Checkpoint(Version),
    MoveFunction {
        package: Address,
        module: Option<String>,
        function: Option<String>,
    },
    InputObject(Address),
    ChangedObject(Address),
    AffectedObject(Address),
    FromAddress(Address),
    ToAddress(Address),
    FromAndToAddress {
        from: Address,
        to: Address,
    },
    FromOrToAddress {
        addr: Address,
    },
    TransactionKind(String),
    TransactionKindIn(Vec<String>),
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Checkpoint(Version)

CURRENTLY NOT SUPPORTED. Query by checkpoint.

MoveFunction

Query by move function.

Fields

package: Address

module: Option<String>

function: Option<String>

InputObject(Address)

Query by input object.

ChangedObject(Address)

Query by changed object, including created, mutated and unwrapped objects.

AffectedObject(Address)

Query for transactions that touch this object.

FromAddress(Address)

Query by sender address.

ToAddress(Address)

Query by recipient address.

FromAndToAddress

Query by sender and recipient address.

Fields

from: Address

to: Address

FromOrToAddress

CURRENTLY NOT SUPPORTED. Query txs that have a given address as sender or recipient.

Fields

addr: Address

TransactionKind(String)

Query by transaction kind

TransactionKindIn(Vec<String>)

Query transactions of any given kind in the input.

Trait Implementations

impl Clone for TransactionFilter

fn clone(&self) -> TransactionFilter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionFilter

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TransactionFilter

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TransactionFilter

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

where __S: Serializer,

Serialize this value into the given Serde serializer.