Skip to main content

Module iota_system::validator_wrapper

use iota::address;
use iota::bag;
use iota::balance;
use iota::coin;
use iota::config;
use iota::deny_list;
use iota::dynamic_field;
use iota::dynamic_object_field;
use iota::event;
use iota::hex;
use iota::iota;
use iota::object;
use iota::table;
use iota::transfer;
use iota::tx_context;
use iota::types;
use iota::url;
use iota::versioned;
use iota_system::staking_pool;
use iota_system::validator;
use iota_system::validator_cap;
use std::address;
use std::ascii;
use std::bcs;
use std::option;
use std::string;
use std::type_name;
use std::u64;
use std::vector;

Module Functions​

pub(pkg) create_v1​

public(package) fun create_v1(validator: iota_system::validator::ValidatorV1, ctx: &mut iota::tx_context::TxContext): iota_system::validator_wrapper::Validator
Implementation
public(package) fun create_v1(validator: ValidatorV1, ctx: &mut TxContext): Validator {
    Validator {
        inner: versioned::create(1, validator, ctx),
    }
}

Structs​

struct Validator​

public struct Validator has store
Fields

pub(pkg) destroy​

Destroy the wrapper and retrieve the inner validator object.

public(package) fun destroy(self: iota_system::validator_wrapper::Validator): iota_system::validator::ValidatorV1
Implementation
public(package) fun destroy(self: Validator): ValidatorV1 {
    upgrade_to_latest(&self);
    let Validator { inner } = self;
    versioned::destroy(inner)
}

pub(pkg) load_validator_maybe_upgrade​

This function should always return the latest supported version. If the inner version is old, we upgrade it lazily in-place.

public(package) fun load_validator_maybe_upgrade(self: &mut iota_system::validator_wrapper::Validator): &mut iota_system::validator::ValidatorV1
Implementation
public(package) fun load_validator_maybe_upgrade(self: &mut Validator): &mut ValidatorV1 {
    upgrade_to_latest(self);
    versioned::load_value_mut(&mut self.inner)
}

prv upgrade_to_latest​

fun upgrade_to_latest(self: &iota_system::validator_wrapper::Validator)
Implementation
fun upgrade_to_latest(self: &Validator) {
    let version = version(self);
    // TODO: When new versions are added, we need to explicitly upgrade here.
    assert!(version == 1, EInvalidVersion);
}

prv version​

fun version(self: &iota_system::validator_wrapper::Validator): u64
Implementation
fun version(self: &Validator): u64 {
    versioned::version(&self.inner)
}

Constants​

err EInvalidVersion​

const EInvalidVersion: u64 = 0;