Skip to main content

Module iota::ptb_command

use iota::address;
use iota::hex;
use iota::object;
use iota::tx_context;
use std::address;
use std::ascii;
use std::bcs;
use std::option;
use std::string;
use std::type_name;
use std::vector;

Structs​

struct ProgrammableMoveCall​

public struct ProgrammableMoveCall has copy, drop
Fields

pub arguments​

public fun arguments(call: &iota::ptb_command::ProgrammableMoveCall): &vector<iota::ptb_command::Argument>
Implementation
public fun arguments(call: &ProgrammableMoveCall): &vector<Argument> {
    &call.arguments
}

pub function​

public fun function(call: &iota::ptb_command::ProgrammableMoveCall): &std::ascii::String
Implementation
public fun function(call: &ProgrammableMoveCall): &String {
    &call.function
}

pub module_name​

public fun module_name(call: &iota::ptb_command::ProgrammableMoveCall): &std::ascii::String
Implementation
public fun module_name(call: &ProgrammableMoveCall): &String {
    &call.module_name
}

pub package​

public fun package(call: &iota::ptb_command::ProgrammableMoveCall): &iota::object::ID
Implementation
public fun package(call: &ProgrammableMoveCall): &ID {
    &call.package
}

pub type_arguments​

public fun type_arguments(call: &iota::ptb_command::ProgrammableMoveCall): &vector<std::type_name::TypeName>
Implementation
public fun type_arguments(call: &ProgrammableMoveCall): &vector {
    &call.type_arguments
}

struct TransferObjectsData​

public struct TransferObjectsData has copy, drop
Fields

pub objects​

public fun objects(data: &iota::ptb_command::TransferObjectsData): &vector<iota::ptb_command::Argument>
Implementation
public fun objects(data: &TransferObjectsData): &vector<Argument> {
    &data.objects
}

pub recipient​

public fun recipient(data: &iota::ptb_command::TransferObjectsData): &iota::ptb_command::Argument
Implementation
public fun recipient(data: &TransferObjectsData): &Argument {
    &data.recipient
}

struct SplitCoinsData​

public struct SplitCoinsData has copy, drop
Fields

pub amounts​

public fun amounts(data: &iota::ptb_command::SplitCoinsData): &vector<iota::ptb_command::Argument>
Implementation
public fun amounts(data: &SplitCoinsData): &vector<Argument> {
    &data.amounts
}

pub coin​

public fun coin(data: &iota::ptb_command::SplitCoinsData): &iota::ptb_command::Argument
Implementation
public fun coin(data: &SplitCoinsData): &Argument {
    &data.coin
}

struct MergeCoinsData​

public struct MergeCoinsData has copy, drop
Fields

pub source_coins​

public fun source_coins(data: &iota::ptb_command::MergeCoinsData): &vector<iota::ptb_command::Argument>
Implementation
public fun source_coins(data: &MergeCoinsData): &vector<Argument> {
    &data.source_coins
}

pub target_coin​

public fun target_coin(data: &iota::ptb_command::MergeCoinsData): &iota::ptb_command::Argument
Implementation
public fun target_coin(data: &MergeCoinsData): &Argument {
    &data.target_coin
}

struct PublishData​

public struct PublishData has copy, drop
Fields
modules: vector<vector<u8>>
dependencies: vector<iota::object::ID>

pub dependencies​

public fun dependencies(data: &iota::ptb_command::PublishData): &vector<iota::object::ID>
Implementation
public fun dependencies(data: &PublishData): &vector {
    &data.dependencies
}

pub modules​

public fun modules(data: &iota::ptb_command::PublishData): &vector>
Implementation
public fun modules(data: &PublishData): &vector> {
    &data.modules
}

struct MakeMoveVecData​

public struct MakeMoveVecData has copy, drop
Fields

pub elements​

public fun elements(data: &iota::ptb_command::MakeMoveVecData): &vector<iota::ptb_command::Argument>
Implementation
public fun elements(data: &MakeMoveVecData): &vector<Argument> {
    &data.elements
}

pub type_arg​

public fun type_arg(data: &iota::ptb_command::MakeMoveVecData): &std::option::Option<std::type_name::TypeName>
Implementation
public fun type_arg(data: &MakeMoveVecData): &Option {
    &data.type_arg
}

struct UpgradeData​

public struct UpgradeData has copy, drop
Fields

pub upgrade_dependencies​

public fun upgrade_dependencies(data: &iota::ptb_command::UpgradeData): &vector<iota::object::ID>
Implementation
public fun upgrade_dependencies(data: &UpgradeData): &vector {
    &data.dependencies
}

pub upgrade_modules​

public fun upgrade_modules(data: &iota::ptb_command::UpgradeData): &vector>
Implementation
public fun upgrade_modules(data: &UpgradeData): &vector> {
    &data.modules
}

pub upgrade_package​

public fun upgrade_package(data: &iota::ptb_command::UpgradeData): &iota::object::ID
Implementation
public fun upgrade_package(data: &UpgradeData): &ID {
    &data.package
}

pub upgrade_ticket​

public fun upgrade_ticket(data: &iota::ptb_command::UpgradeData): &iota::ptb_command::Argument
Implementation
public fun upgrade_ticket(data: &UpgradeData): &Argument {
    &data.upgrade_ticket
}

Enums​

enum Command​

public enum Command has copy, drop
Variants

pub as_make_move_vec​

public fun as_make_move_vec(command: &iota::ptb_command::Command): std::option::Option<iota::ptb_command::MakeMoveVecData>
Implementation
public fun as_make_move_vec(command: &Command): Option<MakeMoveVecData> {
    match (command) {
        Command::MakeMoveVec(data) => some(*data),
        _ => none(),
    }
}

pub as_merge_coins​

public fun as_merge_coins(command: &iota::ptb_command::Command): std::option::Option<iota::ptb_command::MergeCoinsData>
Implementation
public fun as_merge_coins(command: &Command): Option<MergeCoinsData> {
    match (command) {
        Command::MergeCoins(data) => some(*data),
        _ => none(),
    }
}

pub as_move_call​

public fun as_move_call(command: &iota::ptb_command::Command): std::option::Option<iota::ptb_command::ProgrammableMoveCall>
Implementation
public fun as_move_call(command: &Command): Option<ProgrammableMoveCall> {
    match (command) {
        Command::MoveCall(call) => some(*call),
        _ => none(),
    }
}

pub as_publish​

public fun as_publish(command: &iota::ptb_command::Command): std::option::Option<iota::ptb_command::PublishData>
Implementation
public fun as_publish(command: &Command): Option<PublishData> {
    match (command) {
        Command::Publish(data) => some(*data),
        _ => none(),
    }
}

pub as_split_coins​

public fun as_split_coins(command: &iota::ptb_command::Command): std::option::Option<iota::ptb_command::SplitCoinsData>
Implementation
public fun as_split_coins(command: &Command): Option<SplitCoinsData> {
    match (command) {
        Command::SplitCoins(data) => some(*data),
        _ => none(),
    }
}

pub as_transfer_objects​

public fun as_transfer_objects(command: &iota::ptb_command::Command): std::option::Option<iota::ptb_command::TransferObjectsData>
Implementation
public fun as_transfer_objects(command: &Command): Option<TransferObjectsData> {
    match (command) {
        Command::TransferObjects(data) => some(*data),
        _ => none(),
    }
}

pub as_upgrade​

public fun as_upgrade(command: &iota::ptb_command::Command): std::option::Option<iota::ptb_command::UpgradeData>
Implementation
public fun as_upgrade(command: &Command): Option<UpgradeData> {
    match (command) {
        Command::Upgrade(data) => some(*data),
        _ => none(),
    }
}

pub is_make_move_vec​

public fun is_make_move_vec(command: &iota::ptb_command::Command): bool
Implementation
public fun is_make_move_vec(command: &Command): bool {
    match (command) {
        Command::MakeMoveVec() => true,
         => false,
    }
}

pub is_merge_coins​

public fun is_merge_coins(command: &iota::ptb_command::Command): bool
Implementation
public fun is_merge_coins(command: &Command): bool {
    match (command) {
        Command::MergeCoins() => true,
         => false,
    }
}

pub is_move_call​

public fun is_move_call(command: &iota::ptb_command::Command): bool
Implementation
public fun is_move_call(command: &Command): bool {
    match (command) {
        Command::MoveCall() => true,
         => false,
    }
}

pub is_publish​

public fun is_publish(command: &iota::ptb_command::Command): bool
Implementation
public fun is_publish(command: &Command): bool {
    match (command) {
        Command::Publish() => true,
         => false,
    }
}

pub is_split_coins​

public fun is_split_coins(command: &iota::ptb_command::Command): bool
Implementation
public fun is_split_coins(command: &Command): bool {
    match (command) {
        Command::SplitCoins() => true,
         => false,
    }
}

pub is_transfer_objects​

public fun is_transfer_objects(command: &iota::ptb_command::Command): bool
Implementation
public fun is_transfer_objects(command: &Command): bool {
    match (command) {
        Command::TransferObjects() => true,
         => false,
    }
}

pub is_upgrade​

public fun is_upgrade(command: &iota::ptb_command::Command): bool
Implementation
public fun is_upgrade(command: &Command): bool {
    match (command) {
        Command::Upgrade() => true,
         => false,
    }
}

enum Argument​

public enum Argument has copy, drop
Variants

Variant GasCoin

Variant Input

0: u16

Variant Result

0: u16

Variant NestedResult

0: u16
1: u16

pub input_index​

public fun input_index(arg: &iota::ptb_command::Argument): std::option::Option<u16>
Implementation
public fun input_index(arg: &Argument): Option<u16> {
    match (arg) {
        Argument::Input(index) => some(*index),
        _ => none(),
    }
}

pub is_gas_coin​

public fun is_gas_coin(arg: &iota::ptb_command::Argument): bool
Implementation
public fun is_gas_coin(arg: &Argument): bool {
    match (arg) {
        Argument::GasCoin => true,
        _ => false,
    }
}

pub is_input​

public fun is_input(arg: &iota::ptb_command::Argument): bool
Implementation
public fun is_input(arg: &Argument): bool {
    match (arg) {
        Argument::Input() => true,
         => false,
    }
}

pub is_nested_result​

public fun is_nested_result(arg: &iota::ptb_command::Argument): bool
Implementation
public fun is_nested_result(arg: &Argument): bool {
    match (arg) {
        Argument::NestedResult(_, ) => true,
         => false,
    }
}

pub is_result​

public fun is_result(arg: &iota::ptb_command::Argument): bool
Implementation
public fun is_result(arg: &Argument): bool {
    match (arg) {
        Argument::Result() => true,
         => false,
    }
}

pub nested_result_command_index​

public fun nested_result_command_index(arg: &iota::ptb_command::Argument): std::option::Option<u16>
Implementation
public fun nested_result_command_index(arg: &Argument): Option<u16> {
    match (arg) {
        Argument::NestedResult(command_index, ) => some(*command_index),
         => none(),
    }
}

pub nested_result_inner_index​

public fun nested_result_inner_index(arg: &iota::ptb_command::Argument): std::option::Option<u16>
Implementation
public fun nested_result_inner_index(arg: &Argument): Option<u16> {
    match (arg) {
        Argument::NestedResult(, inner_index) => some(*inner_index),
         => none(),
    }
}

pub result_command_index​

public fun result_command_index(arg: &iota::ptb_command::Argument): std::option::Option<u16>
Implementation
public fun result_command_index(arg: &Argument): Option<u16> {
    match (arg) {
        Argument::Result(command_index) => some(*command_index),
        _ => none(),
    }
}