Ksui/xyz.mcxross.ksui.generated.type

Package-level declarations

Types

AccumulatorRootCreateTransaction

class AccumulatorRootCreateTransaction

Address

class Address

The 32-byte address that is an account address (corresponding to a public key).

AddressOwner

class AddressOwner

An address-owned object is owned by a specific 32-byte address that is either an account address (derived from a particular signature scheme) or an object ID. An address-owned object is accessible only to its owner and no others.

AuthenticatorStateCreateTransaction

class AuthenticatorStateCreateTransaction

System transaction for creating the on-chain state used by zkLogin.

AuthenticatorStateExpireTransaction

class AuthenticatorStateExpireTransaction

AuthenticatorStateUpdateTransaction

class AuthenticatorStateUpdateTransaction

System transaction for updating the on-chain state used by zkLogin.

Balance

class Balance

The total balance for a particular coin type.

BalanceChange

class BalanceChange

Effects to the balance (sum of coin values per coin type) owned by an address or object.

BalanceChangeConnection

class BalanceChangeConnection

BalanceConnection

class BalanceConnection

Base64

class Base64

String containing Base64-encoded binary data.

BigInt

class BigInt

String representation of an arbitrary width, possibly signed integer.

BridgeCommitteeInitTransaction

class BridgeCommitteeInitTransaction

BridgeStateCreateTransaction

class BridgeStateCreateTransaction

ChangeEpochTransaction

class ChangeEpochTransaction

A system transaction that updates epoch information on-chain (increments the current epoch). Executed by the system once per epoch, without using gas. Epoch change transactions cannot be submitted by users, because validators will refuse to sign them.

Checkpoint

class Checkpoint

Checkpoints contain finalized transactions and are used for node synchronization and global transaction ordering.

CheckpointConnection

class CheckpointConnection

CheckpointId

data class CheckpointId(val digest: Optional<String?> = Optional.Absent, val sequenceNumber: Optional<Any?> = Optional.Absent)

Filter either by the digest, or the sequence number, or neither, to get the latest checkpoint.

Coin

class Coin

Some 0x2::coin::Coin Move object.

CoinConnection

class CoinConnection

CoinDenyListStateCreateTransaction

class CoinDenyListStateCreateTransaction

CoinMetadata

class CoinMetadata

The metadata for a coin type.

ConsensusAddressOwner

class ConsensusAddressOwner

Same as AddressOwner, but the object is versioned by consensus.

ConsensusCommitPrologueTransaction

class ConsensusCommitPrologueTransaction

System transaction that runs at the beginning of a checkpoint, and is responsible for setting the current value of the clock, based on the timestamp from consensus.

DateTime

class DateTime

ISO-8601 Date and Time: RFC3339 in UTC with format: YYYY-MM-DDTHH:MM:SS.mmmZ. Note that the milliseconds part is optional, and it may be omitted if its value is 0.

DisplayEntry

class DisplayEntry

The set of named templates defined on-chain for the type of this object, to be handled off-chain. The server substitutes data from the object into these templates to generate a display string per template.

class DryRunEffect

class DryRunMutation

class DryRunResult

class DryRunReturn

class DynamicField

Dynamic fields are heterogeneous fields that can be added or removed at runtime, and can have arbitrary user-assigned names. There are two sub-types of dynamic fields:

DynamicFieldConnection

class DynamicFieldConnection

DynamicFieldName

data class DynamicFieldName(val type: String, val bcs: Any)

DynamicFieldValue

class DynamicFieldValue

EndOfEpochTransaction

class EndOfEpochTransaction

System transaction that supersedes ChangeEpochTransaction as the new way to run transactions at the end of an epoch. Behaves similarly to ChangeEpochTransaction but can accommodate other optional transactions to run at the end of the epoch.

EndOfEpochTransactionKind

class EndOfEpochTransactionKind

EndOfEpochTransactionKindConnection

class EndOfEpochTransactionKindConnection

Epoch

class Epoch

Operation of the Sui network is temporally partitioned into non-overlapping epochs, and the network aims to keep epochs roughly the same duration as each other. During a particular epoch the following data is fixed:

Event

class Event

EventConnection

class EventConnection

EventFilter

data class EventFilter(val sender: Optional<Any?> = Optional.Absent, val transactionDigest: Optional<String?> = Optional.Absent, val emittingModule: Optional<String?> = Optional.Absent, val eventType: Optional<String?> = Optional.Absent)

ExecutionResult

class ExecutionResult

The result of an execution, including errors that occurred during said execution.

GasCoin

class GasCoin

Access to the gas inputs, after they have been smashed into one coin. The gas coin can only be used by reference, except for with TransferObjectsTransaction that can accept it by value.

GasCostSummary

class GasCostSummary

Breakdown of gas costs in effects.

GenesisTransaction

class GenesisTransaction

System transaction that initializes the network and writes the initial set of objects on-chain.

GraphQLBoolean

class GraphQLBoolean

The Boolean scalar type represents true or false.

GraphQLFloat

class GraphQLFloat

The Float scalar type represents signed double-precision fractional values as specified by IEEE 754.

GraphQLID

class GraphQLID

The ID scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as "4") or integer (such as 4) input value will be accepted as an ID.

GraphQLInt

class GraphQLInt

The Int scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.

GraphQLString

class GraphQLString

The String scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.

Immutable

class Immutable

An immutable object is an object that can't be mutated, transferred, or deleted. Immutable objects have no owner, so anyone can use them.

IMoveDatatype

class IMoveDatatype

Interface implemented by all GraphQL types that represent a Move datatype (either structs or enums). This interface is used to provide a way to access fields that are shared by both structs and enums, e.g., the module that the datatype belongs to, the name of the datatype, type parameters etc.

IMoveObject

class IMoveObject

This interface is implemented by types that represent a Move object on-chain (A Move value whose type has key).

Input

class Input

One of the input objects or primitive values to the programmable transaction block.

IObject

class IObject

Interface implemented by on-chain values that are addressable by an ID (also referred to as its address). This includes Move objects and packages.

IOwner

class IOwner

Interface implemented by GraphQL types representing entities that can own objects. Object owners are identified by an address which can represent either the public key of an account or another object. The same address can only refer to an account or an object, never both, but it is not possible to know which up-front.

JSON

class JSON

Arbitrary JSON data.

MoveAbility

enum MoveAbility : Enum<MoveAbility>

Abilities are keywords in Sui Move that define how types behave at the compiler level.

MoveData

class MoveData

The contents of a Move Value, corresponding to the following recursive type:

MoveEnum

class MoveEnum

Description of an enum type, defined in a Move module.

MoveEnumConnection

class MoveEnumConnection

MoveEnumVariant

class MoveEnumVariant

MoveField

class MoveField

Information for a particular field on a Move struct.

MoveFunction

class MoveFunction

Signature of a function, defined in a Move module.

MoveFunctionConnection

class MoveFunctionConnection

MoveFunctionTypeParameter

class MoveFunctionTypeParameter

MoveModule

class MoveModule

Represents a module in Move, a library that defines struct types and functions that operate on these types.

MoveModuleConnection

class MoveModuleConnection

MoveObject

class MoveObject

The representation of an object as a Move Object, which exposes additional information (content, module that governs it, version, is transferrable, etc.) about this object.

MoveObjectConnection

class MoveObjectConnection

MovePackage

class MovePackage

A MovePackage is a kind of Move object that represents code that has been published on chain. It exposes information about its modules, type definitions, functions, and dependencies.

MoveStruct

class MoveStruct

Description of a struct type, defined in a Move module.

MoveStructConnection

class MoveStructConnection

MoveStructTypeParameter

class MoveStructTypeParameter

MoveType

class MoveType

Represents concrete types (no type parameters, no references).

MoveTypeLayout

class MoveTypeLayout

The shape of a concrete Move Type (a type with all its type parameters instantiated with concrete types), corresponding to the following recursive type:

MoveTypeSignature

class MoveTypeSignature

The signature of a concrete Move Type (a type with all its type parameters instantiated with concrete types, that contains no references), corresponding to the following recursive type:

MoveValue

class MoveValue

MoveVisibility

enum MoveVisibility : Enum<MoveVisibility>

The visibility modifier describes which modules can access this module member. By default, a module member can be called only within the same module.

Mutation

class Mutation

Mutations are used to write to the Sui network.

Object

class Object

An object in Sui is a package (set of Move bytecode modules) or object (typed data structure with fields) with additional metadata detailing its id, version, transaction digest, owner field indicating how this object can be accessed.

ObjectChange

class ObjectChange

Effect on an individual Object (keyed by its ID).

ObjectChangeConnection

class ObjectChangeConnection

ObjectConnection

class ObjectConnection

ObjectFilter

data class ObjectFilter(val type: Optional<String?> = Optional.Absent, val owner: Optional<Any?> = Optional.Absent, val objectIds: Optional<List<Any>?> = Optional.Absent)

Constrains the set of objects returned. All filters are optional, and the resulting set of objects are ones whose

ObjectOwner

class ObjectOwner

The object's owner type: Immutable, Shared, Parent, Address, or ConsensusAddress.

ObjectRef

data class ObjectRef(val address: Any, val version: Any, val digest: String)

OpenMoveType

class OpenMoveType

Represents types that could contain references or free type parameters. Such types can appear as function parameters, in fields of structs, or as actual type parameter.

OpenMoveTypeSignature

class OpenMoveTypeSignature

The shape of an abstract Move Type (a type that can contain free type parameters, and can optionally be taken by reference), corresponding to the following recursive type:

Owner

class Owner

An Owner is an entity that can own an object. Each Owner is identified by a SuiAddress which represents either an Address (corresponding to a public key of an account) or an Object, but never both (it is not known up-front whether a given Owner is an Address or an Object).

PageInfo

class PageInfo

Information about pagination in a connection

Parent

class Parent

If the object's owner is a Parent, this object is part of a dynamic field (it is the value of the dynamic field, or the intermediate Field object itself), and it is owned by another object.

ProgrammableSystemTransactionBlock

class ProgrammableSystemTransactionBlock

ProgrammableSystemTransactionBlock is identical to ProgrammableTransactionBlock, but graphql does not allow multiple variants with the same type.

ProgrammableTransactionBlock

class ProgrammableTransactionBlock

A user transaction that allows the interleaving of native commands (like transfer, split coins, merge coins, etc) and move calls, executed atomically.

ProtocolConfigAttr

class ProtocolConfigAttr

A single protocol configuration value.

ProtocolConfigFeatureFlag

class ProtocolConfigFeatureFlag

Whether or not a single feature is enabled in the protocol config.

ProtocolConfigs

class ProtocolConfigs

Constants that control how the chain operates.

Query

class Query

RandomnessStateCreateTransaction

class RandomnessStateCreateTransaction

RandomnessStateUpdateTransaction

class RandomnessStateUpdateTransaction

System transaction to update the source of on-chain randomness.

Result

class Result

The result of another transaction command.

SafeMode

class SafeMode

Information about whether epoch changes are using safe mode.

Shared

class Shared

A shared object is an object that is shared using the 0x2::transfer::share_object function. Unlike owned objects, once an object is shared, it stays mutable and is accessible by anyone.

StakedSui

class StakedSui

Represents a 0x3::staking_pool::StakedSui Move object on-chain.

StakedSuiConnection

class StakedSuiConnection

StakeStatus

enum StakeStatus : Enum<StakeStatus>

The stake's possible status: active, pending, or unstaked.

StakeSubsidy

class StakeSubsidy

Parameters that control the distribution of the stake subsidy.

StorageFund

class StorageFund

SUI set aside to account for objects stored on-chain.

StoreExecutionTimeObservationsTransaction

class StoreExecutionTimeObservationsTransaction

SuiAddress

class SuiAddress

String containing 32B hex-encoded address, with a leading "0x". Leading zeroes can be omitted on input but will always appear in outputs (SuiAddress in output is guaranteed to be 66 characters long).

SuinsRegistration

class SuinsRegistration

SuinsRegistrationConnection

class SuinsRegistrationConnection

SystemParameters

class SystemParameters

Details of the system that are decided during genesis.

TransactionArgument

class TransactionArgument

An argument to a programmable transaction command.

TransactionBlock

class TransactionBlock

TransactionBlockConnection

class TransactionBlockConnection

TransactionBlockEffects

class TransactionBlockEffects

The effects representing the result of executing a transaction block.

TransactionBlockFilter

data class TransactionBlockFilter(val function: Optional<String?> = Optional.Absent, val kind: Optional<TransactionBlockKindInput?> = Optional.Absent, val afterCheckpoint: Optional<Any?> = Optional.Absent, val atCheckpoint: Optional<Any?> = Optional.Absent, val beforeCheckpoint: Optional<Any?> = Optional.Absent, val affectedAddress: Optional<Any?> = Optional.Absent, val sentAddress: Optional<Any?> = Optional.Absent, val inputObject: Optional<Any?> = Optional.Absent, val changedObject: Optional<Any?> = Optional.Absent, val transactionIds: Optional<List<String>?> = Optional.Absent)

TransactionBlockKind

class TransactionBlockKind

The kind of transaction block, either a programmable transaction or a system transaction.

TransactionBlockKindInput

enum TransactionBlockKindInput : Enum<TransactionBlockKindInput>

An input filter selecting for either system or programmable transactions.

TransactionMetadata

data class TransactionMetadata(val sender: Optional<Any?> = Optional.Absent, val gasPrice: Optional<Any?> = Optional.Absent, val gasObjects: Optional<List<ObjectRef>?> = Optional.Absent, val gasBudget: Optional<Any?> = Optional.Absent, val gasSponsor: Optional<Any?> = Optional.Absent)

The optional extra data a user can provide to a transaction dry run. sender defaults to 0x0. If gasObjects is not present, or is an empty list, it is substituted with a mock Coin object, gasPrice defaults to the reference gas price, gasBudget defaults to the max gas budget and gasSponsor defaults to the sender.

UInt53

class UInt53

An unsigned integer that can hold values up to 2^53 - 1. This can be treated similarly to Int, but it is guaranteed to be non-negative, and it may be larger than 2^32 - 1.

Validator

class Validator

ValidatorConnection

class ValidatorConnection

ValidatorCredentials

class ValidatorCredentials

The credentials related fields associated with a validator.

ValidatorSet

class ValidatorSet

Representation of 0x3::validator_set::ValidatorSet.