Struct AddRecord 

pub struct AddRecord {
    pub trail_id: ObjectID,
    pub owner: IotaAddress,
    pub data: Data,
    pub metadata: Option<String>,
    pub tag: Option<String>,
    pub selected_capability_id: Option<ObjectID>,
    /* private fields */
}

Transaction that appends a record to a trail.

Requires the AddRecord permission. Tagged writes additionally require the tag to exist in the trail registry and a capability whose role explicitly allows that tag; otherwise the Move package aborts with ERecordTagNotDefined or ERecordTagNotAllowed. The package also aborts with ETrailWriteLocked while the configured write_lock is active. On success the new record is stored at the trail’s current monotonic sequence number (which never decrements, even after deletions) and a RecordAdded event is emitted.

Fields

trail_id: ObjectID

Trail object ID that will receive the record.

owner: IotaAddress

Address authorizing the write.

data: Data

Record payload to append.

metadata: Option<String>

Optional application-defined metadata.

tag: Option<String>

Optional trail-owned tag to attach to the record.

selected_capability_id: Option<ObjectID>

Explicit capability to use instead of auto-selecting one from the owner’s wallet.

Implementations

impl AddRecord

pub fn new( trail_id: ObjectID, owner: IotaAddress, data: Data, metadata: Option<String>, tag: Option<String>, selected_capability_id: Option<ObjectID>, ) -> Self

Creates an AddRecord transaction builder payload.

Trait Implementations

impl Clone for AddRecord

fn clone(&self) -> AddRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AddRecord

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

Formats the value using the given formatter.

impl Transaction for AddRecord

type Error = Error

Error type for this transaction.

type Output = RecordAdded

Output type for this transaction.

fn build_programmable_transaction<'life0, 'life1, 'async_trait, C>( &'life0 self, client: &'life1 C, ) -> Pin<Box<dyn Future<Output = Result<ProgrammableTransaction, Self::Error>> + Send + 'async_trait>>

where C: CoreClientReadOnly + OptionalSync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Encode this operation into a [ProgrammableTransaction].

fn apply_with_events<'life0, 'life1, 'life2, 'async_trait, C>( self, _: &'life0 mut IotaTransactionBlockEffects, events: &'life1 mut IotaTransactionBlockEvents, _: &'life2 C, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>

where C: CoreClientReadOnly + OptionalSync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Parses a transaction result in order to compute its effects and optionally use events.

fn apply<'life0, 'life1, 'async_trait, C>( self, _: &'life0 mut IotaTransactionBlockEffects, _: &'life1 C, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>

where C: CoreClientReadOnly + OptionalSync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Parses a transaction result in order to compute its effects.