Struct CorrectRecord 

pub struct CorrectRecord {
    pub trail_id: ObjectId,
    pub owner: Address,
    pub sequence_number: u64,
    pub data: Data,
    pub metadata: Option<String>,
    pub tag: Option<String>,
    pub selected_capability_id: Option<ObjectId>,
    /* private fields */
}

Transaction that appends a correction record to a trail.

The original record remains immutable. The correction is appended at the trail’s next sequence number with a correction tracker whose replaces set contains the corrected sequence number, and the corrected record receives a back-pointer to the new correction.

Requires the CorrectRecord permission. Tagged corrections require the correction tag to exist in the trail registry and the capability’s role to allow both the replaced record’s tag, when present, and the correction tag, when present. The Move call aborts when the trail package version is incompatible, the capability is invalid, the trail is write-locked, the target record does not exist, the target record was already replaced, or tag authorization fails. On success the correction is stored at the trail’s current monotonic sequence number and a RecordAdded event is emitted.

Fields

trail_id: ObjectId

Trail object ID that will receive the correction.

owner: Address

Address authorizing the correction.

sequence_number: u64

Sequence number of the record being corrected.

data: Data

Correction payload to append.

metadata: Option<String>

Optional application-defined metadata.

tag: Option<String>

Optional trail-owned tag to attach to the correction record.

selected_capability_id: Option<ObjectId>

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

Implementations

impl CorrectRecord

pub fn new( trail_id: ObjectId, owner: Address, sequence_number: u64, data: Data, metadata: Option<String>, tag: Option<String>, selected_capability_id: Option<ObjectId>, ) -> Self

Creates a CorrectRecord transaction builder payload.

The resulting transaction appends a correction record for sequence_number and carries the same authorization, write-lock, record-existence, already-replaced, tag-definition, and tag-authorization requirements as the Move correct_record entry point.

Trait Implementations

impl Clone for CorrectRecord

fn clone(&self) -> CorrectRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CorrectRecord

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

Formats the value using the given formatter.

impl Transaction for CorrectRecord

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, effects: &'life0 mut IotaTransactionBlockEffects, client: &'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.