Struct DeleteRecord 

pub struct DeleteRecord {
    pub trail_id: ObjectID,
    pub owner: IotaAddress,
    pub sequence_number: u64,
    pub selected_capability_id: Option<ObjectID>,
    /* private fields */
}

Transaction that deletes a single record.

Requires the DeleteRecord permission. The Move package aborts with ERecordNotFound when no record exists at sequence_number and with ERecordLocked while the configured delete-record window still protects the record. Tag-aware authorization additionally applies: if the record carries a tag, the supplied capability’s role must allow that tag.

On success a RecordDeleted event is emitted.

Fields

trail_id: ObjectID

Trail object ID containing the record.

owner: IotaAddress

Address authorizing the deletion.

sequence_number: u64

Sequence number of the record to delete.

selected_capability_id: Option<ObjectID>

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

Implementations

impl DeleteRecord

pub fn new( trail_id: ObjectID, owner: IotaAddress, sequence_number: u64, selected_capability_id: Option<ObjectID>, ) -> Self

Creates a DeleteRecord transaction builder payload.

Trait Implementations

impl Clone for DeleteRecord

fn clone(&self) -> DeleteRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeleteRecord

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

Formats the value using the given formatter.

impl Transaction for DeleteRecord

type Error = Error

Error type for this transaction.

type Output = RecordDeleted

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.