Sui Full Node gRPC
This content describes an alpha/beta feature or service. These early stage features and services are in active development, so details are likely to change.
This feature or service is currently available in
- Devnet
- Testnet
- Mainnet
Sui Full node gRPC API will replace the JSON-RPC on Full nodes, such that JSON-RPC will be deprecated when gRPC API is generally available.
google/protobuf/any.proto
Any
Any contains an arbitrary serialized protocol buffer message along with a
URL that describes the type of the serialized message.
Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.
Example 1: Pack and unpack a message in C++.
Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... }
Example 2: Pack and unpack a message in Java.
Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } // or ... if (any.isSameTypeAs(Foo.getDefaultInstance())) { foo = any.unpack(Foo.getDefaultInstance()); }
Example 3: Pack and unpack a message in Python.
foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ...
Example 4: Pack and unpack a message in Go
foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... }
The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".
JSON
The JSON representation of an Any value uses the regular
representation of the deserialized, embedded message, with an
additional field @type which contains the type URL. Example:
package google.profile; message Person { string first_name = 1; string last_name = 2; }
{ "@type": "type.googleapis.com/google.profile.Person", "firstName": &#lt;string>, "lastName": &#lt;string> }
If the embedded message type is well-known and has a custom JSON
representation, that representation will be embedded adding a field
value which holds the custom JSON in addition to the @type
field. Example (for message [google.protobuf.Duration][]):
{ "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }
Fields
path/google.protobuf.Duration). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme http, https, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, https is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. As of May 2023, there are no widely used type server implementations and no plans to implement one. Schemes other than http, https (or the empty scheme) might be used with implementation specific semantics.google/protobuf/duration.proto
Duration
A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years.
Examples
Example 1: Compute Duration from two Timestamps in pseudo code.
Timestamp start = ...; Timestamp end = ...; Duration duration = ...;
duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos;
if (duration.seconds &#lt; 0 && duration.nanos > 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (duration.seconds > 0 && duration.nanos &#lt; 0) { duration.seconds -= 1; duration.nanos += 1000000000; }
Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
Timestamp start = ...; Duration duration = ...; Timestamp end = ...;
end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos;
if (end.nanos &#lt; 0) { end.seconds -= 1; end.nanos += 1000000000; } else if (end.nanos >= 1000000000) { end.seconds += 1; end.nanos -= 1000000000; }
Example 3: Compute Duration from datetime.timedelta in Python.
td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td)
JSON Mapping
In JSON format, the Duration type is encoded as a string rather than an object, where the string ends in the suffix "s" (indicating seconds) and is preceded by the number of seconds, with nanoseconds expressed as fractional seconds. For example, 3 seconds with 0 nanoseconds should be encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should be expressed in JSON format as "3.000000001s", and 3 seconds and 1 microsecond should be expressed in JSON format as "3.000001s".
Fields
seconds field and a positive or negative nanos field. For durations of one second or more, a non-zero value for the nanos field must be of the same sign as the seconds field. Must be from -999,999,999 to +999,999,999 inclusive.google/protobuf/empty.proto
Empty
A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance:
service Foo {
rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
}
google/protobuf/field_mask.proto
FieldMask
FieldMask represents a set of symbolic field paths, for example:
paths: "f.a" paths: "f.b.d"
Here f represents a field in some root message, a and b
fields in the message found in f, and d a field found in the
message in f.b.
Field masks are used to specify a subset of fields that should be returned by a get operation or modified by an update operation. Field masks also have a custom JSON encoding (see below).
Field Masks in Projections
When used in the context of a projection, a response message or sub-message is filtered by the API to only contain those fields as specified in the mask. For example, if the mask in the previous example is applied to a response message as follows:
f { a : 22 b { d : 1 x : 2 } y : 13 } z: 8
The result will not contain specific values for fields x,y and z (their value will be set to the default, and omitted in proto text output):
f { a : 22 b { d : 1 } }
A repeated field is not allowed except at the last position of a paths string.
If a FieldMask object is not present in a get operation, the operation applies to all fields (as if a FieldMask of all fields had been specified).
Note that a field mask does not necessarily apply to the top-level response message. In case of a REST get operation, the field mask applies directly to the response, but in case of a REST list operation, the mask instead applies to each individual message in the returned resource list. In case of a REST custom method, other definitions may be used. Where the mask applies will be clearly documented together with its declaration in the API. In any case, the effect on the returned resource/resources is required behavior for APIs.
Field Masks in Update Operations
A field mask in update operations specifies which fields of the targeted resource are going to be updated. The API is required to only change the values of the fields as specified in the mask and leave the others untouched. If a resource is passed in to describe the updated values, the API ignores the values of all fields not covered by the mask.
If a repeated field is specified for an update operation, new values will
be appended to the existing repeated field in the target resource. Note that
a repeated field is only allowed in the last position of a paths string.
If a sub-message is specified in the last position of the field mask for an update operation, then new value will be merged into the existing sub-message in the target resource.
For example, given the target message:
f { b { d: 1 x: 2 } c: [1] }
And an update message:
f { b { d: 10 } c: [2] }
then if the field mask is:
paths: ["f.b", "f.c"]
then the result will be:
f { b { d: 10 x: 2 } c: [1, 2] }
An implementation may provide options to override this default behavior for repeated and message fields.
In order to reset a field's value to the default, the field must be in the mask and set to the default value in the provided resource. Hence, in order to reset all fields of a resource, provide a default instance of the resource and set all fields in the mask, or do not provide a mask as described below.
If a field mask is not present on update, the operation applies to all fields (as if a field mask of all fields has been specified). Note that in the presence of schema evolution, this may mean that fields the client does not know and has therefore not filled into the request will be reset to their default. If this is unwanted behavior, a specific service may require a client to always specify a field mask, producing an error if not.
As with get operations, the location of the resource which describes the updated values in the request message depends on the operation kind. In any case, the effect of the field mask is required to be honored by the API.
Considerations for HTTP REST
The HTTP kind of an update operation which uses a field mask must be set to PATCH instead of PUT in order to satisfy HTTP semantics (PUT must only be used for full updates).
JSON Encoding of Field Masks
In JSON, a field mask is encoded as a single string where paths are separated by a comma. Fields name in each path are converted to/from lower-camel naming conventions.
As an example, consider the following message declarations:
message Profile { User user = 1; Photo photo = 2; } message User { string display_name = 1; string address = 2; }
In proto a field mask for Profile may look as such:
mask { paths: "user.display_name" paths: "photo" }
In JSON, the same mask is represented as below:
{ mask: "user.displayName,photo" }
Field Masks and Oneof Fields
Field masks treat fields in oneofs just as regular fields. Consider the following message:
message SampleMessage { oneof test_oneof { string name = 4; SubMessage sub_message = 9; } }
The field mask can be:
mask { paths: "name" }
Or:
mask { paths: "sub_message" }
Note that oneof type names ("test_oneof" in this case) cannot be used in paths.
Field Mask Verification
The implementation of any API method which has a FieldMask type field in the
request should verify the included field paths, and return an
INVALID_ARGUMENT error if any path is unmappable.
Fields
google/protobuf/timestamp.proto
Timestamp
A Timestamp represents a point in time independent of any time zone
or calendar, represented as seconds and fractions of seconds at
nanosecond resolution in UTC Epoch time. It is encoded using the
Proleptic Gregorian Calendar which extends the Gregorian calendar
backwards to year one. It is encoded assuming all minutes are 60
seconds long, i.e. leap seconds are "smeared" so that no leap second
table is needed for interpretation. Range is from
0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
Restricting to that range ensures that conversion to
and from RFC 3339 date strings is possible.
See https://www.ietf.org/rfc/rfc3339.txt.
Examples
Example 1: Compute Timestamp from POSIX time().
Timestamp timestamp;
timestamp.set_seconds(time(NULL));
timestamp.set_nanos(0);
Example 2: Compute Timestamp from POSIX gettimeofday().
struct timeval tv;
gettimeofday(&tv, NULL);
Timestamp timestamp;
timestamp.set_seconds(tv.tv_sec);
timestamp.set_nanos(tv.tv_usec * 1000);
Example 3: Compute Timestamp from Win32 GetSystemTimeAsFileTime().
FILETIME ft;
GetSystemTimeAsFileTime(&ft);
UINT64 ticks = (((UINT64)ft.dwHighDateTime) &#lt;&#lt; 32) | ft.dwLowDateTime;
// A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
// is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
Timestamp timestamp;
timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); //
Example 4: Compute Timestamp from Java System.currentTimeMillis().
long millis = System.currentTimeMillis();
Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
.setNanos((int) ((millis % 1000) * 1000000)).build();
Example 5: Compute Timestamp from current time in Python.
timestamp = Timestamp()
timestamp.GetCurrentTime()
JSON Mapping
In JSON format, the Timestamp type is encoded as a string in the
RFC 3339 format. That is, the
format is {year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z
where {year} is always expressed using four digits while {month}, {day},
{hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
seconds, which can go up to 9 digits (so up to 1 nanosecond resolution),
are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
is required, though only UTC (as indicated by "Z") is presently supported.
For example, 2017-01-15T01:30:15.01Z encodes 15.01 seconds past
01:30 UTC on January 15, 2017.
In JavaScript, you can convert a Date object to this format using the
standard toISOString()
method. In Python, you can convert a standard datetime.datetime object
to this format using strftime
with the time format spec %Y-%m-%dT%H:%M:%S.%fZ. Likewise, in Java, you
can use the Joda Time's ISODateTimeFormat.dateTime()
to obtain a formatter capable of generating timestamps in this format.
Fields
1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.google/rpc/error_details.proto
BadRequest
Describes violations in a client request. This error type focuses on the syntactic aspects of the request.
Fields
FieldViolation
A message type used to describe a single bad request field.
Fields
text,json message CreateContactRequest { message EmailAddress { enum Type { TYPE_UNSPECIFIED = 0; HOME = 1; WORK = 2; } optional string email = 1; repeated EmailType type = 2; } string full_name = 1; repeated EmailAddress email_addresses = 2; } In this example, in proto field could take one of the following values: * full_name for a violation in the full_name value * email_addresses[1].email for a violation in the email field of the first email_addresses message * email_addresses[3].type[2] for a violation in the second type value in the third email_addresses message. In JSON, the same values are represented as: * fullName for a violation in the fullName value * emailAddresses[1].email for a violation in the email field of the first emailAddresses message * emailAddresses[3].type[2] for a violation in the second type value in the third emailAddresses message.[A-Z][A-Z0-9_]+[A-Z0-9], which represents UPPER_SNAKE_CASE.DebugInfo
Describes additional debugging info.
Fields
ErrorInfo
Describes the cause of the error with structured details.
Example of an error when contacting the "pubsub.googleapis.com" API when it is not enabled:
{ "reason": "API_DISABLED"
"domain": "googleapis.com"
"metadata": {
"resource": "projects/123",
"service": "pubsub.googleapis.com"
}
}
This response indicates that the pubsub.googleapis.com API is not enabled.
Example of an error that is returned when attempting to create a Spanner instance in a region that is out of stock:
{ "reason": "STOCKOUT"
"domain": "spanner.googleapis.com",
"metadata": {
"availableRegions": "us-central1,us-east2"
}
}
Fields
[a-z][a-zA-Z0-9-_]+ but should ideally be lowerCamelCase. Also, they must be limited to 64 characters in length. When identifying the current value of an exceeded limit, the units should be contained in the key, not the value. For example, rather than {"instanceLimit": "100/request"}, should be returned as, {"instanceLimitPerRequest": "100"}, if the client exceeds the number of instances that can be created in a single (batch) request.[A-Z][A-Z0-9_]+[A-Z0-9], which represents UPPER_SNAKE_CASE.MetadataEntry
Fields
Help
Provides links to documentation or for performing an out of band action.
For example, if a quota check failed with an error indicating the calling project hasn't enabled the accessed service, this can contain a URL pointing directly to the right place in the developer console to flip the bit.
Fields
Link
Describes a URL link.
Fields
LocalizedMessage
Provides a localized error message that is safe to return to the user which can be attached to an RPC error.
Fields
PreconditionFailure
Describes what preconditions have failed.
For example, if an RPC failed because it required the Terms of Service to be acknowledged, it could list the terms of service violation in the PreconditionFailure message.
Fields
Violation
A message type used to describe a single precondition failure.
Fields
QuotaFailure
Describes how a quota check failed.
For example if a daily limit was exceeded for the calling project,
a service could respond with a QuotaFailure detail containing the project
id and the description of the quota limit that was exceeded. If the
calling project hasn't enabled the service in the developer console, then
a service could respond with the project id and set service_disabled
to true.
Also see RetryInfo and Help types for other details about handling a quota failure.
Fields
Violation
A message type used to describe a single quota violation. For example, a daily quota or a custom quota that was exceeded.
Fields
clientip:<ip address of client> or project:<Google developer project id>.RequestInfo
Contains metadata about the request that clients can attach when filing a bug or providing other forms of feedback.
Fields
ResourceInfo
Describes the resource that is being accessed.
Fields
writer permission on the developer console project.user:<owner email> or project:<Google developer project id>.RetryInfo
Describes when the clients can retry a failed request. Clients could ignore the recommendation here or retry when this information is missing from error responses.
It's always recommended that clients should use exponential backoff when retrying.
Clients should wait until retry_delay amount of time has passed since
receiving the error response before retrying. If retrying requests also
fail, clients should use an exponential backoff scheme to gradually increase
the delay between retries based on retry_delay, until either a maximum
number of retries have been reached or a maximum retry delay cap has been
reached.
Fields
google/rpc/status.proto
Status
The Status type defines a logical error model that is suitable for
different programming environments, including REST APIs and RPC APIs. It is
used by gRPC. Each Status message contains
three pieces of data: error code, error message, and error details.
You can find out more about this error model and how to work with it in the API Design Guide.
Fields
sui/node/v2/node_service.proto
The sui.node.v2 package contains API definitions for services that are expected to run on Fullnodes.
BalanceChange
The delta, or change, in balance for an address for a particular Coin type.
Fields
EffectsFinality
Indicates the finality of the executed transaction.
Fields
ExecuteTransactionRequest
Request message for NodeService.ExecuteTransaction.
Note: You must provide only one of transaction or transaction_bcs.
Fields
UserSigantures authorizing the execution of the provided transaction.UserSigantures authorizing the execution of the provided transaction, encoded as bytes.ExecuteTransactionResponse should be returned.ExecuteTransactionResponse
Response message for NodeService.ExecuteTransaction.
Fields
Coin type objects.TransactionEvents for this transaction. This field might be empty, even if it was explicitly requested, if the transaction didn't produce any events. sui.types.TransactionEffects.events_digest is populated if the transaction produced any events.FullCheckpointObject
An object used by or produced from a transaction.
Fields
FullCheckpointTransaction
A transaction, with all of its inputs and outputs.
Fields
TransactionEvents for this transaction. This field might be empty, even if it was explicitly requested, if the transaction didn't produce any events. sui.types.TransactionEffects.events_digest is populated if the transaction produced any events.GetCheckpointRequest
Request message for NodeService.GetCheckpoint.
At most, provide one of sequence_number or digest. An error is
returned if you attempt to provide both. If you provide neither, the service
returns the latest executed checkpoint.
Fields
GetCheckpointResponse
Response message for NodeService.GetCheckpoint.
Fields
GetCommitteeRequest
Request message for NodeService.GetCommittee.
Fields
GetCommitteeResponse
Response message for NodeService.GetCommittee.
Fields
GetFullCheckpointRequest
Request message for NodeService.GetFullCheckpoint.
At most, provide one of sequence_number or digest. An error is
returned if you provide both. If you provide neither, the service
returns the latest executed checkpoint.
Fields
GetFullCheckpointResponse
Response message for NodeService.GetFullCheckpoint.
Fields
GetNodeInfoRequest
Request message for NodeService.GetNodeInfo.
GetNodeInfoResponse
Response message for NodeService.GetNodeInfo.
Fields
mainnet, testnet, and so on.GetObjectRequest
Request message for NodeService.GetObject.
Fields
GetObjectResponse should be returned.GetObjectResponse
Response message for NodeService.GetObject.
Fields
GetTransactionRequest
Request message for NodeService.GetTransaction.
Fields
GetTransactionResponse
Response message for NodeService.GetTransaction.
Fields
TransactionEvents for this transaction. This field might be empty, even if it was explicitly requested, if the transaction didn't produce any events. sui.types.TransactionEffects.events_digest is populated if the transaction produced any events.sui/node/v2alpha/node_service.proto
The sui.node.v2alpha package contains experimental services that have yet to stabilize
Everything in here is subject to change and there is no gaurentee about stability or breaking changes.
AccountObject
Fields
CoinMetadata
Metadata for a coin type
Fields
CoinTreasury
Information about a coin type's 0x2::coin::TreasuryCap and its total available supply
Fields
DynamicField
Fields
GetCoinInfoRequest
Request message for NodeService.GetCoinInfo.
Fields
GetCoinInfoResponse
Response message for NodeService.GetCoinInfo.
Fields
0x2::coin::CoinMetadata if it exists and has not been wrapped.0x2::coin::TreasuryCap if it exists and has not been wrapped.GetGasInfoRequest
GetGasInfoResponse
Fields
GetProtocolConfigRequest
Fields
GetProtocolConfigResponse
Fields
AttributesEntry
Fields
FeatureFlagsEntry
Fields
ListAccountObjectsRequest
Request message for NodeService.ListAccountObjects
Fields
50 entries will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.ListAccountObjects call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to ListAccountObjects must match the call that provided the page token.ListAccountObjectsResponse
Response message for NodeService.ListAccountObjects
Fields
page_token to retrieve the next page. If this field is omitted, there are no subsequent pages.ListDynamicFieldsRequest
Request message for NodeService.ListDynamicFields
Fields
50 entries will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.ListDynamicFields call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to ListDynamicFields must match the call that provided the page token.UID of the parent, which owns the collections of dynamic fields.ListDynamicFieldsResponse
Response message for NodeService.ListDynamicFields
Fields
page_token to retrieve the next page. If this field is omitted, there are no subsequent pages.RegulatedCoinMetadata
Information about a regulated coin, which indicates that it makes use of the transfer deny list.
Fields
ResolveTransactionRequest
Fields
ResolveTransactionResponse
Fields
SimulateTransactionRequest
Fields
SimulateTransactionResponse
Fields
sui/node/v2alpha/subscription_service.proto
The sui.node.v2alpha package contains experimental services that have yet to stabilize
Everything in here is subject to change and there is no gaurentee about stability or breaking changes.
SubscribeCheckpointsRequest
Request message for SubscriptionService.SubscribeCheckpoints
Fields
SubscribeCheckpointsResponse
Response message for SubscriptionService.SubscribeCheckpoints
Fields
sui/types/signature_scheme.proto
sui/types/types.proto
Protobuf definitions of public Sui core types.
This file contains a complete set of protobuf definitions for all of the public sui core types. All sui types are intended to have a 1:1 mapping to a protobuf message defined in this file and be able to roundtrip to/from their rust and protobuf definitions assuming a sufficiently up-to-date version of both these definitions.
For more information on the types these proto messages correspond with, see
the documentation for their rust versions defined in the
sui-sdk-types
library.
Use of optional
These message definitions use protobuf version 3 (proto3). In proto3, fields
that are primitives (that is, they are not a message) and are not present
on the wire are zero-initialized. To gain the ability to detect
field presence,
these definitions follow the convention of having all fields marked
optional, and wrapping repeated fields in a message as needed.
ActiveJwk
A new JWK.
Fields
Address
Unique identifier for an account on the Sui blockchain.
An Address is a 32-byte pseudonymous identifier used to uniquely identify an account and
asset-ownership on the Sui blockchain. Often, human-readable addresses are encoded in
hexadecimal with a 0x prefix. For example, this is a valid Sui address:
0x02a212de6a9dfa3a69e22387acfbafbb1a9e591bd9d636e7895dcfc8de05f331.
Fields
AddressDeniedForCoinError
Address is denied for this coin type.
Fields
Argument
An argument to a programmable transaction command.
Fields
TransferObjects, which can use it by-value.Result but it accesses a nested result. Currently, the only usage of this is to access a value from a Move call with multiple return values.AuthenticatorStateExpire
Expire old JWKs.
Fields
AuthenticatorStateUpdate
Update the set of valid JWKs.
Fields
Bcs
Message that represents a type that is serialized and encoded using the BCS format.
Fields
Bn254FieldElement
A point on the BN254 elliptic curve.
Fields
CancelledTransaction
A transaction that was cancelled.
Fields
CancelledTransactions
Set of cancelled transactions.
Fields
ChangeEpoch
System transaction used to change the epoch.
Fields
ChangeEpoch txn, the validator must write out the following modules. Modules are provided with the version they will be upgraded to, their modules in serialized form (which include their package ID), and a list of their transitive dependencies.ChangedObject
Input/output state of an object that was changed during execution.
Fields
CheckpointCommitment
A commitment made by a checkpoint.
Fields
CheckpointContents
The committed to contents of a checkpoint.
Fields
V1
Version 1 of CheckpointContents.
Fields
CheckpointSummary
A header for a checkpoint on the Sui blockchain.
On the Sui network, checkpoints define the history of the blockchain. They are quite similar to the concept of blocks used by other blockchains like Bitcoin or Ethereum. The Sui blockchain, however, forms checkpoints after transaction execution has already happened to provide a certified history of the chain, instead of being formed before execution.
Checkpoints commit to a variety of state, including but not limited to:
- The hash of the previous checkpoint.
- The set of transaction digests, their corresponding effects digests, as well as the set of user signatures that authorized its execution.
- The objects produced by a transaction.
- The set of live objects that make up the current state of the chain.
- On epoch transitions, the next validator committee.
CheckpointSummarys themselves don't directly include all of the previous information but they
are the top-level type by which all the information is committed to transitively via cryptographic
hashes included in the summary. CheckpointSummarys are signed and certified by a quorum of
the validator committee in a given epoch to allow verification of the chain's state.
Fields
CheckpointSummary. This will be None only for the first, or genesis, checkpoint.CheckpointSummary is not an evolvable structure - it must be readable by any version of the code. Therefore, to allow extensions to be added to CheckpointSummary, opaque data can be added to checkpoints, which can be deserialized based on the current protocol version.CheckpointedTransactionInfo
Transaction information committed to in a checkpoint.
Fields
CircomG1
A G1 point.
Fields
CircomG2
A G2 point.
Fields
Command
A single command in a programmable transaction.
Fields
forall T: Vec<T> -> vector<T> Given n-values of the same type, it constructs a vector. For non-objects or an empty vector, the type tag must be specified.(&mut Coin<T>, Vec<u64>) -> Vec<Coin<T>> It splits off some amounts into new coins with those amounts.(Vec<forall T:key+store. T>, address) It sends n-objects to the specified address. These objects must have store (public transfer) and either the previous owner must be an address or the object must be newly created.UpgradeTicket that must have been produced from an earlier command in the same programmable transaction.CommandArgumentError
An error with an argument to a command.
Fields
TransferObject command.CongestedObjectsError
Set of objects that were congested, leading to the transaction's cancellation.
Fields
ConsensusCommitPrologue
Consensus commit prologue system transaction.
This message can represent V1, V2, and V3 prologue types.
Fields
ConsensusDeterminedVersionAssignments
Version assignments performed by consensus.
Fields
Digest
32-byte output of hashing a Sui structure using the Blake2b256 hash function.
Fields
EndOfEpochData
Data, which when included in a CheckpointSummary, signals the end of an Epoch.
Fields
ValidatorCommittee for the next epoch.EndOfEpochTransaction
Set of operations run at the end of the epoch to close out the current epoch and start the next one.
Fields
EndOfEpochTransactionKind
Operation run at the end of an epoch.
Fields
Event
An event.
Fields
MoveCall command that triggered this event to be emitted.MoveCall command that triggered this event to be emitted.ExecutionStatus
The status of an executed transaction.
Fields
FailureStatus
An error that can occur during the execution of a transaction.
Fields
GasCostSummary
Summary of gas charges.
Storage is charged independently of computation. There are three parts to the storage charges:
storage_cost: the charge of storage at the time the transaction is executed. The cost of storage is the number of bytes of the objects being mutated multiplied by a variable storage cost per byte.storage_rebate: the amount a user gets back when manipulating an object. Thestorage_rebateis thestorage_costfor an object minus fees.non_refundable_storage_fee: not all the value of the object storage cost is given back to user and there is a small fraction that is kept by the system. This value tracks that charge.
When looking at a gas cost summary the amount charged to the user is
computation_cost + storage_cost - storage_rebate
and that is the amount that is deducted from the gas coins.
non_refundable_storage_fee is collected from the objects being mutated/deleted
and it is tracked by the system in storage funds.
Objects deleted, including the older versions of objects mutated, have the storage field
on the objects added up to a pool of "potential rebate". This rebate then is reduced
by the "nonrefundable rate" such that:
potential_rebate(storage cost of deleted/mutated objects) = storage_rebate + non_refundable_storage_fee
Fields
GasPayment
Payment information for executing a transaction.
Fields
GenesisObject
An object part of the initial chain state.
Fields
GenesisTransaction
The genesis transaction.
Fields
I128
A signed 128-bit integer encoded in little-endian using 16-bytes.
Fields
Identifier
A Move identifier.
Identifiers are only valid if they conform to the following ABNF:
identifier = (ALPHA *127(ALPHA / DIGIT / UNDERSCORE)) /
(UNDERSCORE 1*127(ALPHA / DIGIT / UNDERSCORE))
UNDERSCORE = %x95
Fields
Input
An input to a user transaction.
Fields
Jwk
A JSON web key.
Struct that contains info for a JWK. A list of them for different kinds can be retrieved from the JWK endpoint (for example, &#lt;https://www.googleapis.com/oauth2/v3/certs>). The JWK is used to verify the JWT token.
Fields
JwkId
Key to uniquely identify a JWK.
Fields
MakeMoveVector
Command to build a Move vector out of a set of individual elements.
Fields
MergeCoins
Command to merge multiple coins of the same type into a single coin.
Fields
ModifiedAtVersion
Indicates that an object was modified at a specific version.
Fields
MoveCall
Command to call a Move function.
Functions that can be called by a MoveCall command are those that have a function signature
that is either entry or public (which don't have a reference return type).
Fields
MoveError
Error that occurred in Move.
Fields
MoveField
Fields
MoveLocation
Location in Move bytecode where an error occurred.s
Fields
MoveModule
Module defined by a package.
Fields
MovePackage
A Move package.
Fields
MoveStruct
A Move struct.
Fields
MoveStructValue
Fields
MoveValue
Fields
MoveVariant
Fields
MoveVector
Fields
MultisigAggregatedSignature
Aggregated signature from members of a multisig committee.
Fields
MultisigCommittee
A multisig committee.
Fields
MultisigMember
A member in a multisig committee.
Fields
MultisigMemberPublicKey
Set of valid public keys for multisig committee members.
Fields
MultisigMemberSignature
A signature from a member of a multisig committee.
Fields
NestedResult
An argument type for a nested result.
Fields
Object
An object on the Sui blockchain.
Fields
ObjectData
Object data, either a package or struct.
Fields
ObjectExist
Information about the old version of the object.
Fields
ObjectId
Unique identifier for an object on the Sui blockchain.
An ObjectId is a 32-byte identifier used to uniquely identify an object on the Sui
blockchain.
Fields
ObjectReference
Reference to an object.
Fields
ObjectReferenceWithOwner
An object reference with owner information.
Fields
ObjectWrite
Object write, including all of mutated, created, unwrapped.
Fields
Owner
Enum of different types of ownership for an object.
Fields
PackageIdDoesNotMatch
Package ID does not match PackageId in upgrade ticket.
Fields
PackageUpgradeError
An error with a upgrading a package.
Fields
PackageId in upgrade ticket.PackageWrite
Package write.
Fields
PasskeyAuthenticator
A passkey authenticator.
See
struct.PasskeyAuthenticator
for more information on the requirements on the shape of the
client_data_json field.
Fields
ProgrammableTransaction
A user transaction.
Contains a series of native commands and Move calls where the results of one command can be used in future commands.
Fields
Publish
Command to publish a new Move package.
Fields
RandomnessStateUpdate
Randomness update.
Fields
ReadOnlyRoot
Read-only shared object from the input.
Fields
RoaringBitmap
A RoaringBitmap. See
RoaringFormatSpec for the
specification for the serialized format of RoaringBitmaps.
Fields
SharedObjectInput
A shared object input.
Fields
SimpleSignature
A basic signature.
Can either be an ed25519, secp256k1, or secp256r1 signature with corresponding public key.
Fields
SizeError
A size error.
Fields
SplitCoins
Command to split a single coin object into multiple coins.
Fields
StructTag
Type information for a Move struct.
Fields
SystemPackage
System package.
Fields
Transaction
A transaction.
Fields
TransactionV1
Version 1 of Transaction.
Fields
TransactionEffects
The output or effects of executing a transaction.
Fields
TransactionEffectsV1
Version 1 of TransactionEffects.
Fields
ObjectReference and owner of mutated objects, including gas object.ObjectReference and owner of objects that are unwrapped in this transaction. Unwrapped objects are objects that were wrapped into other objects in the past, and just got extracted out.None if the transaction does not emit any event.TransactionEffectsV2
Version 2 of TransactionEffects.
Fields
None if the transaction does not emit any event.changed_objects vector. Having a dedicated field for convenient access. System transaction that don't require gas will leave this as None.TransactionEvents
Events emitted during the successful execution of a transaction.
Fields
TransactionExpiration
A TTL for a transaction.
Fields
TransactionKind
Transaction type.
Fields
ChangeEpoch variant is now deprecated (but the ChangeEpoch struct is still used by EndOfEpochTransaction).TransferObjects
Command to transfer ownership of a set of objects to an address.
Fields
TypeArgumentError
Type argument error.
Fields
TypeOrigin
Identifies a struct and the module it was defined in.
Fields
TypeTag
Type of a Move value.
Fields
U128
An unsigned 128-bit integer encoded in little-endian using 16-bytes.
Fields
U256
An unsigned 256-bit integer encoded in little-endian using 32-bytes.
Fields
UnchangedSharedObject
A shared object that wasn't changed during execution.
Fields
Upgrade
Command to upgrade an already published package.
Fields
UpgradeInfo
Upgraded package info for the linkage table.
Fields
UserSignature
A signature from a user.
Fields
ValidatorAggregatedSignature
An aggregated signature from multiple validators.
Fields
ValidatorCommittee from this epoch to verify this signature.ValidatorCommittee
The validator set for a particular epoch.
Fields
ValidatorCommitteeMember
A member of a validator committee.
Fields
VersionAssignment
Object version assignment from consensus.
Fields
ZkLoginAuthenticator
A zklogin authenticator.
Fields
ZkLoginClaim
A claim of the iss in a zklogin proof.
Fields
ZkLoginInputs
A zklogin groth16 proof and the required inputs to perform proof verification.
Fields
ZkLoginProof
A zklogin groth16 proof.
Fields
ZkLoginPublicIdentifier
Public key equivalent for zklogin authenticators.
Fields
Scalar Value Types
double
float
int32
Uses variable-length encoding. Inefficient for encoding negative numbers – if your field is likely to have negative values, use sint32 instead.
int64
Uses variable-length encoding. Inefficient for encoding negative numbers – if your field is likely to have negative values, use sint64 instead.
uint32
Uses variable-length encoding.
uint64
Uses variable-length encoding.
sint32
Uses variable-length encoding. Signed int value. These more efficiently encode negative numbers than regular int32s.
sint64
Uses variable-length encoding. Signed int value. These more efficiently encode negative numbers than regular int64s.
fixed32
Always four bytes. More efficient than uint32 if values are often greater than 2^28.
fixed64
Always eight bytes. More efficient than uint64 if values are often greater than 2^56.
sfixed32
Always four bytes.
sfixed64
Always eight bytes.
bool
string
A string must always contain UTF-8 encoded or 7-bit ASCII text.
bytes
May contain any arbitrary sequence of bytes.