Struct Input

pub struct Input {
    pub kind: Option<InputKind>,
    pub value: Option<Value>,
    pub object_id: Option<Address>,
    pub version: Option<Version>,
    pub digest: Option<Digest>,
    pub mutable: Option<bool>,
}

A potentially unresolved transaction input. Note that one can construct a fully resolved input using the provided constructors, but this struct is also useful when the input data is not complete.

If used in the context of transaction builder, make sure to call tx.resolve function on the transaction builder to resolve all unresolved inputs.

Fields

kind: Option<InputKind>

value: Option<Value>

object_id: Option<Address>

Unique identifier for this object.

version: Option<Version>

Either the initial_shared_version if object is a shared object, or the version if this is an owned object. The semantics of version can change depending on whether the object is shared or not. For shared objects, this is the initial version the object was shared at. For all other objects, this is the version of the object.

digest: Option<Digest>

The digest of this object. This field is only relevant for owned/immutable/receiving inputs.

mutable: Option<bool>

Whether this object is mutable. This field is only relevant for shared objects.

Implementations

impl Input

pub fn owned(object_id: Address, version: u64, digest: Digest) -> Self

Return an owned kind of object with all required fields.

pub fn immutable(object_id: Address, version: u64, digest: Digest) -> Self

Return an immutable kind of object with all required fields.

pub fn receiving(object_id: Address, version: u64, digest: Digest) -> Self

Return a receiving kind of object with all required fields.

pub fn shared( object_id: Address, initial_shared_version: u64, mutable: bool, ) -> Self

Return a shared object.

• mutable controls whether a command can accept the object by value or mutable reference.
• initial_shared_version is the first version the object was shared at.

pub fn by_id(object_id: Address) -> Self

Return an object with only its unique identifier.

pub fn with_immutable_kind(self) -> Self

Set the object kind to immutable.

pub fn with_owned_kind(self) -> Self

Set the object kind to owned.

pub fn with_receiving_kind(self) -> Self

Set the object kind to receiving.

pub fn with_shared_kind(self) -> Self

Set the object kind to shared.

pub fn with_version(self, version: u64) -> Self

Set the specified version.

pub fn with_digest(self, digest: Digest) -> Self

Set the specified digest.

pub fn with_initial_shared_version(self, initial_version: u64) -> Self

Set the initial shared version.

pub fn by_val(self) -> Self

Make the object shared and set mutable to true when the input is used by value.

pub fn by_ref(self) -> Self

Make the object shared and set mutable to false when the input is used by reference.

pub fn by_mut(self) -> Self

Make the object shared and set mutable to true when the input is used by mutable reference.

Trait Implementations

impl Clone for Input

fn clone(&self) -> Input

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Input

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

Formats the value using the given formatter.

impl Default for Input

fn default() -> Input

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Input

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Object> for Input

fn from(object: &Object) -> Self

Converts to this type from the input type.

impl From<Address> for Input

fn from(object_id: Address) -> Self

Converts to this type from the input type.

impl<'a, T: Serialize> From<Serialized<'a, T>> for Input

fn from(value: Serialized<'a, T>) -> Self

Converts to this type from the input type.

impl PartialEq for Input

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

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

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 Input

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 Input

impl StructuralPartialEq for Input