Account data A simplified version of the onchain Account resource
Account signature scheme The account signature scheme allows you to have two types of accounts: 1. A single Ed25519 key account, one private key 2. A k-of-n multi-Ed25519 key account, multiple private keys, such that k-of-n must sign a transaction. 3. A single Secp256k1Ecdsa key account, one private key
A hex encoded 32 byte Aptos account address. This is represented in a string as a 64 character hex string, sometimes shortened by stripping leading 0s, and adding a 0x. For example, address 0x0000000000000000000000000000000000000000000000000000000000000001 is represented as 0x1.
This is the generic struct we use for all API errors, it contains a string message and an Aptos API specific error code.
These codes provide more granular error information beyond just the HTTP status code of the response.
A hex encoded 32 byte Aptos account address or a struct tag. This is represented in a string as a 64 character hex string, sometimes shortened by stripping leading 0s, and adding a 0x or Format: `{address}::{module name}::{struct name}`
A Block with or without transactions This contains the information about a transactions along with associated transactions if requested
A block metadata transaction This signifies the beginning of a block, and contains information about the specific block
An encrypted payload's claim about the entry function. Specifies at least the module address, and optionally the specific entry funtion.
Payload has been successfully decrypted.
A higher-limits request backed by a stake pool the fee payer is the delegated voter of.
A higher-limits request backed by a delegation pool the fee payer delegates to.
Payload is still encrypted and cannot be read.
The inner payload of an encrypted transaction, present only when decrypted.
An encrypted transaction payload, discriminated by encrypted_state. NOTE: multisig_address and replay_protection_nonce are not surfaced here. They are part of extra_config and already exposed on UserTransactionRequest. For Decrypted state, multisig_address is embedded in the MultisigPayload variant of decrypted_payload.
Entry function id is string representation of a entry function defined on-chain. Format: `{address}::{module name}::{function name}` Both `module name` and `function name` are case-sensitive.
Payload which runs a single entry function
A more API-friendly representation of the on-chain `aptos_types::aggregate_signature::AggregateSignature`.
A more API-friendly representation of the on-chain `aptos_types::dkg::chunky_dkg::CertifiedAggregatedChunkySubtranscript`.
A more API-friendly representation of the on-chain `aptos_types::jwks::ProviderJWKs`.
A more API-friendly representation of the on-chain `aptos_types::jwks::QuorumCertifiedUpdate`.
Fee payer signature for fee payer transactions This allows you to have transactions across multiple accounts and with a fee payer
Struct holding the outputs of the estimate gas API
The writeset payload of the Genesis transaction
The genesis transaction This only occurs at the genesis transaction (version 0)
Representation of a successful healthcheck
All bytes (Vec<u8>) data is represented as hex-encoded string prefixed with `0x` and fulfilled with two hex digits per byte. Unlike the `Address` type, HexEncodedBytes will not trim any zeros.
A string containing a 128-bit signed integer. We represent i128 values as a string to ensure compatibility with languages such as JavaScript that do not parse i128s in JSON natively.
A string containing a 256-bit signed integer. We represent i256 values as a string to ensure compatibility with languages such as JavaScript that do not parse i256s in JSON natively.
A string containing a 64-bit signed integer. We represent i64 values as a string to ensure compatibility with languages such as JavaScript that do not parse i64s in JSON natively.
The struct holding all data returned to the client by the index endpoint (i.e., GET "/"). Only for responding in JSON
The JWK type that can be converted from/to `JWKMoveStruct` but easier to use in rust.
Move module bytecode along with it's ABI
Move module id is a string representation of Move module. Format: `{address}::{module name}` `address` should be hex-encoded 32 byte account address that is prefixed with `0x`. Module name is case-sensitive.
String representation of a MoveStructTag (on-chain Move struct type). This exists so you can specify MoveStructTags as path / query parameters, e.g. for get_events_by_event_handle. It is a combination of: 1. `move_module_address`, `module_name` and `struct_name`, all joined by `::` 2. `struct generic type parameters` joined by `, ` Examples: * `0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>` * `0x1::account::Account` Note: 1. Empty chars should be ignored when comparing 2 struct tag ids. 2. When used in an URL path, should be encoded by url-encoding (AKA percent-encoding). See [doc](https://aptos.dev/concepts/accounts) for more details.
This is a JSON representation of some data within an account resource. More specifically, it is a map of strings to arbitrary JSON values / objects, where the keys are top level fields within the given resource. To clarify, you might query for 0x1::account::Account and see the example data. Move `bool` type value is serialized into `boolean`. Move `u8`, `u16`, `u32`, `i8`, `i16`, and `i32` type value is serialized into `integer`. Move `u64`, `u128`, `u256`, `i64`, `i128`, and `i256` type value is serialized into `string`. Move `address` type value (32 byte Aptos account address) is serialized into a HexEncodedBytes string. For example: - `0x1` - `0x1668f6be25668c1a17cd8caf6b8d2f25` Move `vector` type value is serialized into `array`, except `vector<u8>` which is serialized into a HexEncodedBytes string with `0x` prefix. For example: - `vector<u64>{255, 255}` => `["255", "255"]` - `vector<u8>{255, 255}` => `0xffff` Move `struct` type value is serialized into `object` that looks like this (except some Move stdlib types, see the following section): ```json { field1_name: field1_value, field2_name: field2_value, ...... } ``` For example: `{ "created": "0xa550c18", "role_id": "0" }` **Special serialization for Move stdlib types**: - [0x1::string::String](https://github.com/aptos-labs/aptos-core/blob/main/third_party/move/move-stdlib/docs/ascii.md) is serialized into `string`. For example, struct value `0x1::string::String{bytes: b"Hello World!"}` is serialized as `"Hello World!"` in JSON.
String representation of an on-chain Move type tag that is exposed in transaction payload. Values: - bool - u8 - u16 - u32 - u64 - u128 - u256 - i8 - i16 - i32 - i64 - i128 - i256 - address - signer - vector: `vector<{non-reference MoveTypeId}>` - struct: `{address}::{module_name}::{struct_name}::<{generic types}>` Vector type value examples: - `vector<u8>` - `vector<vector<u64>>` - `vector<0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>>` Struct type value examples: - `0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin> - `0x1::account::Account` Note: 1. Empty chars should be ignored when comparing 2 struct tag ids. 2. When used in an URL path, should be encoded by url-encoding (AKA percent-encoding).
An enum of the possible Move value types
Multi agent signature for multi agent transactions This allows you to have transactions across multiple accounts
A Ed25519 multi-sig signature This allows k-of-n signing for a transaction
A multisig transaction that allows an owner of a multisig account to execute a pre-approved transaction as the multisig account.
Enum for multisig transaction payloads, supporting both entry functions and scripts.
A placeholder to represent the absence of account signature
API representation of persisted auxiliary transaction information
Move type `0x1::jwks::RSA_JWK` in rust. See its doc in Move for more details.
Table Item request for the GetTableItemRaw API
Multipliers for higher transaction limits, expressed as percent of the base limit (100 = 1x, 200 = 2x, 250 = 2.5x).
Payload which runs a script that can run multiple functions
A higher-limits request whose backing is a stake pool the fee payer owns.
Representation of a StateKey as a hex string. This is used for cursor based pagination.
A request to submit a transaction This requires a transaction and a signature of it
Table Item request for the GetTableItem API
Enum of the different types of transactions in Aptos
An enum of the possible transaction payloads
An enum representing the different transaction signatures available
Information telling which batch submission transactions failed
Batch transaction submission result Tells which transactions failed
A string containing a 128-bit unsigned integer. We represent u128 values as a string to ensure compatibility with languages such as JavaScript that do not parse u128s in JSON natively.
A string containing a 256-bit unsigned integer. We represent u256 values as a string to ensure compatibility with languages such as JavaScript that do not parse u256s in JSON natively.
A string containing a 64-bit unsigned integer. We represent u64 values as a string to ensure compatibility with languages such as JavaScript that do not parse u64s in JSON natively.
Move type `0x1::jwks::UnsupportedJWK` in rust. See its doc in Move for more details.
A transaction submitted by a user to change the state of the blockchain
A request for higher transaction execution limits, backed by a staking proof.
An event from a transaction with a version
View request for the Move View Function API
Write a new module or update an existing one
Write a resource or update an existing one
A final state change of a transaction on a resource or module
A writeset payload, used only for genesis