Struct DeleteRecordsBatch 

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

Transaction that deletes multiple records in a batch operation.

Requires the DeleteAllRecords permission. The Move entry point walks the trail from the front, silently skips records still inside the delete-record window or outside the capability’s allowed tag set, and deletes up to limit eligible records in trail order.

On success a RecordDeleted event is emitted per deletion.

limit caps the number of records actually deleted, not the number of records inspected. Ineligible records at the front of the trail are silently walked past without counting toward limit, so more than limit records may be visited before limit deletions accumulate.

Lock state — both count-based and time-based — is evaluated against the trail snapshot and clock timestamp captured at the start of the call, so the deletable set is stable for the batch’s duration. The Rust implementation mirrors the Move output by collecting the matching RecordDeleted events in deletion order; the returned vector may be shorter than limit (or empty) and that is not an error.

Fields

trail_id: ObjectID

Trail object ID containing the records.

owner: IotaAddress

Address authorizing the deletion.

limit: u64

Maximum number of records to delete in this batch.

selected_capability_id: Option<ObjectID>

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

Implementations

impl DeleteRecordsBatch

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

Creates a DeleteRecordsBatch transaction builder payload.

Trait Implementations

impl Clone for DeleteRecordsBatch

fn clone(&self) -> DeleteRecordsBatch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeleteRecordsBatch

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

Formats the value using the given formatter.

impl Transaction for DeleteRecordsBatch

type Error = Error

Error type for this transaction.

type Output = Vec<u64>

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.