Class AbstractKeylessAccountAbstract
Hierarchy (view full)
- Serializable
- AbstractKeylessAccount
Implements
Index
Methods
Properties
Methods
bcs
bcs
check
- check
Keyless Account Validity(aptosConfig): Promise<void> Validates that the Keyless Account can be used to sign transactions.
+Parameters
- aptosConfig: AptosConfig
Returns Promise<void>
init
- init(promise): Promise<void>
This initializes the asynchronous proof fetch.
+Parameters
- promise: Promise<ZeroKnowledgeSig>
Returns Promise<void>
Emits whether the proof succeeds or fails, but has no return.
+
is
serialize
- serialize(serializer): void
Serializes the jwt data into a format suitable for transmission or storage. +This function ensures that both the jwt data and the proof are properly serialized.
+Parameters
- serializer: Serializer
The serializer instance used to convert the jwt data into bytes.
+
Returns void
- serializer: Serializer
sign
- sign(message): KeylessSignature
Sign the given message using Keyless.
+Parameters
- message: HexInput
in HexInput format
+
Returns KeylessSignature
Signature
+- message: HexInput
sign
- sign
Transaction(transaction): KeylessSignature Sign the given transaction with Keyless. +Signs the transaction and proof to guard against proof malleability.
+Parameters
- transaction: AnyRawTransaction
the transaction to be signed
+
Returns KeylessSignature
KeylessSignature
+- transaction: AnyRawTransaction
sign
- sign
Transaction With Authenticator(transaction): AccountAuthenticatorSingleKey Sign a transaction using Keyless.
+Parameters
- transaction: AnyRawTransaction
the raw transaction
+
Returns AccountAuthenticatorSingleKey
the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+- transaction: AnyRawTransaction
sign
- sign
With Authenticator(message): AccountAuthenticatorSingleKey Sign a message using Keyless.
+Parameters
- message: HexInput
the message to sign, as binary input
+
Returns AccountAuthenticatorSingleKey
the AccountAuthenticator containing the signature, together with the account's public key
+- message: HexInput
to
to
verify
- verify
Signature(args): boolean Note - This function is currently incomplete and should only be used to verify ownership of the KeylessAccount
+Verifies a signature given the message.
+TODO: Groth16 proof verification
+Parameters
- args: {
message: HexInput;
signature: KeylessSignature;
}message: HexInput
the message that was signed.
+signature: KeylessSignature
the KeylessSignature to verify
+
Returns boolean
boolean
+- args: {
wait
StaticfetchJWK
- fetchJWK(args): Promise<MoveJWK>
Fetches the JWK from the issuer's well-known JWKS endpoint.
+Parameters
- args: {
aptosConfig: AptosConfig;
kid: string;
publicKey: KeylessPublicKey | FederatedKeylessPublicKey;
}aptos
Config: AptosConfig kid: string
The kid of the JWK to fetch
+public
Key: KeylessPublicKey | FederatedKeylessPublicKey The keyless public key to query
+
Returns Promise<MoveJWK>
A JWK matching the
+kidin the JWT header.- args: {
Staticpartial
- partial
Deserialize(deserializer): {
address: AccountAddress;
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
pepper: Uint8Array;
proof: ZeroKnowledgeSig;
uidKey: string;
verificationKeyHash?: Uint8Array;
} Parameters
- deserializer: Deserializer
Returns {
address: AccountAddress;
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
pepper: Uint8Array;
proof: ZeroKnowledgeSig;
uidKey: string;
verificationKeyHash?: Uint8Array;
}address: AccountAddress
ephemeral
Key Pair: EphemeralKeyPair jwt: string
pepper: Uint8Array
proof: ZeroKnowledgeSig
uid
Key: string OptionalverificationKey Hash?: Uint8Array
Properties
Readonlyaccount
Account address associated with the account
+Readonlyaud
The value of the 'aud' claim on the JWT, also known as client ID. This is the identifier for the dApp's +OIDC registration with the identity provider.
+Readonlyephemeral
The EphemeralKeyPair used to generate sign.
+Readonlyjwt
The JWT token used to derive the account
+Readonlypepper
A value contains 31 bytes of entropy that preserves privacy of the account. Typically fetched from a pepper provider.
+proof
The zero knowledge signature (if ready) which contains the proof used to validate the EphemeralKeyPair.
+Readonlyproof
The proof of the EphemeralKeyPair or a promise that provides the proof. This is used to allow for awaiting on +fetching the proof.
+Readonlypublic
The KeylessPublicKey associated with the account
+Readonlysigning
Signing scheme used to sign transactions
+Readonlyuid
The claim on the JWT to identify a user. This is typically 'sub' or 'email'.
+Readonlyuid
The value of the uidKey claim on the JWT. This intended to be a stable user identifier.
+Optional Readonlyverification
The hash of the verification key used to verify the proof. This is optional and can be used to check verifying key +rotations which may invalidate the proof.
+Static ReadonlyPEPPER_
Class AccountAbstract
Abstract class representing a generic Aptos account.
+This class serves as a single entry point for account generation, allowing accounts to be created
+either through Account.generate() or Account.fromDerivationPath. Although it is defined as an
+abstract class, it should be treated as an interface and enforced using the implements keyword.
Note: Generating an account instance does not create the account on-chain.
+Hierarchy (view full)
- Account
Implemented by
Index
Constructors
Methods
Properties
Methods
Abstractsign
Abstractsign
- sign
Transaction(transaction): Signature Sign the given transaction using the available signing capabilities.
+Parameters
- transaction: AnyRawTransaction
the transaction to be signed
+
Returns Signature
Signature
+- transaction: AnyRawTransaction
Abstractsign
- sign
Transaction With Authenticator(transaction): AccountAuthenticator Sign a transaction using the available signing capabilities.
+Parameters
- transaction: AnyRawTransaction
the raw transaction
+
Returns AccountAuthenticator
the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+- transaction: AnyRawTransaction
Abstractsign
- sign
With Authenticator(message): AccountAuthenticator Sign a message using the available signing capabilities.
+Parameters
- message: HexInput
the signing message, as binary input
+
Returns AccountAuthenticator
the AccountAuthenticator containing the signature, together with the account's public key
+- message: HexInput
verify
- verify
Signature(args): boolean Verify the given message and signature with the public key. +This function helps ensure the integrity and authenticity of a message by validating its signature.
+Parameters
- args: VerifySignatureArgs
The arguments for verifying the signature.
+
Returns boolean
A boolean indicating whether the signature is valid.
+- args: VerifySignatureArgs
Staticauth
- auth
Key(args): AuthenticationKey Retrieve the authentication key for the associated account using the provided public key. +This key enables account owners to rotate their private key(s) associated with the account without changing the address that +hosts their account. +See here for more info: https://aptos.dev/concepts/accounts#single-signer-authentication
+Parameters
- args: {
publicKey: AccountPublicKey;
}The arguments for retrieving the authentication key.
+public
Key: AccountPublicKey The public key of the account.
+
Returns AuthenticationKey
The authentication key for the associated account.
+- args: {
Staticfrom
- from
Derivation Path(args): Ed25519Account Generates an account from a specified derivation path and mnemonic. +This function allows you to create an account using different signing schemes based on the provided arguments.
+Parameters
- args: GenerateEd25519AccountArgs & PrivateKeyFromDerivationPathArgs
The arguments for generating the account.
+
Returns Ed25519Account
- args: GenerateEd25519AccountArgs & PrivateKeyFromDerivationPathArgs
- from
Derivation Path(args): SingleKeyAccount Parameters
Returns SingleKeyAccount
- from
Derivation Path(args): SingleKeyAccount Parameters
Returns SingleKeyAccount
- from
Derivation Path(args): Account Parameters
Returns Account
Staticfrom
- from
Private Key(args): Ed25519Account Creates an account from a given private key and address. +This function allows you to instantiate an account based on the provided private key, +and it can differentiate between legacy and non-legacy accounts.
+Parameters
- args: CreateEd25519AccountFromPrivateKeyArgs
The arguments for creating the account.
+
Returns Ed25519Account
An instance of either Ed25519Account or SingleKeyAccount based on the provided private key.
+- args: CreateEd25519AccountFromPrivateKeyArgs
- from
Private Key(args): SingleKeyAccount Parameters
Returns SingleKeyAccount
- from
Private Key(args): SingleKeyAccount Parameters
Returns SingleKeyAccount
- from
Private Key(args): Account Parameters
Returns Account
Staticfrom
- from
Private Key And Address(args): Account Parameters
- args: CreateAccountFromPrivateKeyArgs
The arguments required to create an account from a private key.
+
Returns Account
Account
+- args: CreateAccountFromPrivateKeyArgs
Staticgenerate
- generate(args?): Ed25519Account
Generates a new account based on the specified signing scheme and legacy option. +This function allows you to create an account with either the Ed25519 signing scheme or a different scheme as specified.
+Parameters
Optionalargs: GenerateEd25519AccountArgsThe arguments for generating the account.
+
Returns Ed25519Account
- generate(args): SingleKeyAccount
Parameters
Returns SingleKeyAccount
- generate(args): SingleKeyAccount
Parameters
Returns SingleKeyAccount
- generate(args): Account
Parameters
- args: GenerateAccountArgs
Returns Account
Class AccountAddress
NOTE: Only use this class for account addresses. For other hex data, e.g. transaction +hashes, use the Hex class.
+AccountAddress is used for working with account addresses. Account addresses, when +represented as a string, generally look like these examples:
+-
+
- 0x1 +
- 0xaa86fe99004361f747f91342ca13c426ca0cccb0c1217677180c9493bad6ef0c +
Proper formatting and parsing of account addresses is defined by AIP-40. +To learn more about the standard, read the AIP here: +https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+The comments in this class make frequent reference to the LONG and SHORT formats, +as well as "special" addresses. To learn what these refer to see AIP-40.
+Hierarchy (view full)
- Serializable
- AccountAddress
Implements
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Account Address(input): AccountAddress Creates an instance of AccountAddress from a Uint8Array.
+This function ensures that the input data is exactly 32 bytes long, which is required for a valid account address.
+Parameters
- input: Uint8Array
A Uint8Array representing an account address.
+
Returns AccountAddress
- input: Uint8Array
Methods
bcs
bcs
equals
- equals(other): boolean
Determine if two AccountAddresses are equal based on their underlying byte data.
+Parameters
- other: AccountAddress
The AccountAddress to compare to.
+
Returns boolean
true if the AccountAddresses are equal, false if not.
+- other: AccountAddress
is
- is
Special(): boolean Determines if the address is classified as special, which is defined as 0x0 to 0xf inclusive. +In other words, the last byte of the address must be < 0b10000 (16) +and every other byte must be zero.
+For more information on how special addresses are defined, see AIP-40: +https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+Returns boolean
true if the address is special, false otherwise.
+
serialize
- serialize(serializer): void
Serialize the AccountAddress to a Serializer instance's data buffer.
+Parameters
- serializer: Serializer
The serializer to serialize the AccountAddress to.
+
Returns void
void
+- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serializes the current instance into a byte sequence suitable for entry functions. +This allows for the proper encoding of data when interacting with entry functions in the blockchain.
+Parameters
- serializer: Serializer
The serializer instance used to convert the data into bytes.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serializes the current instance for use in a script function by encoding it into a byte sequence. +This process involves serializing the variant index and the instance data, making it suitable for transmission.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
- to
String(): `0x${string}` Return the AccountAddress as a string as per AIP-40. +https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md. +This representation returns special addresses in SHORT form (0xf) +and other addresses in LONG form (0x + 64 characters).
+Returns `0x${string}`
AccountAddress as a string conforming to AIP-40.
+
to
- to
String Long(): `0x${string}` Convert the account address to a string in LONG format, which is always 0x followed by 64 hex characters.
+NOTE: Prefer to use
+toStringwhere possible, as it formats special addresses using the SHORT form (no leading 0s).Returns `0x${string}`
AccountAddress as a string in LONG form.
+
to
- to
String Long Without Prefix(): string Returns the account address as a string in LONG form without a leading 0x. +This function will include leading zeroes and will produce a string of 64 hex characters.
+NOTE: Prefer to use
+toStringwhere possible, as it formats special addresses using the SHORT form (no leading 0s).Returns string
The account address in LONG form.
+
to
to
Staticdeserialize
- deserialize(deserializer): AccountAddress
Deserialize an AccountAddress from the byte buffer in a Deserializer instance. +This function allows you to convert a byte representation of an AccountAddress into an instance of AccountAddress.
+Parameters
- deserializer: Deserializer
The deserializer to deserialize the AccountAddress from.
+
Returns AccountAddress
An instance of AccountAddress.
+- deserializer: Deserializer
Staticfrom
- from(input, __namedParameters?): AccountAddress
Convenience method for creating an AccountAddress from various input types. +This function accepts a string, Uint8Array, or an existing AccountAddress instance and returns the corresponding +AccountAddress.
+Parameters
- input: AccountAddressInput
The input to convert into an AccountAddress. This can be a string representation of an address, a Uint8Array, +or an existing AccountAddress.
+ - __namedParameters: {
maxMissingChars?: number;
} = {}OptionalmaxMissing Chars?: number
Returns AccountAddress
- input: AccountAddressInput
Staticfrom
- from
Strict(input): AccountAddress Create an AccountAddress from various input types, including strings, Uint8Array, and AccountAddress instances.
+Parameters
- input: AccountAddressInput
The input to convert into an AccountAddress, which can be a string, a Uint8Array, or an AccountAddress.
+
Returns AccountAddress
- input: AccountAddressInput
Staticfrom
- from
String(input, __namedParameters?): AccountAddress NOTE: This function has relaxed parsing behavior. For strict behavior, please use +the
+fromStringStrictfunction. Where possible usefromStringStrictrather than this +function,fromString.Creates an instance of AccountAddress from a hex string.
+This function allows all formats defined by AIP-40. In short this means the +following formats are accepted:
+-
+
- LONG, with or without leading 0x +
- SHORT*, with or without leading 0x +
Where:
+-
+
- LONG is 64 hex characters. +
- SHORT* is 1 to 63 hex characters inclusive. The address can have missing values up to
maxMissingCharsbefore it is padded.
+ - Padding zeroes are allowed, e.g. 0x0123 is valid. +
Learn more about the different address formats by reading AIP-40: +https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+Parameters
- input: string
A hex string representing an account address.
+ - __namedParameters: {
maxMissingChars?: number;
} = {}OptionalmaxMissing Chars?: number
Returns AccountAddress
An instance of AccountAddress.
+
Staticfrom
- from
String Strict(input): AccountAddress NOTE: This function has strict parsing behavior. For relaxed behavior, please use +the
+fromStringfunction.Creates an instance of AccountAddress from a hex string.
+This function allows only the strictest formats defined by AIP-40. In short this +means only the following formats are accepted:
+-
+
- LONG +
- SHORT for special addresses +
Where:
+-
+
- LONG is defined as 0x + 64 hex characters. +
- SHORT for special addresses is 0x0 to 0xf inclusive without padding zeroes. +
This means the following are not accepted:
+-
+
- SHORT for non-special addresses. +
- Any address without a leading 0x. +
Parameters
- input: string
A hex string representing an account address.
+
Returns AccountAddress
An instance of AccountAddress.
+Remarks
This function has strict parsing behavior. For relaxed behavior, please use the
+fromStringfunction.See
AIP-40 documentation for more details on address formats: +https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+
Staticis
- is
Valid(args): ParsingResult<AddressInvalidReason> Check if the provided input is a valid AccountAddress.
+Parameters
- args: {
input: AccountAddressInput;
strict?: boolean;
}The arguments for validation.
+input: AccountAddressInput
A hex string representing an account address.
+Optionalstrict?: booleanIf true, use strict parsing behavior; if false, use relaxed parsing behavior.
+
Returns ParsingResult<AddressInvalidReason>
An object indicating whether the address is valid. If valid, valid = true; if not, valid = false with additional details. +If the address is invalid, invalidReason will explain why it is invalid, and invalidReasonMessage will provide the error message.
+- args: {
Properties
Readonlydata
This is the internal representation of an account address.
+StaticA
StaticFOUR
Static ReadonlyLENGTH
The number of bytes that make up an account address.
+Static ReadonlyLONG_
The length of an address string in LONG form without a leading 0x.
+StaticONE
StaticTHREE
StaticTWO
StaticZERO
Class AccountAuthenticatorAbstract
Represents an account authenticator that can handle multiple authentication variants. +This class serves as a base for different types of account authenticators, allowing for serialization +and deserialization of various authenticator types.
+Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Account Authenticator(): AccountAuthenticator Returns AccountAuthenticator
Methods
bcs
bcs
is
- is
Ed25519(): this is AccountAuthenticatorEd25519 Determines if the current instance is an Ed25519 account authenticator.
+Returns this is AccountAuthenticatorEd25519
True if the instance is of type AccountAuthenticatorEd25519, otherwise false.
+
is
- is
Multi Ed25519(): this is AccountAuthenticatorMultiEd25519 Determines if the current instance is of type AccountAuthenticatorMultiEd25519.
+Returns this is AccountAuthenticatorMultiEd25519
True if the instance is a multi-signature Ed25519 account authenticator, otherwise false.
+
is
- is
Multi Key(): this is AccountAuthenticatorMultiKey Determine if the current instance is of type AccountAuthenticatorMultiKey.
+Returns this is AccountAuthenticatorMultiKey
Returns true if the instance is an AccountAuthenticatorMultiKey, otherwise false.
+
is
- is
Single Key(): this is AccountAuthenticatorSingleKey Determines if the current instance is of the type AccountAuthenticatorSingleKey.
+Returns this is AccountAuthenticatorSingleKey
True if the instance is an AccountAuthenticatorSingleKey, otherwise false.
+
Abstractserialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): AccountAuthenticator
Deserializes an AccountAuthenticator from the provided deserializer. +This function helps in reconstructing the AccountAuthenticator object based on the variant index.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns AccountAuthenticator
- deserializer: Deserializer
Class AccountAuthenticatorEd25519
Represents an Ed25519 transaction authenticator for multi-signer transactions. +This class encapsulates the account's Ed25519 public key and signature.
+Hierarchy (view full)
- AccountAuthenticator
- AccountAuthenticatorEd25519
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Account Authenticator Ed25519(public_key, signature): AccountAuthenticatorEd25519 Creates an instance of the class with the specified public keys and signatures.
+Parameters
- public_key: Ed25519PublicKey
The public key used for verification.
+ - signature: Ed25519Signature
The signatures corresponding to the public keys.
+
Returns AccountAuthenticatorEd25519
- public_key: Ed25519PublicKey
Methods
bcs
bcs
is
- is
Ed25519(): this is AccountAuthenticatorEd25519 Determines if the current instance is an Ed25519 account authenticator.
+Returns this is AccountAuthenticatorEd25519
True if the instance is of type AccountAuthenticatorEd25519, otherwise false.
+
is
- is
Multi Ed25519(): this is AccountAuthenticatorMultiEd25519 Determines if the current instance is of type AccountAuthenticatorMultiEd25519.
+Returns this is AccountAuthenticatorMultiEd25519
True if the instance is a multi-signature Ed25519 account authenticator, otherwise false.
+
is
- is
Multi Key(): this is AccountAuthenticatorMultiKey Determine if the current instance is of type AccountAuthenticatorMultiKey.
+Returns this is AccountAuthenticatorMultiKey
Returns true if the instance is an AccountAuthenticatorMultiKey, otherwise false.
+
is
- is
Single Key(): this is AccountAuthenticatorSingleKey Determines if the current instance is of the type AccountAuthenticatorSingleKey.
+Returns this is AccountAuthenticatorSingleKey
True if the instance is an AccountAuthenticatorSingleKey, otherwise false.
+
serialize
- serialize(serializer): void
Serializes the account authenticator data into the provided serializer. +This function captures the multi-key variant, public keys, and signatures for serialization.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer): AccountAuthenticator
Deserializes an AccountAuthenticator from the provided deserializer. +This function helps in reconstructing the AccountAuthenticator object based on the variant index.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns AccountAuthenticator
- deserializer: Deserializer
Staticload
- load(deserializer): AccountAuthenticatorEd25519
Loads an instance of AccountAuthenticatorMultiKey from the provided deserializer. +This function helps in reconstructing the authenticator object using the deserialized public keys and signatures.
+Parameters
- deserializer: Deserializer
The deserializer used to extract the necessary data for loading the authenticator.
+
Returns AccountAuthenticatorEd25519
- deserializer: Deserializer
Class AccountAuthenticatorMultiEd25519
Represents a transaction authenticator for Multi Ed25519, designed for multi-signer transactions.
+Hierarchy (view full)
- AccountAuthenticator
- AccountAuthenticatorMultiEd25519
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Account Authenticator Multi Ed25519(public_key, signature): AccountAuthenticatorMultiEd25519 Parameters
- public_key: MultiEd25519PublicKey
- signature: MultiEd25519Signature
Returns AccountAuthenticatorMultiEd25519
Methods
bcs
bcs
is
- is
Ed25519(): this is AccountAuthenticatorEd25519 Determines if the current instance is an Ed25519 account authenticator.
+Returns this is AccountAuthenticatorEd25519
True if the instance is of type AccountAuthenticatorEd25519, otherwise false.
+
is
- is
Multi Ed25519(): this is AccountAuthenticatorMultiEd25519 Determines if the current instance is of type AccountAuthenticatorMultiEd25519.
+Returns this is AccountAuthenticatorMultiEd25519
True if the instance is a multi-signature Ed25519 account authenticator, otherwise false.
+
is
- is
Multi Key(): this is AccountAuthenticatorMultiKey Determine if the current instance is of type AccountAuthenticatorMultiKey.
+Returns this is AccountAuthenticatorMultiKey
Returns true if the instance is an AccountAuthenticatorMultiKey, otherwise false.
+
is
- is
Single Key(): this is AccountAuthenticatorSingleKey Determines if the current instance is of the type AccountAuthenticatorSingleKey.
+Returns this is AccountAuthenticatorSingleKey
True if the instance is an AccountAuthenticatorSingleKey, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): AccountAuthenticator
Deserializes an AccountAuthenticator from the provided deserializer. +This function helps in reconstructing the AccountAuthenticator object based on the variant index.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns AccountAuthenticator
- deserializer: Deserializer
Staticload
- load(deserializer): AccountAuthenticatorMultiEd25519
Parameters
- deserializer: Deserializer
Returns AccountAuthenticatorMultiEd25519
Class AccountAuthenticatorMultiKey
Represents an account authenticator that supports multiple keys and signatures for multi-signature scenarios.
+Hierarchy (view full)
- AccountAuthenticator
- AccountAuthenticatorMultiKey
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Account Authenticator Multi Key(public_keys, signatures): AccountAuthenticatorMultiKey Parameters
- public_keys: MultiKey
- signatures: MultiKeySignature
Returns AccountAuthenticatorMultiKey
Methods
bcs
bcs
is
- is
Ed25519(): this is AccountAuthenticatorEd25519 Determines if the current instance is an Ed25519 account authenticator.
+Returns this is AccountAuthenticatorEd25519
True if the instance is of type AccountAuthenticatorEd25519, otherwise false.
+
is
- is
Multi Ed25519(): this is AccountAuthenticatorMultiEd25519 Determines if the current instance is of type AccountAuthenticatorMultiEd25519.
+Returns this is AccountAuthenticatorMultiEd25519
True if the instance is a multi-signature Ed25519 account authenticator, otherwise false.
+
is
- is
Multi Key(): this is AccountAuthenticatorMultiKey Determine if the current instance is of type AccountAuthenticatorMultiKey.
+Returns this is AccountAuthenticatorMultiKey
Returns true if the instance is an AccountAuthenticatorMultiKey, otherwise false.
+
is
- is
Single Key(): this is AccountAuthenticatorSingleKey Determines if the current instance is of the type AccountAuthenticatorSingleKey.
+Returns this is AccountAuthenticatorSingleKey
True if the instance is an AccountAuthenticatorSingleKey, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): AccountAuthenticator
Deserializes an AccountAuthenticator from the provided deserializer. +This function helps in reconstructing the AccountAuthenticator object based on the variant index.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns AccountAuthenticator
- deserializer: Deserializer
Staticload
- load(deserializer): AccountAuthenticatorMultiKey
Parameters
- deserializer: Deserializer
Returns AccountAuthenticatorMultiKey
Class AccountAuthenticatorSingleKey
Represents an account authenticator that utilizes a single key for signing. +This class is designed to handle authentication using a public key and its corresponding signature.
+Hierarchy (view full)
- AccountAuthenticator
- AccountAuthenticatorSingleKey
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Account Authenticator Single Key(public_key, signature): AccountAuthenticatorSingleKey Parameters
- public_key: AnyPublicKey
- signature: AnySignature
Returns AccountAuthenticatorSingleKey
Methods
bcs
bcs
is
- is
Ed25519(): this is AccountAuthenticatorEd25519 Determines if the current instance is an Ed25519 account authenticator.
+Returns this is AccountAuthenticatorEd25519
True if the instance is of type AccountAuthenticatorEd25519, otherwise false.
+
is
- is
Multi Ed25519(): this is AccountAuthenticatorMultiEd25519 Determines if the current instance is of type AccountAuthenticatorMultiEd25519.
+Returns this is AccountAuthenticatorMultiEd25519
True if the instance is a multi-signature Ed25519 account authenticator, otherwise false.
+
is
- is
Multi Key(): this is AccountAuthenticatorMultiKey Determine if the current instance is of type AccountAuthenticatorMultiKey.
+Returns this is AccountAuthenticatorMultiKey
Returns true if the instance is an AccountAuthenticatorMultiKey, otherwise false.
+
is
- is
Single Key(): this is AccountAuthenticatorSingleKey Determines if the current instance is of the type AccountAuthenticatorSingleKey.
+Returns this is AccountAuthenticatorSingleKey
True if the instance is an AccountAuthenticatorSingleKey, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): AccountAuthenticator
Deserializes an AccountAuthenticator from the provided deserializer. +This function helps in reconstructing the AccountAuthenticator object based on the variant index.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns AccountAuthenticator
- deserializer: Deserializer
Staticload
- load(deserializer): AccountAuthenticatorSingleKey
Parameters
- deserializer: Deserializer
Returns AccountAuthenticatorSingleKey
Class AccountPublicKeyAbstract
An abstract representation of an account public key.
+Provides a common interface for deriving an authentication key.
+Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Account Public Key(): AccountPublicKey Returns AccountPublicKey
Methods
Abstractauth
- auth
Key(): AuthenticationKey Get the authentication key associated with this public key
+Returns AuthenticationKey
bcs
bcs
Abstractserialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
Abstractverify
- verify
Signature(args): boolean Verifies that the private key associated with this public key signed the message with the given signature.
+Parameters
- args: VerifySignatureArgs
Returns boolean
Class AccountSequenceNumber
Represents an account's sequence number management for transaction handling on the Aptos blockchain. +This class provides methods to retrieve the next available sequence number, synchronize with the on-chain sequence number, +and manage local sequence numbers while ensuring thread safety.
+ Index
Constructors
Methods
Properties
Constructors
constructor
- new
Account Sequence Number(aptosConfig, account, maxWaitTime, maximumInFlight, sleepTime): AccountSequenceNumber Creates an instance of the class with the specified configuration and account details. +This constructor initializes the necessary parameters for managing Aptos transactions.
+Parameters
- aptosConfig: AptosConfig
The configuration settings for Aptos.
+ - account: Account
The account associated with the Aptos transactions.
+ - maxWaitTime: number
The maximum time to wait for a transaction to be processed, in milliseconds.
+ - maximumInFlight: number
The maximum number of transactions that can be in flight at the same time.
+ - sleepTime: number
The time to sleep between transaction checks, in milliseconds.
+
Returns AccountSequenceNumber
- aptosConfig: AptosConfig
Methods
initialize
next
- next
Sequence Number(): Promise<null | bigint> Returns the next available sequence number for this account. +This function ensures that the sequence number is updated and synchronized, handling potential delays in transaction commits.
+Returns Promise<null | bigint>
The next available sequence number.
+
synchronize
update
Properties
Readonlyaccount
Readonlyaptos
current
last
lock
We want to guarantee that we preserve ordering of workers to requests.
+lock is used to try to prevent multiple coroutines from accessing a shared resource at the same time,
+which can result in race conditions and data inconsistency.
+This code actually doesn't do it though, since we aren't giving out a slot, it is still somewhat a race condition.
The ideal solution is likely that each thread grabs the next number from an incremental integer.
+When they complete, they increment that number and that entity is able to enter the lock.
+That would guarantee ordering.
maximum
max
sleep
Class AnyPublicKey
Represents any public key supported by Aptos.
+Since AIP-55 Aptos supports
+Legacy and Unified authentication keys.
Any unified authentication key is represented in the SDK as AnyPublicKey.
Hierarchy (view full)
- AccountPublicKey
- AnyPublicKey
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Any Public Key(publicKey): AnyPublicKey Creates an instance of the signature class based on the provided signature type. +This allows for the handling of different signature variants such as Ed25519, Secp256k1, and Keyless.
+Parameters
- publicKey: PublicKey
The publicKey object which determines the variant to be used.
+
Returns AnyPublicKey
- publicKey: PublicKey
Methods
auth
- auth
Key(): AuthenticationKey Generates an authentication key from the current instance's byte representation. +This function is essential for creating a unique identifier for authentication purposes.
+Returns AuthenticationKey
The generated authentication key.
+
bcs
bcs
is
is
serialize
- serialize(serializer): void
Serializes the current object using the provided serializer. +This function helps in converting the object into a format suitable for transmission or storage.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
to
verify
- verify
Signature(args): boolean Verifies the provided signature against the given message. +This function helps ensure the integrity and authenticity of the message by confirming that the signature is valid.
+Parameters
- args: VerifySignatureArgs
The arguments for signature verification.
+
Returns boolean
A boolean indicating whether the signature is valid for the given message.
+- args: VerifySignatureArgs
Staticdeserialize
- deserialize(deserializer): AnyPublicKey
Deserializes an AnySignature from the provided deserializer. +This function helps in reconstructing the AnySignature object from its serialized form, allowing for further processing or validation.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns AnyPublicKey
- deserializer: Deserializer
Staticis
- is
Instance(publicKey): publicKey is AnyPublicKey Determines if the provided publicKey is an instance of a valid PublicKey object.
+Parameters
- publicKey: PublicKey
The publicKey to be checked for validity.
+
Returns publicKey is AnyPublicKey
True if the signature is a valid instance; otherwise, false.
+- publicKey: PublicKey
Staticis
- is
Public Key(publicKey): publicKey is AnyPublicKey Determines if the provided public key is an instance of AnyPublicKey.
+Parameters
- publicKey: AccountPublicKey
The public key to check.
+
Returns publicKey is AnyPublicKey
- publicKey: AccountPublicKey
Class AnySignature
Represents a signature that utilizes the SingleKey authentication scheme.
+This class is designed to encapsulate various types of signatures, which can
+only be generated by a SingleKeySigner due to the shared authentication mechanism.
Hierarchy (view full)
- Signature
- AnySignature
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Any Signature(signature): AnySignature Parameters
- signature: Signature
Returns AnySignature
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
Staticdeserialize
- deserialize(deserializer): AnySignature
Parameters
- deserializer: Deserializer
Returns AnySignature
Staticis
- is
Instance(signature): signature is AnySignature Parameters
- signature: Signature
Returns signature is AnySignature
Class Aptos
The main entry point for interacting with the Aptos APIs, +providing access to various functionalities organized into +distinct namespaces.
+To utilize the SDK, instantiate a new Aptos object to gain +access to the complete range of SDK features.
+Example
import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for connecting to the Aptos testnet
const config = new AptosConfig({ network: Network.TESTNET });
// Initialize the Aptos client with the configuration
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error);
+Hierarchy (view full)
- Account
- ANS
- Coin
- DigitalAsset
- Event
- Faucet
- FungibleAsset
- General
- Keyless
- Staking
- Table
- AptosObject
- Omit<Transaction,
| "build"
| "simulate"
| "submit"
| "batch">- Aptos
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Aptos(settings?): Aptos Initializes a new instance of the Aptos client with the provided configuration settings. +This allows you to interact with various Aptos functionalities such as accounts, transactions, and events.
+Parameters
Optionalsettings: AptosConfigConfiguration settings for the Aptos client.
+
Returns Aptos
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a new Aptos client with default settings
const config = new AptosConfig({ network: Network.TESTNET }); // Specify your own settings if needed
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +
Methods
add
- add
Digital Asset Property Transaction(args): Promise<SimpleTransaction> Add a digital asset property to the blockchain. +This function allows you to specify a new property for a digital asset, including its key, type, and value.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
propertyKey: string;
propertyType:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY";
propertyValue: PropertyValue;
}The arguments for adding a digital asset property.
+creator: Account
The account that mints the digital asset.
+digital
Asset Address: AccountAddressInput The digital asset address.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` (Optional) The type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptions(Optional) Options for generating the transaction.
+property
Key: string The property key for storing on-chain properties.
+property
Type:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY"The type of property value.
+property
Value: PropertyValue The property value to be stored on-chain.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Add a digital asset property
const transaction = await aptos.addDigitalAssetPropertyTransaction({
creator: Account.generate(), // Replace with a real account
propertyKey: "newKey",
propertyType: "BOOLEAN",
propertyValue: true,
digitalAssetAddress: "0x123", // Replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
add
- add
Digital Asset Typed Property Transaction(args): Promise<SimpleTransaction> Add a typed digital asset property to the blockchain. +This function allows you to define and store a specific property for a digital asset, enabling better categorization and +management of digital assets.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
propertyKey: string;
propertyType:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY";
propertyValue: PropertyValue;
}The parameters for adding the typed property.
+creator: Account
The account that mints the digital asset.
+digital
Asset Address: AccountAddressInput The digital asset address.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` The optional type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional transaction generation options.
+property
Key: string The property key for storing on-chain properties.
+property
Type:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY"The type of property value.
+property
Value: PropertyValue The property value to be stored on-chain.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Adding a typed digital asset property
const transaction = await aptos.addDigitalAssetTypedPropertyTransaction({
creator: Account.generate(), // replace with a real account
propertyKey: "typedKey",
propertyType: "STRING",
propertyValue: "hello",
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
batch
- batch
Transactions For Single Account(args): Promise<void> Parameters
- args: {
data: InputGenerateTransactionPayloadData[];
options?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">;
sender: Account;
}The arguments for batching transactions.
+data: InputGenerateTransactionPayloadData[]
An array of transaction payloads to be processed.
+Optionaloptions?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">Optional. Transaction generation configurations (excluding accountSequenceNumber).
+sender: Account
The sender account to sign and submit the transactions.
+
Returns Promise<void>
Deprecated
Prefer to use
+aptos.transaction.batch.forSingleAccount()Batch transactions for a single account by submitting multiple transaction payloads. +This function is useful for efficiently processing and submitting transactions that do not depend on each other, such as +batch funding or batch token minting.
+Example
+ +import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
const sender = Account.generate(); // Generate a new account for sending transactions
async function runExample() {
const transactions = [
{ }, // Build your first transaction payload
{ }, // Build your second transaction payload
];
// Batch transactions for the single account
await aptos.batchTransactionsForSingleAccount({
sender,
data: transactions,
});
console.log("Batch transactions submitted successfully.");
}
runExample().catch(console.error); +- args: {
burn
- burn
Digital Asset Transaction(args): Promise<SimpleTransaction> Burn a digital asset by its creator, allowing for the removal of a specified digital asset from the blockchain.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
}The arguments for burning the digital asset.
+creator: Account
The creator account that is burning the digital asset.
+digital
Asset Address: AccountAddressInput The address of the digital asset to be burned.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset being burned.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const creator = Account.generate(); // Replace with a real creator account
const transaction = await aptos.burnDigitalAssetTransaction({
creator: creator,
digitalAssetAddress: "0x123", // Replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
create
- create
Collection Transaction(args): Promise<SimpleTransaction> Creates a new collection within the specified account.
+Parameters
- args: {
creator: Account;
description: string;
name: string;
options?: InputGenerateTransactionOptions;
uri: string;
} & CreateCollectionOptions
Returns Promise<SimpleTransaction>
A SimpleTransaction that when submitted will create the collection.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Creating a new collection transaction
const transaction = await aptos.createCollectionTransaction({
creator: Account.generate(), // Replace with a real account
description: "A unique collection of digital assets.",
name: "My Digital Collection",
uri: "https://mycollection.com",
});
console.log("Transaction created:", transaction);
}
runExample().catch(console.error); +- args: {
derive
- derive
Account From Private Key(args): Promise<Account> Derives an account by providing a private key. This function resolves the provided private key type and derives the public +key from it.
+If the privateKey is a Secp256k1 type, it derives the account using the derived public key and auth key using the SingleKey +scheme locally. +If the privateKey is an ED25519 type, it looks up the authentication key on chain to determine whether it is a Legacy ED25519 +key or a Unified ED25519 key, and then derives the account based on that.
+Parameters
- args: {
privateKey: PrivateKey;
}The arguments for deriving the account.
+private
Key: PrivateKey An account private key.
+
Returns Promise<Account>
The derived Account type.
+Example
+ +import { Aptos, AptosConfig, Network, Ed25519PrivateKey } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Deriving an account from a private key
const account = await aptos.deriveAccountFromPrivateKey({
privateKey: new Ed25519PrivateKey("0x123") // replace with a real private key
});
console.log(account);
}
runExample().catch(console.error); +- args: {
derive
- derive
Keyless Account(args): Promise<KeylessAccount> Parameters
- args: {
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
pepper?: HexInput;
proofFetchCallback?: ProofFetchCallback;
uidKey?: string;
}ephemeral
Key Pair: EphemeralKeyPair jwt: string
Optionalpepper?: HexInputOptionalproofFetch Callback?: ProofFetchCallback OptionaluidKey?: string
Returns Promise<KeylessAccount>
- args: {
- derive
Keyless Account(args): Promise<FederatedKeylessAccount> Parameters
- args: {
ephemeralKeyPair: EphemeralKeyPair;
jwkAddress: AccountAddressInput;
jwt: string;
pepper?: HexInput;
proofFetchCallback?: ProofFetchCallback;
uidKey?: string;
}ephemeral
Key Pair: EphemeralKeyPair jwk
Address: AccountAddressInput jwt: string
Optionalpepper?: HexInputOptionalproofFetch Callback?: ProofFetchCallback OptionaluidKey?: string
Returns Promise<FederatedKeylessAccount>
- args: {
freeze
- freeze
Digital Asset Transafer Transaction(args): Promise<SimpleTransaction> Freeze the ability to transfer a specified digital asset. +This function allows the creator to restrict the transfer capability of a digital asset.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
}The arguments for freezing the digital asset transfer.
+creator: Account
The creator account initiating the freeze.
+digital
Asset Address: AccountAddressInput The address of the digital asset to be frozen.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset being frozen.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Freeze the digital asset transfer
const transaction = await aptos.freezeDigitalAssetTransaferTransaction({
creator: Account.generate(), // Replace with a real account if needed
digitalAssetAddress: "0x123", // Replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
fund
- fund
Account(args): Promise<UserTransactionResponse> This function creates an account if it does not exist and mints the specified amount of coins into that account.
+Parameters
- args: {
accountAddress: AccountAddressInput;
amount: number;
options?: WaitForTransactionOptions;
}The arguments for funding the account.
+account
Address: AccountAddressInput The address of the account to fund.
+amount: number
The amount of tokens to fund the account with.
+Optionaloptions?: WaitForTransactionOptionsConfiguration options for waiting for the transaction.
+
Returns Promise<UserTransactionResponse>
Transaction hash of the transaction that funded the account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fund an account with a specified amount of tokens
const transaction = await aptos.fundAccount({
accountAddress: "0x1", // replace with your account address
amount: 100,
});
console.log("Transaction hash:", transaction.hash);
}
runExample().catch(console.error); +- args: {
get
- get
AccountAPTAmount(args): Promise<number> Retrieves the current amount of APT for a specified account.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The arguments for the account query.
+account
Address: AccountAddressInput The account address for which to retrieve the APT amount.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<number>
The current amount of APT for the specified account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the APT amount for a specific account
const accountAPTAmount = await aptos.getAccountAPTAmount({ accountAddress: "0x1" }); // replace with a real account address
console.log("Account APT Amount:", accountAPTAmount);
}
runExample().catch(console.error); +- args: {
get
- get
Account Coin Amount(args): Promise<number> Queries the current amount of a specified coin held by an account.
+Parameters
- args: {
accountAddress: AccountAddressInput;
coinType?: `${string}::${string}::${string}`;
faMetadataAddress?: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for querying the account's coin amount.
+account
Address: AccountAddressInput The account address to query for the coin amount.
+OptionalcoinType?: `${string}::${string}::${string}` The coin type to query. Note: If not provided, it may be automatically populated if
+faMetadataAddress+is specified.OptionalfaMetadata Address?: AccountAddressInput The fungible asset metadata address to query. Note: If not provided, it may be automatically +populated if
+coinTypeis specified.OptionalminimumLedger Version?: AnyNumber Not used anymore, here for backward compatibility +see https://github.com/aptos-labs/aptos-ts-sdk/pull/519, will be removed in the near future. +Optional ledger version to sync up to before querying.
+
Returns Promise<number>
The current amount of the specified coin held by the account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Query the account's coin amount for a specific coin type
const accountCoinAmount = await aptos.getAccountCoinAmount({
accountAddress: "0x1", // replace with a real account address
coinType: "0x1::aptos_coin::AptosCoin" // specify the coin type
});
console.log(`Account coin amount: ${accountCoinAmount}`);
}
runExample().catch(console.error); +- args: {
get
- get
Account Coins Count(args): Promise<number> Retrieves the current count of an account's coins aggregated across all types.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for the account coins count query.
+account
Address: AccountAddressInput The account address we want to get the total count for.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<number>
The current count of the aggregated coins for the specified account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Getting the account coins count for a specific account
const accountCoinsCount = await aptos.getAccountCoinsCount({ accountAddress: "0x1" }); // replace with a real account address
console.log("Account Coins Count:", accountCoinsCount);
}
runExample().catch(console.error); +- args: {
get
- get
Account Coins Data(args): Promise<{
amount?: any;
asset_type?: null | string;
is_frozen: boolean;
is_primary?: null | boolean;
last_transaction_timestamp?: any;
last_transaction_version?: any;
metadata?: null | {
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
symbol: string;
token_standard: string;
};
owner_address: string;
storage_id: string;
token_standard?: null | string;
}[]> Retrieves the coins data for a specified account.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
amount?: any;
asset_type?: null | string;
is_frozen: boolean;
is_primary?: null | boolean;
last_transaction_timestamp?: any;
last_transaction_version?: any;
metadata?: null | {
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
symbol: string;
token_standard: string;
};
owner_address: string;
storage_id: string;
token_standard?: null | string;
}> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
}account
Address: AccountAddressInput The account address for which to retrieve the coin's data.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
amount?: any;
asset_type?: null | string;
is_frozen: boolean;
is_primary?: null | boolean;
last_transaction_timestamp?: any;
last_transaction_version?: any;
metadata?: null | {
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
symbol: string;
token_standard: string;
};
owner_address: string;
storage_id: string;
token_standard?: null | string;
}> & WhereArg<CurrentFungibleAssetBalancesBoolExp>
Returns Promise<{
amount?: any;
asset_type?: null | string;
is_frozen: boolean;
is_primary?: null | boolean;
last_transaction_timestamp?: any;
last_transaction_version?: any;
metadata?: null | {
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
symbol: string;
token_standard: string;
};
owner_address: string;
storage_id: string;
token_standard?: null | string;
}[]>An array containing the coins data for the specified account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching coins data for a specific account
const accountCoinsData = await aptos.getAccountCoinsData({
accountAddress: "0x1", // replace with a real account address
options: {
limit: 10, // specify the number of results to return
orderBy: { asset_type: "asc" }, // specify the order of results
},
});
console.log(accountCoinsData);
}
runExample().catch(console.error); +- args: {
get
- get
Account Collections With Owned Tokens(args): Promise<{
collection_id?: null | string;
collection_name?: null | string;
collection_uri?: null | string;
creator_address?: null | string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
distinct_tokens?: any;
last_transaction_version?: any;
owner_address?: null | string;
single_token_uri?: null | string;
}[]> Queries for all collections that an account currently has tokens for, including NFTs, fungible tokens, and soulbound tokens. +If you want to filter by a specific token standard, you can pass an optional tokenStandard parameter.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg & PaginationArgs & OrderByArg<{
collection_id?: null | string;
collection_name?: null | string;
collection_uri?: null | string;
creator_address?: null | string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
distinct_tokens?: any;
last_transaction_version?: any;
owner_address?: null | string;
single_token_uri?: null | string;
}>;
}account
Address: AccountAddressInput The account address we want to get the collections for.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArg & PaginationArgs & OrderByArg<{
collection_id?: null | string;
collection_name?: null | string;
collection_uri?: null | string;
creator_address?: null | string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
distinct_tokens?: any;
last_transaction_version?: any;
owner_address?: null | string;
single_token_uri?: null | string;
}>
Returns Promise<{
collection_id?: null | string;
collection_name?: null | string;
collection_uri?: null | string;
creator_address?: null | string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
distinct_tokens?: any;
last_transaction_version?: any;
owner_address?: null | string;
single_token_uri?: null | string;
}[]>Collections array with the collections data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get account collections with owned tokens for a specific account
const accountCollectionsWithOwnedTokens = await aptos.getAccountCollectionsWithOwnedTokens({
accountAddress: "0x1", // replace with a real account address
options: {
tokenStandard: "NFT", // specify the token standard if needed
limit: 10, // specify the number of results to return
},
});
console.log(accountCollectionsWithOwnedTokens);
}
runExample().catch(console.error); +- args: {
get
- get
Account Domains(args): Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]> Fetches all top-level domain names for a specified account.
+Parameters
- args: GetAccountDomainsArgs
The arguments for retrieving account domains.
+
Returns Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]>A promise of an array of ANSName.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching all top-level domain names for a specific account
const domains = await aptos.getAccountDomains({
accountAddress: "0x1", // replace with a real account address
options: {
limit: 10, // specify the number of names to fetch
offset: 0, // specify the offset for pagination
orderBy: "created_at", // specify the order by which to sort the names
where: {
// additional filters can be specified here
},
},
});
console.log(domains);
}
runExample().catch(console.error); +- args: GetAccountDomainsArgs
get
- get
Account Events By Creation Number(args): Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]> Retrieve events associated with a specific account address and creation number.
+Parameters
- args: {
accountAddress: AccountAddressInput;
creationNumber: AnyNumber;
minimumLedgerVersion?: AnyNumber;
}The parameters for retrieving account events.
+account
Address: AccountAddressInput The account address to query events for.
+creation
Number: AnyNumber The event creation number to filter the events.
+OptionalminimumLedger Version?: AnyNumber Optional minimum ledger version to sync up to before querying.
+
Returns Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]>Promise
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get events for the account at creation number 0
const events = await aptos.getAccountEventsByCreationNumber({
accountAddress: "0x1", // replace with a real account address
creationNumber: 0,
});
console.log(events);
}
runExample().catch(console.error); +- args: {
get
- get
Account Events By Event Type(args): Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]> Retrieve events associated with a specific account address and event type.
+Parameters
- args: {
accountAddress: AccountAddressInput;
eventType: `${string}::${string}::${string}`;
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}>;
}account
Address: AccountAddressInput The account address to query events for.
+event
Type: `${string}::${string}::${string}` The type of event to filter by.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}>Optional pagination and ordering parameters for the event query.
+
Returns Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]>Promise
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get events for a specific account and event type
const events = await aptos.getAccountEventsByEventType({
accountAddress: "0x1", // replace with a real account address
eventType: "0x1::transaction_fee::FeeStatement", // replace with a real event type
minimumLedgerVersion: 1, // optional, specify if needed
});
console.log(events);
}
runExample().catch(console.error); +- args: {
get
- get
Account Info(args): Promise<AccountData> Queries the current state for an Aptos account given its account address.
+Parameters
- args: {
accountAddress: AccountAddressInput;
}The arguments for retrieving account information.
+account
Address: AccountAddressInput The Aptos account address to query.
+
Returns Promise<AccountData>
The account data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve account information for a specific address
const accountInfo = await aptos.getAccountInfo({ accountAddress: "0x1" }); // replace with a real account address
console.log(accountInfo);
}
runExample().catch(console.error); +- args: {
get
- get
Account Module(args): Promise<MoveModuleBytecode> Queries for a specific account module given an account address and module name.
+Parameters
- args: {
accountAddress: AccountAddressInput;
moduleName: string;
options?: LedgerVersionArg;
}account
Address: AccountAddressInput The Aptos account address.
+module
Name: string The name of the module.
+Optionaloptions?: LedgerVersionArg
Returns Promise<MoveModuleBytecode>
The account module associated with the specified account address and module name.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the account module for a specific account address and module name
const module = await aptos.getAccountModule({
accountAddress: "0x1", // replace with a real account address
moduleName: "MyModule" // specify the module name
});
console.log(module);
}
runExample().catch(console.error); +- args: {
get
- get
Account Modules(args): Promise<MoveModuleBytecode[]> Queries for all modules in an account given an account address. +This function may call the API multiple times to auto paginate through results.
+Parameters
- args: {
accountAddress: AccountAddressInput;
options?: PaginationArgs & LedgerVersionArg;
}account
Address: AccountAddressInput The Aptos account address to query modules for.
+Optionaloptions?: PaginationArgs & LedgerVersionArg
Returns Promise<MoveModuleBytecode[]>
-
+
- The account modules associated with the specified address. +
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching account modules for a specific account
const accountModules = await aptos.getAccountModules({
accountAddress: "0x1", // replace with a real account address
options: {
offset: 0, // starting from the first module
limit: 10, // limiting to 10 modules
},
});
console.log(accountModules);
}
runExample().catch(console.error); +- args: {
get
- get
Account Names(args): Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]> Fetches all names for an account, including both top-level domains and subdomains.
+Parameters
- args: GetAccountNamesArgs
The arguments for fetching account names.
+
Returns Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]>A promise of an array of ANSName.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetch account names for a specific address
const accountNames = await aptos.getAccountNames({
accountAddress: "0x1", // replace with a real account address
options: {
limit: 10, // specify how many names to fetch
orderBy: "name", // specify the order by which to sort the names
},
});
console.log(accountNames);
}
runExample().catch(console.error); +- args: GetAccountNamesArgs
get
- get
Account Owned Objects(args): Promise<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}[]> Queries an account's owned objects.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}>;
}account
Address: AccountAddressInput The account address we want to get the objects for.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}>
Returns Promise<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}[]>Objects array with the object data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the objects owned by the specified account
const accountOwnedObjects = await aptos.getAccountOwnedObjects({
accountAddress: "0x1", // replace with a real account address
minimumLedgerVersion: 1, // optional, specify if needed
options: {
offset: 0, // optional, specify if needed
limit: 10, // optional, specify if needed
orderBy: "created_at", // optional, specify if needed
},
});
console.log(accountOwnedObjects);
}
runExample().catch(console.error); +- args: {
get
- get
Account Owned Tokens(args): Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}[]> Queries the tokens currently owned by a specified account, including NFTs and fungible tokens. +If desired, you can filter the results by a specific token standard.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg & PaginationArgs & OrderByArg<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>;
}account
Address: AccountAddressInput The account address for which to retrieve owned tokens.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArg & PaginationArgs & OrderByArg<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>
Returns Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}[]>An array of tokens with their respective data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the tokens owned by a specific account
const accountOwnedTokens = await aptos.getAccountOwnedTokens({
accountAddress: "0x1", // replace with a real account address
options: {
limit: 10, // specify how many tokens to return
orderBy: "created_at", // specify the order of the results
},
});
console.log(accountOwnedTokens);
}
runExample().catch(console.error); +- args: {
get
- get
Account Owned Tokens From Collection Address(args): Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}[]> Queries all current tokens of a specific collection that an account owns by the collection address. +This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc. +If you want to get only the token from a specific standard, you can pass an optional tokenStandard parameter.
+Parameters
- args: {
accountAddress: AccountAddressInput;
collectionAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg & PaginationArgs & OrderByArg<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>;
}account
Address: AccountAddressInput The account address we want to get the tokens for.
+collection
Address: AccountAddressInput The address of the collection being queried.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to, before querying.
+Optionaloptions?: TokenStandardArg & PaginationArgs & OrderByArg<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>
Returns Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}[]>Tokens array with the token data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get tokens owned by a specific account in a specific collection
const accountOwnedTokens = await aptos.getAccountOwnedTokensFromCollectionAddress({
accountAddress: "0x1", // replace with a real account address
collectionAddress: "0x2", // replace with a real collection address
});
console.log(accountOwnedTokens);
}
runExample().catch(console.error); +- args: {
get
- get
Account Resource<T>(args): Promise<T> Queries a specific account resource given an account address and resource type.
+Type Parameters
Parameters
- args: {
accountAddress: AccountAddressInput;
options?: LedgerVersionArg;
resourceType: `${string}::${string}::${string}`;
}account
Address: AccountAddressInput The Aptos account address to query.
+Optionaloptions?: LedgerVersionArgresource
Type: `${string}::${string}::${string}` The string representation of an on-chain Move struct type, e.g., "0x1::aptos_coin::AptosCoin".
+
Returns Promise<T>
The account resource of the specified type.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the account resource for a specific account address and resource type
const resource = await aptos.getAccountResource({
accountAddress: "0x1", // replace with a real account address
resourceType: "0x1::aptos_coin::AptosCoin"
});
console.log(resource);
}
runExample().catch(console.error); +- args: {
get
- get
Account Resources(args): Promise<MoveResource[]> Queries all account resources given an account address. +This function may call the API multiple times to auto paginate through results.
+Parameters
- args: {
accountAddress: AccountAddressInput;
options?: PaginationArgs & LedgerVersionArg;
}account
Address: AccountAddressInput The Aptos account address to query resources for.
+Optionaloptions?: PaginationArgs & LedgerVersionArg
Returns Promise<MoveResource[]>
Account resources.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching account resources for a specific account address
const resources = await aptos.getAccountResources({ accountAddress: "0x1" }); // replace with a real account address
console.log(resources);
}
runExample().catch(console.error); +- args: {
get
- get
Account Subdomains(args): Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]> Fetches all subdomain names for a specified account.
+Parameters
- args: GetAccountSubdomainsArgs
The arguments for retrieving subdomains.
+
Returns Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]>A promise of an array of ANSName.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching subdomain names for a specific account
const subdomains = await aptos.getAccountSubdomains({
accountAddress: "0x1", // replace with a real account address
options: {
limit: 10, // specify the number of subdomains to fetch
offset: 0, // specify the offset for pagination
orderBy: "name", // specify the order by which to sort the names
},
});
console.log(subdomains);
}
runExample().catch(console.error); +- args: GetAccountSubdomainsArgs
get
- get
Account Tokens Count(args): Promise<number> Queries the current count of tokens owned by a specified account.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for the query.
+account
Address: AccountAddressInput The account address to query the token count for.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<number>
The current count of tokens owned by the account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the count of tokens owned by the account
const tokensCount = await aptos.getAccountTokensCount({ accountAddress: "0x1" }); // replace with a real account address
console.log(`Tokens Count: ${tokensCount}`);
}
runExample().catch(console.error); +- args: {
get
- get
Account Transactions(args): Promise<TransactionResponse[]> Queries account transactions given an account address. +This function may call the API multiple times to auto paginate and retrieve all account transactions.
+Parameters
- args: {
accountAddress: AccountAddressInput;
options?: PaginationArgs;
}account
Address: AccountAddressInput The Aptos account address to query transactions for.
+Optionaloptions?: PaginationArgsOptional pagination arguments.
+
Returns Promise<TransactionResponse[]>
The account transactions.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetch transactions for a specific account
const transactions = await aptos.getAccountTransactions({
accountAddress: "0x1", // replace with a real account address
options: {
offset: 0, // starting from the first transaction
limit: 10, // limiting to 10 transactions
},
});
console.log(transactions);
}
runExample().catch(console.error); +- args: {
get
- get
Account Transactions Count(args): Promise<number> Queries the current count of transactions submitted by an account.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for the query.
+account
Address: AccountAddressInput The account address we want to get the total count for.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<number>
Current count of transactions made by an account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the count of transactions for a specific account
const accountTransactionsCount = await aptos.getAccountTransactionsCount({
accountAddress: "0x1", // replace with a real account address
minimumLedgerVersion: 1, // specify your own minimum ledger version if needed
});
console.log(accountTransactionsCount);
}
runExample().catch(console.error); +- args: {
get
- get
Block By Height(args): Promise<Block> Retrieve a block by its height, allowing for the inclusion of transactions if specified.
+Parameters
- args: {
blockHeight: AnyNumber;
options?: {
withTransactions?: boolean;
};
}The parameters for the block retrieval.
+block
Height: AnyNumber The block height to look up, starting at 0.
+Optionaloptions?: {
withTransactions?: boolean;
}Optional settings for the retrieval.
+OptionalwithTransactions?: boolean
Returns Promise<Block>
The block with optional transactions included.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve the block at height 5, including transactions
const block = await aptos.getBlockByHeight({ blockHeight: 5, options: { withTransactions: true } });
console.log(block);
}
runExample().catch(console.error); +- args: {
get
- get
Block By Version(args): Promise<Block> Retrieves block information by the specified ledger version.
+Parameters
- args: {
ledgerVersion: AnyNumber;
options?: {
withTransactions?: boolean;
};
}The arguments for retrieving the block.
+ledger
Version: AnyNumber The ledger version to lookup block information for.
+Optionaloptions?: {
withTransactions?: boolean;
}Optional parameters for the request.
+OptionalwithTransactions?: boolean
Returns Promise<Block>
Block information with optional transactions.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve block information for a specific ledger version
const block = await aptos.getBlockByVersion({ ledgerVersion: 5 });
console.log(block);
}
runExample().catch(console.error); +- args: {
get
- get
Chain Id(): Promise<number> Retrieves the chain ID of the Aptos blockchain.
+Returns Promise<number>
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching the chain ID
const chainId = await aptos.getChainId();
console.log("Chain ID:", chainId);
}
runExample().catch(console.error);
@returns The chain ID of the Aptos blockchain. +
get
- get
Chain Top User Transactions(args): Promise<{
version: any;
}[]> Queries the top user transactions based on the specified limit.
+Parameters
- args: {
limit: number;
}The arguments for querying top user transactions.
+limit: number
The number of transactions to return.
+
Returns Promise<{
version: any;
}[]>GetChainTopUserTransactionsResponse
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetch the top user transactions with a limit of 5
const topUserTransactions = await aptos.getChainTopUserTransactions({ limit: 5 });
console.log(topUserTransactions);
}
runExample().catch(console.error); +- args: {
get
- get
Collection Data(args): Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}> Queries data of a specific collection by the collection creator address and the collection name. +This function is deprecated; use
+getCollectionDataByCreatorAddressAndCollectionNameinstead.If a creator account has two collections with the same name in v1 and v2, you can pass an optional
+tokenStandardparameter +to query a specific standard.Parameters
- args: {
collectionName: string;
creatorAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg;
}The arguments for querying the collection data.
+collection
Name: string The name of the collection.
+creator
Address: AccountAddressInput The address of the collection's creator.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArgOptional parameters for the query.
+
Returns Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}>GetCollectionDataResponse - The response type containing the collection data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Querying collection data by creator address and collection name
const collection = await aptos.getCollectionData({
creatorAddress: "0x1", // replace with a real creator address
collectionName: "myCollection", // specify your collection name
});
console.log(collection);
}
runExample().catch(console.error); +- args: {
get
- get
Collection Data By Collection Id(args): Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}> Queries data of a specific collection by the collection ID.
+Parameters
- args: {
collectionId: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg & PaginationArgs;
}collection
Id: AccountAddressInput The ID of the collection, which is the same as the address of the collection object.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArg & PaginationArgsOptional parameters for token standard and pagination.
+
Returns Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}>GetCollectionDataResponse - The response type containing the collection data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching collection data by collection ID
const collection = await aptos.getCollectionDataByCollectionId({
collectionId: "0x123", // replace with a real collection ID
});
console.log(collection);
}
runExample().catch(console.error); +- args: {
get
- get
Collection Data By Creator Address(args): Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}> Retrieves data for a specific collection created by a given creator address. +This function allows you to query collection data while optionally specifying a minimum ledger version and pagination options.
+Parameters
- args: {
creatorAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg & PaginationArgs;
}creator
Address: AccountAddressInput The address of the collection's creator.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArg & PaginationArgs
Returns Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}>GetCollectionDataResponse - The response type containing collection data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve collection data by creator address
const collectionData = await aptos.getCollectionDataByCreatorAddress({
creatorAddress: "0x1", // replace with a real creator address
minimumLedgerVersion: 1, // specify the minimum ledger version if needed
options: {
tokenStandard: "v2", // specify the token standard if needed
pagination: { limit: 10, offset: 0 } // specify pagination options if needed
}
});
console.log(collectionData);
}
runExample().catch(console.error); +- args: {
get
- get
Collection Data By Creator Address And Collection Name(args): Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}> Queries data of a specific collection by the collection creator address and the collection name. +If a creator account has multiple collections with the same name across different versions, +specify the
+tokenStandardparameter to query a specific standard.Parameters
- args: {
collectionName: string;
creatorAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg & PaginationArgs;
}collection
Name: string The name of the collection.
+creator
Address: AccountAddressInput The address of the collection's creator.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArg & PaginationArgs
Returns Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}>GetCollectionDataResponse - The response type containing collection data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching collection data by creator address and collection name
const collection = await aptos.getCollectionDataByCreatorAddressAndCollectionName({
creatorAddress: "0x1", // replace with a real creator address
collectionName: "myCollection",
minimumLedgerVersion: 1, // optional, specify if needed
options: { tokenStandard: "v2" } // optional, specify if needed
});
console.log(collection);
}
runExample().catch(console.error); +- args: {
get
- get
Collection Id(args): Promise<string> Queries the ID of a specified collection. +This ID corresponds to the collection's object address in V2, while V1 does not utilize objects and lacks an address.
+Parameters
- args: {
collectionName: string;
creatorAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg;
}collection
Name: string The name of the collection.
+creator
Address: AccountAddressInput The address of the collection's creator.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArg
Returns Promise<string>
The collection ID.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching the collection ID for a specific creator and collection name
const collectionId = await aptos.getCollectionId({
creatorAddress: "0x1", // replace with a real creator address
collectionName: "myCollection"
});
console.log("Collection ID:", collectionId);
}
runExample().catch(console.error); +- args: {
get
- get
Current Digital Asset Ownership(args): Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}> Retrieves the current ownership data of a specified digital asset using its address.
+Parameters
- args: {
digitalAssetAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for the request.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>GetCurrentTokenOwnershipResponse containing relevant ownership data of the digital asset.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Getting the current ownership of a digital asset
const digitalAssetOwner = await aptos.getCurrentDigitalAssetOwnership({
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(digitalAssetOwner);
}
runExample().catch(console.error); +- args: {
get
- get
Current Fungible Asset Balances(args?): Promise<{
amount?: any;
asset_type?: null | string;
is_frozen: boolean;
is_primary?: null | boolean;
last_transaction_timestamp?: any;
last_transaction_version?: any;
owner_address: string;
storage_id: string;
token_standard?: null | string;
}[]> Queries all fungible asset balances.
+Parameters
Optionalargs: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
}Optional parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to, before querying.
+Optionaloptions?: PaginationArgs & WhereArg<CurrentFungibleAssetBalancesBoolExp>Optional configuration for pagination and filtering.
+
Returns Promise<{
amount?: any;
asset_type?: null | string;
is_frozen: boolean;
is_primary?: null | boolean;
last_transaction_timestamp?: any;
last_transaction_version?: any;
owner_address: string;
storage_id: string;
token_standard?: null | string;
}[]>A list of fungible asset metadata.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching current fungible asset balances
const fungibleAssetBalances = await aptos.getCurrentFungibleAssetBalances();
console.log(fungibleAssetBalances);
}
runExample().catch(console.error); +
get
- get
Delegated Staking Activities(args): Promise<{
amount: any;
delegator_address: string;
event_index: any;
event_type: string;
pool_address: string;
transaction_version: any;
}[]> Queries delegated staking activities for a specific delegator and pool.
+Parameters
- args: {
delegatorAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
poolAddress: AccountAddressInput;
}The arguments for querying delegated staking activities.
+delegator
Address: AccountAddressInput The address of the delegator.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+pool
Address: AccountAddressInput The address of the staking pool.
+
Returns Promise<{
amount: any;
delegator_address: string;
event_index: any;
event_type: string;
pool_address: string;
transaction_version: any;
}[]>The response containing delegated staking activities.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get delegated staking activities for a specific delegator and pool
const activities = await aptos.getDelegatedStakingActivities({
delegatorAddress: "0x1", // replace with a real delegator address
poolAddress: "0x2", // replace with a real pool address
minimumLedgerVersion: 1, // specify your own if needed
});
console.log(activities);
}
runExample().catch(console.error); +- args: {
get
- get
Digital Asset Activity(args): Promise<{
after_value?: null | string;
before_value?: null | string;
entry_function_id_str?: null | string;
event_account_address: string;
event_index: any;
from_address?: null | string;
is_fungible_v2?: null | boolean;
property_version_v1: any;
to_address?: null | string;
token_amount: any;
token_data_id: string;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}[]> Retrieves the activity data for a specified digital asset using its address.
+Parameters
- args: {
digitalAssetAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
after_value?: null | string;
before_value?: null | string;
entry_function_id_str?: null | string;
event_account_address: string;
event_index: any;
from_address?: null | string;
is_fungible_v2?: null | boolean;
property_version_v1: any;
to_address?: null | string;
token_amount: any;
token_data_id: string;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}>;
}The parameters for the request.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionalminimumLedger Version?: AnyNumber Optional minimum ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
after_value?: null | string;
before_value?: null | string;
entry_function_id_str?: null | string;
event_account_address: string;
event_index: any;
from_address?: null | string;
is_fungible_v2?: null | boolean;
property_version_v1: any;
to_address?: null | string;
token_amount: any;
token_data_id: string;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}>Optional pagination and ordering parameters.
+
Returns Promise<{
after_value?: null | string;
before_value?: null | string;
entry_function_id_str?: null | string;
event_account_address: string;
event_index: any;
from_address?: null | string;
is_fungible_v2?: null | boolean;
property_version_v1: any;
to_address?: null | string;
token_amount: any;
token_data_id: string;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}[]>A promise that resolves to the activity data related to the digital asset.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the activity data for a digital asset
const digitalAssetActivity = await aptos.getDigitalAssetActivity({
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(digitalAssetActivity);
}
runExample().catch(console.error); +- args: {
get
- get
Digital Asset Data(args): Promise<{
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
}> Retrieves digital asset data using the address of a digital asset.
+Parameters
- args: {
digitalAssetAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for the request.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<{
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
}>GetTokenDataResponse containing relevant data for the digital asset.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching digital asset data for a specific address
const digitalAsset = await aptos.getDigitalAssetData({
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(digitalAsset);
}
runExample().catch(console.error); +- args: {
get
- get
Domain Subdomains(args): Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]> Fetches all subdomain names for a given domain, excluding the domain itself.
+Parameters
- args: GetDomainSubdomainsArgs
The arguments for fetching subdomains.
+
Returns Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]>A promise that resolves to an array of ANSName.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching subdomains for a specific domain
const subdomains = await aptos.getDomainSubdomains({
domain: "test", // replace with your domain
options: {
limit: 10, // specify the number of subdomains to fetch
offset: 0, // specify the starting point for fetching
orderBy: "name", // specify the order by which to sort the results
},
});
console.log(subdomains);
}
runExample().catch(console.error); +- args: GetDomainSubdomainsArgs
get
- get
Events(args?): Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]> Retrieve all events from the Aptos blockchain. +An optional
+whereclause can be provided to filter the results based on specific criteria.Parameters
Optionalargs: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}> & WhereArg<EventsBoolExp>;
}Optional parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}> & WhereArg<EventsBoolExp>Optional pagination and filtering options.
+
Returns Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]>GetEventsQuery response type containing the events.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve all events
const events = await aptos.getEvents();
// Retrieve events with filtering by account address
const whereCondition = {
account_address: { _eq: "0x123" }, // replace with a real account address
};
const filteredEvents = await aptos.getEvents({
options: { where: whereCondition },
});
console.log(events);
console.log(filteredEvents);
}
runExample().catch(console.error); +
get
- get
Expiration(args): Promise<undefined | number> Retrieve the expiration time of a domain name or subdomain name from the contract.
+Parameters
- args: {
name: string;
}The arguments for retrieving the expiration.
+name: string
A string of the name to retrieve.
+
Returns Promise<undefined | number>
number as a unix timestamp in milliseconds.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the expiration time for the domain "test.aptos"
const exp = await aptos.getExpiration({ name: "test.aptos" });
// Log the expiration date
console.log(new Date(exp)); // Outputs the expiration date
}
runExample().catch(console.error); +- args: {
get
- get
Fungible Asset Activities(args?): Promise<{
amount?: any;
asset_type?: null | string;
block_height: any;
entry_function_id_str?: null | string;
event_index: any;
gas_fee_payer_address?: null | string;
is_frozen?: null | boolean;
is_gas_fee: boolean;
is_transaction_success: boolean;
owner_address?: null | string;
storage_id: string;
storage_refund_amount: any;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}[]> Queries all fungible asset activities and returns a list of their metadata.
+Parameters
Optionalargs: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & WhereArg<FungibleAssetActivitiesBoolExp>;
}Optional parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to, before querying.
+Optionaloptions?: PaginationArgs & WhereArg<FungibleAssetActivitiesBoolExp>Optional configuration for pagination and filtering.
+
Returns Promise<{
amount?: any;
asset_type?: null | string;
block_height: any;
entry_function_id_str?: null | string;
event_index: any;
gas_fee_payer_address?: null | string;
is_frozen?: null | boolean;
is_gas_fee: boolean;
is_transaction_success: boolean;
owner_address?: null | string;
storage_id: string;
storage_refund_amount: any;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}[]>A list of fungible asset metadata.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching fungible asset activities
const fungibleAssetActivities = await aptos.getFungibleAssetActivities();
console.log(fungibleAssetActivities);
}
runExample().catch(console.error); +
get
- get
Fungible Asset Metadata(args?): Promise<{
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
supply_v2?: any;
symbol: string;
token_standard: string;
}[]> Queries all fungible asset metadata.
+Parameters
Optionalargs: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & WhereArg<FungibleAssetMetadataBoolExp>;
}Optional parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & WhereArg<FungibleAssetMetadataBoolExp>Optional configuration for pagination and filtering.
+
Returns Promise<{
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
supply_v2?: any;
symbol: string;
token_standard: string;
}[]>A list of fungible asset metadata.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching fungible asset metadata
const fungibleAssets = await aptos.getFungibleAssetMetadata();
console.log(fungibleAssets);
}
runExample().catch(console.error); +
get
- get
Fungible Asset Metadata By Asset Type(args): Promise<{
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
supply_v2?: any;
symbol: string;
token_standard: string;
}> Queries the fungible asset metadata for a specific asset type. +This function helps retrieve detailed information about a fungible asset based on its type.
+Parameters
Returns Promise<{
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
supply_v2?: any;
symbol: string;
token_standard: string;
}>A fungible asset metadata item.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve fungible asset metadata by asset type
const fungibleAsset = await aptos.getFungibleAssetMetadataByAssetType({
assetType: "0x1::aptos_coin::AptosCoin" // replace with your asset type
});
console.log(fungibleAsset);
}
runExample().catch(console.error); +
get
- get
Fungible Asset Metadata By Creator Address(args): Promise<{
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
supply_v2?: any;
symbol: string;
token_standard: string;
}[]> Retrieves fungible asset metadata based on the creator address.
+This function allows you to query metadata for a specific fungible asset created by a given address.
+Parameters
- args: {
creatorAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for the query.
+creator
Address: AccountAddressInput The creator address of the fungible asset.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<{
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
supply_v2?: any;
symbol: string;
token_standard: string;
}[]>A fungible asset metadata item.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve fungible asset metadata by creator address
const fungibleAsset = await aptos.getFungibleAssetMetadataByCreatorAddress({
creatorAddress: "0x123", // replace with a real creator address
});
console.log(fungibleAsset);
}
runExample().catch(console.error); +- args: {
get
- get
Gas Price Estimation(): Promise<GasEstimation> Estimates the gas unit price required to process a transaction on the Aptos blockchain in a timely manner. +This helps users to understand the cost associated with their transactions. +https://api.mainnet.aptoslabs.com/v1/spec#/operations/estimate_gas_price
+Returns Promise<GasEstimation>
An object containing the estimated gas price.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET }); // Specify your network
const aptos = new Aptos(config);
async function runExample() {
// Getting the gas price estimation
const gasPriceEstimation = await aptos.getGasPriceEstimation();
console.log("Estimated Gas Price:", gasPriceEstimation);
}
runExample().catch(console.error); +
get
- get
Indexer Last Success Version(): Promise<bigint> Queries for the last successful indexer version, providing insight into the ledger version the indexer is updated to, which +may lag behind the full nodes.
+Returns Promise<bigint>
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the last successful indexer version
const version = await aptos.getIndexerLastSuccessVersion();
console.log(`Last successful indexer version: ${version}`);
}
runExample().catch(console.error); +
get
- get
Ledger Info(): Promise<LedgerInfo> Queries for the Aptos ledger information.
+Returns Promise<LedgerInfo>
The Aptos Ledger Info, which includes details such as chain ID, epoch, and ledger version.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching the ledger information
const ledgerInfo = await aptos.getLedgerInfo();
console.log(ledgerInfo);
}
runExample().catch(console.error); +
get
- get
Module Events By Event Type(args): Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]> Retrieve module events based on a specified event type. +This function allows you to query for events that are associated with a particular module event type in the Aptos blockchain.
+Parameters
- args: {
eventType: `${string}::${string}::${string}`;
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}>;
}The arguments for retrieving module events.
+event
Type: `${string}::${string}::${string}` The event type to filter the results.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}>Optional pagination and ordering parameters for the event results.
+
Returns Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]>Promise
+- A promise that resolves to the retrieved events. Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve module events for a specific event type
const events = await aptos.getModuleEventsByEventType({
eventType: "0x1::transaction_fee::FeeStatement", // specify the event type
minimumLedgerVersion: 1, // optional: specify minimum ledger version if needed
});
console.log(events); // log the retrieved events
}
runExample().catch(console.error); +- args: {
get
- get
Name(args): Promise<undefined | {
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}> Fetches a single name from the indexer based on the provided name argument.
+Parameters
- args: {
name: string;
}The arguments for retrieving the name.
+name: string
A string of the name to retrieve, e.g. "test.aptos.apt" or "test.apt" or "test". +Can be inclusive or exclusive of the .apt suffix and can be a subdomain.
+
Returns Promise<undefined | {
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}>A promise of an ANSName or undefined if the name is not active.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching a name from the indexer
const name = await aptos.getName({ name: "test.aptos" }); // replace with a real name
console.log(name);
}
runExample().catch(console.error); +- args: {
get
- get
Number Of Delegators(args): Promise<number> Queries the current number of delegators in a specified pool. Throws an error if the pool is not found.
+Parameters
- args: {
minimumLedgerVersion?: AnyNumber;
poolAddress: AccountAddressInput;
}The parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+pool
Address: AccountAddressInput The address of the pool to query.
+
Returns Promise<number>
The number of delegators for the given pool.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the number of delegators for a specific pool
const delegators = await aptos.getNumberOfDelegators({ poolAddress: "0x1" }); // replace with a real pool address
console.log(`Number of delegators: ${delegators}`);
}
runExample().catch(console.error); +- args: {
get
- get
Number Of Delegators For All Pools(args?): Promise<{
num_active_delegator?: any;
pool_address?: null | string;
}[]> Retrieves the current number of delegators across all pools.
+Parameters
Optionalargs: {
minimumLedgerVersion?: AnyNumber;
options?: OrderByArg<{
num_active_delegator?: any;
pool_address?: null | string;
}>;
}Optional parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: OrderByArg<{
num_active_delegator?: any;
pool_address?: null | string;
}>Optional ordering options for the response.
+
Returns Promise<{
num_active_delegator?: any;
pool_address?: null | string;
}[]>GetNumberOfDelegatorsForAllPoolsResponse response type containing the number of delegators per pool.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve the number of delegators for all pools
const delegators = await aptos.getNumberOfDelegatorsForAllPools();
console.log(delegators);
}
runExample().catch(console.error); +
get
- get
Object Data By Object Address(args): Promise<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}> Fetches the object data based on the specified object address.
+Parameters
- args: {
minimumLedgerVersion?: AnyNumber;
objectAddress: AccountAddressInput;
options?: PaginationArgs & OrderByArg<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}>;
}OptionalminimumLedger Version?: AnyNumber Optional minimum ledger version to wait for.
+object
Address: AccountAddressInput The object address to retrieve data for.
+Optionaloptions?: PaginationArgs & OrderByArg<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}>Optional configuration options for pagination and ordering.
+
Returns Promise<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}>The object data corresponding to the provided address.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching object data by object address
const objectData = await aptos.getObjectDataByObjectAddress({
objectAddress: "0x1", // replace with a real object address
});
console.log(objectData);
}
runExample().catch(console.error); +- args: {
get
- get
Owned Digital Assets(args): Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}[]> Retrieves the digital assets owned by a specified address.
+Parameters
- args: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>;
ownerAddress: AccountAddressInput;
}OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>Optional pagination and ordering parameters for the response.
+owner
Address: AccountAddressInput The address of the owner.
+
Returns Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}[]>GetOwnedTokensResponse containing ownership data of the digital assets belonging to the ownerAddress.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching the digital assets owned by the specified address
const digitalAssets = await aptos.getOwnedDigitalAssets({
ownerAddress: "0x1", // replace with a real account address
});
console.log(digitalAssets);
}
runExample().catch(console.error); +- args: {
get
- get
Owner Address(args): Promise<undefined | AccountAddress> Retrieve the owner address of a specified domain name or subdomain name from the contract.
+Parameters
- args: {
name: string;
}The arguments for retrieving the owner address.
+name: string
A string representing the name of the domain or subdomain to retrieve the owner address for.
+
Returns Promise<undefined | AccountAddress>
AccountAddress if the name is owned, undefined otherwise.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve the owner address of "test.aptos"
const owner = await aptos.getOwnerAddress({ name: "test.aptos" });
console.log(owner); // Logs the owner address or undefined if not owned
}
runExample().catch(console.error); +- args: {
get
- get
Pepper(args): Promise<Uint8Array> Fetches the pepper from the Aptos pepper service API.
+Parameters
- args: {
derivationPath?: string;
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
}The arguments for fetching the pepper.
+OptionalderivationPath?: string A derivation path used for creating multiple accounts per user via the BIP-44 standard. Defaults +to "m/44'/637'/0'/0'/0".
+ephemeral
Key Pair: EphemeralKeyPair The EphemeralKeyPair used to generate the nonce in the JWT token.
+jwt: string
JWT token.
+
Returns Promise<Uint8Array>
The pepper which is a Uint8Array of length 31.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const ephemeralKeyPair = new EphemeralKeyPair(); // create a new ephemeral key pair
const jwt = "your_jwt_token"; // replace with a real JWT token
// Fetching the pepper using the provided JWT and ephemeral key pair
const pepper = await aptos.getPepper({
jwt,
ephemeralKeyPair,
// derivationPath: "m/44'/637'/0'/0'/0" // specify your own if needed
});
console.log("Fetched pepper:", pepper);
}
runExample().catch(console.error); +- args: {
get
- get
Primary Name(args): Promise<undefined | string> Retrieve the primary name for an account. An account can have multiple names, but only one primary name, which may not exist.
+Parameters
- args: {
address: AccountAddressInput;
}The arguments for retrieving the primary name.
+address: AccountAddressInput
An AccountAddressInput (address) of the account.
+
Returns Promise<undefined | string>
A string if the account has a primary name, undefined otherwise.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve the primary name for the specified account address
const name = await aptos.getPrimaryName({ address: "0x1" }); // replace with a real account address
console.log(name);
}
runExample().catch(console.error); +- args: {
get
- get
Processor Status(processorType): Promise<{
last_success_version: any;
last_updated: any;
processor: string;
}> Query the processor status for a specific processor type.
+Parameters
- processorType: ProcessorType
The processor type to query.
+
Returns Promise<{
last_success_version: any;
last_updated: any;
processor: string;
}>The status of the specified processor type.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the processor status for the account transactions processor
const status = await aptos.getProcessorStatus("account_transactions_processor");
console.log(status);
}
runExample().catch(console.error); +- processorType: ProcessorType
get
- get
Proof(args): Promise<ZeroKnowledgeSig> Fetches a proof from the Aptos prover service API.
+Parameters
- args: {
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
pepper?: HexInput;
uidKey?: string;
}The arguments for fetching the proof.
+ephemeral
Key Pair: EphemeralKeyPair The EphemeralKeyPair used to generate the nonce in the JWT token.
+jwt: string
JWT token.
+Optionalpepper?: HexInputThe pepper used for the account. If not provided, it will be fetched from the Aptos pepper service.
+OptionaluidKey?: string A key in the JWT token to use to set the uidVal in the IdCommitment.
+
Returns Promise<ZeroKnowledgeSig>
The proof which is represented by a ZeroKnowledgeSig.
+Example
+ +import { Aptos, AptosConfig, Network, EphemeralKeyPair, getPepper } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const jwt = "your_jwt_token"; // replace with a real JWT token
const ephemeralKeyPair = new EphemeralKeyPair(); // create a new ephemeral key pair
// Fetch the proof using the getProof function
const proof = await aptos.getProof({
jwt,
ephemeralKeyPair,
pepper: await getPepper({}), // fetch the pepper if not provided
uidKey: "sub", // specify the uid key
});
console.log("Fetched proof:", proof);
}
runExample().catch(console.error); +- args: {
get
- get
Signing Message(args): Uint8Array Returns a signing message for a transaction, allowing a user to sign it using their preferred method before submission to the network.
+Parameters
- args: {
transaction: AnyRawTransaction;
}The arguments for obtaining the signing message.
+transaction: AnyRawTransaction
A raw transaction for signing elsewhere.
+
Returns Uint8Array
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const transaction = await aptos.transaction.build.simple({
sender: "0x1", // replace with a real sender address
data: {
function: "0x1::aptos_account::transfer",
functionArguments: ["0x2", 100], // replace with a real destination address
},
});
const message = await aptos.getSigningMessage({ transaction });
console.log(message);
}
runExample().catch(console.error); +- args: {
get
- get
Table Item<T>(args): Promise<T> Queries for a specific item in a table identified by the handle and the key for the item. +This function allows you to retrieve structured data from a table in the Aptos blockchain.
+Type Parameters
Parameters
- args: {
data: TableItemRequest;
handle: string;
options?: LedgerVersionArg;
}data: TableItemRequest
Object that describes the table item, including key and value types.
+handle: string
A pointer to where that table is stored.
+Optionaloptions?: LedgerVersionArg
Returns Promise<T>
Table item value rendered in JSON.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve a table item from the Aptos blockchain
const tableItem = await aptos.getTableItem({
handle: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca",
data: {
key_type: "address", // Move type of table key
value_type: "u128", // Move type of table value
key: "0x619dc29a0aac8fa146714058e8dd6d2d0f3bdf5f6331907bf91f3acd81e6935" // Value of table key
},
});
console.log(tableItem);
}
runExample().catch(console.error); +- args: {
get
- get
Table Items Data(args): Promise<{
decoded_key: any;
decoded_value?: any;
key: string;
table_handle: string;
transaction_version: any;
write_set_change_index: any;
}[]> Queries for table items data with optional filtering and pagination. +This function allows you to retrieve specific data from a table based on provided criteria.
+Parameters
- args: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & WhereArg<TableItemsBoolExp> & OrderByArg<{
decoded_key: any;
decoded_value?: any;
key: string;
table_handle: string;
transaction_version: any;
write_set_change_index: any;
}>;
}The arguments for querying table items data.
+OptionalminimumLedger Version?: AnyNumber Optional minimum ledger version to wait for before querying.
+Optionaloptions?: PaginationArgs & WhereArg<TableItemsBoolExp> & OrderByArg<{
decoded_key: any;
decoded_value?: any;
key: string;
table_handle: string;
transaction_version: any;
write_set_change_index: any;
}>Optional parameters for pagination and filtering.
+
Returns Promise<{
decoded_key: any;
decoded_value?: any;
key: string;
table_handle: string;
transaction_version: any;
write_set_change_index: any;
}[]>GetTableItemsDataResponse
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve table items data with specific filtering options
const data = await aptos.getTableItemsData({
minimumLedgerVersion: 1, // specify your own minimum ledger version if needed
options: {
where: {
table_handle: { _eq: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca" },
transaction_version: { _eq: "0" }
},
limit: 10, // specify your own limit if needed
},
});
console.log(data);
}
runExample().catch(console.error); +- args: {
get
- get
Table Items Metadata(args): Promise<{
handle: string;
key_type: string;
value_type: string;
}[]> Queries for the metadata of table items, allowing for filtering and pagination.
+Parameters
- args: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & WhereArg<TableMetadatasBoolExp> & OrderByArg<{
handle: string;
key_type: string;
value_type: string;
}>;
}The parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional minimum ledger version to wait for before querying.
+Optionaloptions?: PaginationArgs & WhereArg<TableMetadatasBoolExp> & OrderByArg<{
handle: string;
key_type: string;
value_type: string;
}>Optional parameters for pagination and filtering.
+
Returns Promise<{
handle: string;
key_type: string;
value_type: string;
}[]>GetTableItemsMetadataResponse
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching table items metadata with a filter condition
const data = await aptos.getTableItemsMetadata({
minimumLedgerVersion: 1, // specify your own minimum ledger version if needed
options: {
where: { handle: { _eq: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca" } },
limit: 10, // specify your own limit if needed
},
});
console.log(data);
}
runExample().catch(console.error); +- args: {
get
- get
Target Address(args): Promise<undefined | AccountAddress> Retrieve the target address of a domain or subdomain name, which indicates the address the name points to for use on-chain. +Note that the target address can point to addresses that do not own the name.
+Parameters
- args: {
name: string;
}The arguments for retrieving the target address.
+name: string
A string representing the name, which can be a primary name, a subdomain, or a combination (e.g., +"primary", "primary.apt", "secondary.primary", "secondary.primary.apt").
+
Returns Promise<undefined | AccountAddress>
AccountAddress if the name has a target, undefined otherwise.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve the target address for the specified domain name
const targetAddr = await aptos.getTargetAddress({ name: "test.aptos" });
console.log(targetAddr); // Logs the target address, e.g., 0x123...
}
runExample().catch(console.error); +- args: {
get
- get
Transaction By Hash(args): Promise<TransactionResponse> Queries on-chain transactions by their transaction hash, returning both pending and committed transactions.
+Parameters
Returns Promise<TransactionResponse>
The transaction from the mempool (pending) or the on-chain (committed) transaction.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetch a transaction by its hash
const transaction = await aptos.getTransactionByHash({ transactionHash: "0x123" }); // replace with a real transaction hash
console.log(transaction);
}
runExample().catch(console.error); +
get
- get
Transaction By Version(args): Promise<TransactionResponse> Queries on-chain transaction by version. This function will not return pending transactions.
+Parameters
Returns Promise<TransactionResponse>
On-chain transaction. Only on-chain transactions have versions, so this +function cannot be used to query pending transactions.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching a transaction by its version
const transaction = await aptos.getTransactionByVersion({ ledgerVersion: 1 }); // replace 1 with a real version
console.log(transaction);
}
runExample().catch(console.error); +
get
- get
Transactions(args?): Promise<TransactionResponse[]> Queries on-chain transactions, excluding pending transactions. +Use this function to retrieve historical transactions from the blockchain.
+Parameters
Optionalargs: {
options?: PaginationArgs;
}Optional parameters for pagination.
+Optionaloptions?: PaginationArgsOptional pagination options.
+
Returns Promise<TransactionResponse[]>
An array of on-chain transactions.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetch transactions with pagination
const transactions = await aptos.getTransactions({
options: {
offset: 0, // Start from the first transaction
limit: 10, // Limit to 10 results
},
});
console.log(transactions);
}
runExample().catch(console.error); +
is
- is
Pending Transaction(args): Promise<boolean> Defines if the specified transaction is currently in a pending state. +This function helps you determine the status of a transaction using its hash.
+Parameters
Returns Promise<boolean>
+trueif the transaction is in a pending state andfalseotherwise.Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Check if the transaction is pending using its hash
const isPendingTransaction = await aptos.isPendingTransaction({ transactionHash: "0x123" }); // replace with a real transaction hash
console.log("Is the transaction pending?", isPendingTransaction);
}
runExample().catch(console.error); +
lookup
- lookup
Original Account Address(args): Promise<AccountAddress> Looks up the account address for a given authentication key, handling both rotated and non-rotated keys.
+Parameters
- args: {
authenticationKey: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: LedgerVersionArg;
}authentication
Key: AccountAddressInput The authentication key for which to look up the account address.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: LedgerVersionArg
Returns Promise<AccountAddress>
Promise
+- The account address associated with the authentication key. Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Look up the original account address for a given authentication key
const accountAddress = await aptos.lookupOriginalAccountAddress({
authenticationKey: "0x1", // replace with a real authentication key
});
console.log("Original Account Address:", accountAddress);
}
runExample().catch(console.error); +- args: {
mint
- mint
Digital Asset Transaction(args): Promise<SimpleTransaction> Create a transaction to mint a digital asset into the creator's account within an existing collection. +This function helps you generate a transaction that can be simulated or submitted to the blockchain for minting a digital asset.
+Parameters
- args: {
collection: string;
creator: Account;
description: string;
name: string;
options?: InputGenerateTransactionOptions;
propertyKeys?: string[];
propertyTypes?: (
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY")[];
propertyValues?: PropertyValue[];
uri: string;
}collection: string
The name of the collection the digital asset belongs to.
+creator: Account
The creator of the collection.
+description: string
The description of the digital asset.
+name: string
The name of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional transaction generation options.
+OptionalpropertyKeys?: string[] Optional array of property keys for the digital asset.
+OptionalpropertyTypes?: (
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY")[]Optional array of property types for the digital asset.
+OptionalpropertyValues?: PropertyValue[] Optional array of property values for the digital asset.
+uri: string
The URI to additional info about the digital asset.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Creating a transaction to mint a digital asset
const transaction = await aptos.mintDigitalAssetTransaction({
creator: Account.generate(), // replace with a real account
collection: "MyCollection",
description: "This is a digital asset.",
name: "MyDigitalAsset",
uri: "https://example.com/my-digital-asset",
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
mint
- mint
Soul Bound Transaction(args): Promise<SimpleTransaction> Mint a soul bound digital asset into a recipient's account. +This function allows you to create a unique digital asset that is bound to a specific account.
+Parameters
- args: {
account: Account;
collection: string;
description: string;
name: string;
options?: InputGenerateTransactionOptions;
propertyKeys?: string[];
propertyTypes?: (
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY")[];
propertyValues?: PropertyValue[];
recipient: AccountAddressInput;
uri: string;
}The arguments for minting the soul bound transaction.
+account: Account
The account that mints the digital asset.
+collection: string
The collection name that the digital asset belongs to.
+description: string
The digital asset description.
+name: string
The digital asset name.
+Optionaloptions?: InputGenerateTransactionOptionsAdditional options for generating the transaction.
+OptionalpropertyKeys?: string[] The property keys for storing on-chain properties.
+OptionalpropertyTypes?: (
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY")[]The type of property values.
+OptionalpropertyValues?: PropertyValue[] The property values to be stored on-chain.
+recipient: AccountAddressInput
The account address where the digital asset will be created.
+uri: string
The digital asset URL.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Mint a soul bound digital asset
const transaction = await aptos.mintSoulBoundTransaction({
account: Account.generate(), // Replace with a real account
collection: "collectionName",
description: "collectionDescription",
name: "digitalAssetName",
uri: "digital-asset-uri.com",
recipient: "0x123" // Replace with a real recipient account address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
publish
- publish
Package Transaction(args): Promise<SimpleTransaction> Generates a transaction to publish a Move package to the blockchain. +This function helps you create a transaction that can be simulated or submitted to the chain for publishing a package.
+To get the
+metadataBytesandbyteCode, can compile using Aptos CLI with command +aptos move compile --save-metadata ...,https://aptos.dev/tutorials/your-first-dapp/#step-4-publish-a-move-module
+Parameters
- args: {
account: AccountAddressInput;
metadataBytes: HexInput;
moduleBytecode: HexInput[];
options?: InputGenerateTransactionOptions;
}The arguments for publishing the package.
+account: AccountAddressInput
The publisher account.
+metadata
Bytes: HexInput The package metadata bytes.
+module
Bytecode: HexInput[] An array of the bytecode of each module in the package in compiler output order.
+Optionaloptions?: InputGenerateTransactionOptionsOptional settings for generating the transaction.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Replace with a real account address
const account = "0x1";
const metadataBytes = "0x..."; // replace with real metadata bytes
const byteCode = "0x..."; // replace with real module bytecode
const transaction = await aptos.publishPackageTransaction({
account,
metadataBytes,
moduleBytecode: [byteCode],
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
query
- query
Indexer<T>(args): Promise<T> Retrieves data from the Aptos Indexer using a GraphQL query. +This function allows you to execute complex queries to fetch specific data from the Aptos blockchain.
+Type Parameters
Parameters
- args: {
query: GraphqlQuery;
}query: GraphqlQuery
Returns Promise<T>
The provided T type.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Querying the Aptos Indexer for ledger information
const topUserTransactions = await aptos.queryIndexer({
query: `query MyQuery {
ledger_infos {
chain_id
}
}`
});
console.log(topUserTransactions);
}
runExample().catch(console.error); +- args: {
register
- register
Name(args): Promise<SimpleTransaction> Registers a new name.
+This function allows you to register a domain or subdomain name with specific expiration policies and options.
+Parameters
- args: Omit<RegisterNameParameters, "aptosConfig">
Returns Promise<SimpleTransaction>
SimpleTransaction
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Registering a subdomain name assuming def.apt is already registered and belongs to the sender alice.
const txn = await aptos.registerName({
sender: "0x1", // replace with a real sender account
name: "test.aptos.apt",
expiration: {
policy: "subdomain:independent",
expirationDate: Date.now() + 30 * 24 * 60 * 60 * 1000, // expires in 30 days
},
});
console.log("Transaction:", txn);
}
runExample().catch(console.error); +
remove
- remove
Digital Asset Property Transaction(args): Promise<SimpleTransaction> Remove a digital asset property from the blockchain. +This function allows you to delete an existing property associated with a digital asset.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
propertyKey: string;
propertyType:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY";
propertyValue: PropertyValue;
}The parameters required to remove the digital asset property.
+creator: Account
The account that mints the digital asset.
+digital
Asset Address: AccountAddressInput The digital asset address.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+property
Key: string The property key for storing on-chain properties.
+property
Type:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY"The type of property value.
+property
Value: PropertyValue The property value to be stored on-chain.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Remove a digital asset property
const transaction = await aptos.removeDigitalAssetPropertyTransaction({
creator: Account.generate(), // replace with a real account
propertyKey: "newKey",
propertyType: "BOOLEAN",
propertyValue: true,
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
renew
- renew
Domain(args): Promise<SimpleTransaction> Renews a domain name for one year. +If a domain name was minted with V1 of the contract, it will automatically be upgraded to V2 via this transaction.
+Parameters
- args: {
name: string;
options?: InputGenerateTransactionOptions;
sender: Account;
years?: 1;
}The arguments for renewing the domain.
+name: string
A string representing the domain to renew. Subdomains cannot be renewed.
+Optionaloptions?: InputGenerateTransactionOptionsOptional transaction options.
+sender: Account
The sender account, which must be the domain owner.
+Optionalyears?: 1The number of years to renew the name. Currently, only one year is permitted.
+
Returns Promise<SimpleTransaction>
SimpleTransaction
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Renew the domain "test" for one year
const transaction = await aptos.renewDomain({
sender: Account.generate(), // replace with a real account
name: "test"
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
rotate
- rotate
Auth Key(args): Promise<TransactionResponse> Rotate an account's authentication key. After rotation, only the new private key can be used to sign transactions for the account. +Note: Only legacy Ed25519 scheme is supported for now. +More info: https://aptos.dev/guides/account-management/key-rotation/
+Parameters
- args: {
fromAccount: Account;
toNewPrivateKey: PrivateKey;
}The arguments for rotating the auth key.
+from
Account: Account The account to rotate the auth key for.
+to
New Private Key: PrivateKey The new private key to rotate to.
+
Returns Promise<TransactionResponse>
PendingTransactionResponse
+Example
+ +import { Aptos, AptosConfig, Network, Account, PrivateKey } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Rotate the authentication key for an account
const response = await aptos.rotateAuthKey({
// replace with a real account
fromAccount: Account.generate(),
// replace with a real private key
toNewPrivateKey: new PrivateKey("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"),
});
console.log(response);
}
runExample().catch(console.error); +- args: {
set
- set
Digital Asset Description Transaction(args): Promise<SimpleTransaction> Set the digital asset description to provide additional context or information about the asset.
+Parameters
- args: {
creator: Account;
description: string;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
}The parameters for setting the digital asset description.
+creator: Account
The creator account responsible for the digital asset.
+description: string
The digital asset description to be set.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Set the digital asset description
const transaction = await aptos.setDigitalAssetDescriptionTransaction({
creator: Account.generate(), // replace with a real account
description: "This is a digital asset description.",
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
set
- set
Digital Asset Name Transaction(args): Promise<SimpleTransaction> Set the digital asset name, allowing you to define a name for a specific digital asset on the blockchain.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
name: string;
options?: InputGenerateTransactionOptions;
}The parameters for setting the digital asset name.
+creator: Account
The creator account responsible for the transaction.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset, represented as a Move struct ID.
+name: string
The desired name for the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the blockchain.
+Example
+ +import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const creator = Account.generate(); // Generate a new account for the creator
const digitalAssetAddress = "0x123"; // replace with a real digital asset address
// Set the digital asset name
const transaction = await aptos.setDigitalAssetNameTransaction({
creator: creator,
name: "digitalAssetName",
digitalAssetAddress: digitalAssetAddress,
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
set
- set
Digital AssetURITransaction(args): Promise<SimpleTransaction> Set the URI for a digital asset, allowing you to associate a unique identifier with the asset.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
uri: string;
}The parameters for the transaction.
+creator: Account
The creator account initiating the transaction.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+uri: string
The digital asset URI to be set.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Set the URI for a digital asset
const transaction = await aptos.setDigitalAssetURITransaction({
creator: Account.generate(), // Replace with a real creator account
uri: "digital-asset-uri.com",
digitalAssetAddress: "0x123", // Replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
set
- set
Primary Name(args): Promise<SimpleTransaction> Sets the primary name for the sender account, allowing them to designate a single primary name among potentially multiple +names. An account may not have a primary name.
+Parameters
- args: {
name?: string;
options?: InputGenerateTransactionOptions;
sender: Account;
}The arguments for setting the primary name.
+Optionalname?: stringA string representing the name to set as primary (e.g., "test.aptos").
+Optionaloptions?: InputGenerateTransactionOptionsOptional transaction options.
+sender: Account
The sender account.
+
Returns Promise<SimpleTransaction>
SimpleTransaction
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Set the primary name for the sender account
const sender = Account.generate(); // replace with a real account
await aptos.setPrimaryName({ sender, name: "test.aptos" });
const primaryName = await aptos.getPrimaryName({ address: sender.accountAddress });
console.log("Primary Name:", primaryName); // Should log: "Primary Name: test.aptos"
}
runExample().catch(console.error); +- args: {
set
- set
Target Address(args): Promise<SimpleTransaction> Sets the target address of a domain or subdomain name, pointing it to a specified address for use on-chain. +The target address can be different from the owner of the name.
+Parameters
- args: {
address: AccountAddressInput;
name: string;
options?: InputGenerateTransactionOptions;
sender: Account;
}The arguments for setting the target address.
+address: AccountAddressInput
The AccountAddressInput of the address to set the domain or subdomain to.
+name: string
A string representing the domain or subdomain name (e.g., "test.aptos").
+Optionaloptions?: InputGenerateTransactionOptionsOptional settings for generating the transaction.
+sender: Account
The account initiating the transaction.
+
Returns Promise<SimpleTransaction>
SimpleTransaction
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Setting the target address for a domain name
const sender = Account.generate(); // replace with a real account
const address = "0x1"; // replace with a real account address
await aptos.setTargetAddress({
sender: sender,
name: "test.aptos",
address: address,
});
const targetAddress = await aptos.getTargetAddress({ name: "test.aptos" });
console.log(targetAddress); // Should log the address set for "test.aptos"
}
runExample().catch(console.error); +- args: {
sign
- sign(args): AccountAuthenticator
Sign a transaction that can later be submitted to the chain. +This function is essential for ensuring the authenticity of the transaction by using the provided account's signing capabilities.
+Parameters
- args: {
signer: Account;
transaction: AnyRawTransaction;
}The arguments for signing the transaction.
+signer: Account
The account that will sign the transaction.
+transaction: AnyRawTransaction
A raw transaction to sign.
+
Returns AccountAuthenticator
AccountAuthenticator - The authenticator for the signed transaction.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const sender = Account.generate(); // Generate a new account for signing
const transaction = await aptos.transaction.build.simple({
sender: sender.accountAddress,
data: {
function: "0x1::aptos_account::transfer",
functionArguments: [ "0x1", 100 ], // replace with a real account address and amount
},
});
const signedTransaction = await aptos.transaction.sign({
signer: sender,
transaction,
}); // Sign the transaction
console.log("Signed Transaction:", signedTransaction);
}
runExample().catch(console.error); +- args: {
sign
- sign
And Submit As Fee Payer(args): Promise<PendingTransactionResponse> Sign and submit a single signer transaction as the fee payer to chain given an authenticator by the sender of the transaction.
+Parameters
- args: {
feePayer: Account;
senderAuthenticator: AccountAuthenticator;
transaction: AnyRawTransaction;
}fee
Payer: Account The fee payer account to sign the transaction
+sender
Authenticator: AccountAuthenticator The AccountAuthenticator signed by the sender of the transaction
+transaction: AnyRawTransaction
An instance of a RawTransaction, plus optional secondary/fee payer addresses
+
Returns Promise<PendingTransactionResponse>
PendingTransactionResponse
+Example
+ +const transaction = await aptos.transaction.build.simple({sender: alice.accountAddress, feePayer: true ...})
const senderAuthenticator = alice.signTransactionWithAuthenticator(transaction)
const pendingTransaction = await aptos.signAndSubmitAsFeePayer({
senderAuthenticator,
feePayer: bob,
transaction,
}) +- args: {
sign
- sign
And Submit Transaction(args): Promise<PendingTransactionResponse> Sign and submit a single signer transaction to the blockchain. +This function allows you to execute a transaction after signing it with the specified account.
+Parameters
- args: FeePayerOrFeePayerAuthenticatorOrNeither & {
signer: Account;
transaction: AnyRawTransaction;
}The arguments for signing and submitting the transaction.
+
Returns Promise<PendingTransactionResponse>
PendingTransactionResponse
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const sender = Account.generate(); // Generate a new account for sending the transaction
const transaction = await aptos.transaction.build.simple({
sender: sender.accountAddress,
data: {
function: "0x1::aptos_account::transfer",
functionArguments: [ "0x1", 100 ], // replace with a real account address
},
});
// Sign and submit the transaction
const pendingTransaction = await aptos.signAndSubmitTransaction({
signer: sender,
transaction,
});
console.log(pendingTransaction);
}
runExample().catch(console.error); +- args: FeePayerOrFeePayerAuthenticatorOrNeither & {
sign
- sign
As Fee Payer(args): AccountAuthenticator Sign a transaction as a fee payer that can later be submitted to the chain. +This function ensures that the transaction is marked with the fee payer's address, allowing it to be processed correctly.
+Parameters
- args: {
signer: Account;
transaction: AnyRawTransaction;
}The arguments for signing the transaction.
+signer: Account
The fee payer signer account.
+transaction: AnyRawTransaction
A raw transaction to sign on. This transaction must include a
+feePayerAddressproperty.
Returns AccountAuthenticator
AccountAuthenticator - The authenticator for the signed transaction.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const sender = Account.generate(); // Generate a new account for the fee payer
const transaction = await aptos.transaction.build.simple({
// All transactions on Aptos are implemented via smart contracts.
function: "0x1::aptos_account::transfer",
functionArguments: [sender.accountAddress, 100],
feePayerAddress: sender.accountAddress, // Set the fee payer address
});
const signedTransaction = await aptos.transaction.signAsFeePayer({
signer: sender,
transaction,
});
console.log("Signed transaction as fee payer:", signedTransaction);
}
runExample().catch(console.error); +- args: {
transfer
- transfer
Coin Transaction(args): Promise<SimpleTransaction> Generate a transfer coin transaction that can be simulated, signed, and submitted. +This function helps you create a transaction to transfer a specified amount of coins +from one account to another within the Aptos network.
+Parameters
- args: {
amount: AnyNumber;
coinType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
recipient: AccountAddressInput;
sender: AccountAddressInput;
}The arguments for the transfer transaction.
+amount: AnyNumber
The amount of coins to transfer.
+OptionalcoinType?: `${string}::${string}::${string}` Optional. The coin struct type to transfer. Defaults to 0x1::aptos_coin::AptosCoin.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+recipient: AccountAddressInput
The recipient account address.
+sender: AccountAddressInput
The sender account address.
+
Returns Promise<SimpleTransaction>
SimpleTransaction
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Generate a transfer coin transaction
const transaction = await aptos.transferCoinTransaction({
sender: "0x1", // replace with a real sender account address
recipient: "0x2", // replace with a real recipient account address
amount: 10,
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
transfer
- transfer
Digital Asset Transaction(args): Promise<SimpleTransaction> Transfer ownership of a non-fungible digital asset. +This function allows you to transfer a digital asset only if it is not frozen, meaning the ownership transfer is not disabled.
+Parameters
- args: {
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
recipient: AccountAddress;
sender: Account;
}The arguments for transferring the digital asset.
+digital
Asset Address: AccountAddressInput The address of the digital asset being transferred.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset, defaults to "0x4::token::Token".
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+recipient: AccountAddress
The account address of the recipient.
+sender: Account
The sender account of the current digital asset owner.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Transfer a digital asset
const transaction = await aptos.transferDigitalAssetTransaction({
sender: Account.generate(), // replace with a real sender account
digitalAssetAddress: "0x123", // replace with a real digital asset address
recipient: "0x456", // replace with a real recipient account address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
transfer
- transfer
Fungible Asset(args): Promise<SimpleTransaction> Transfer a specified amount of fungible asset from the sender's primary store to the recipient's primary store. +This method allows you to transfer any fungible asset, including fungible tokens.
+Parameters
- args: {
amount: AnyNumber;
fungibleAssetMetadataAddress: AccountAddressInput;
options?: InputGenerateTransactionOptions;
recipient: AccountAddressInput;
sender: Account;
}The arguments for the transfer operation.
+amount: AnyNumber
The number of assets to transfer.
+fungible
Asset Metadata Address: AccountAddressInput The fungible asset account address. For example, if you’re transferring USDT, +this would be the USDT address.
+Optionaloptions?: InputGenerateTransactionOptionsOptional parameters for generating the transaction.
+recipient: AccountAddressInput
The recipient account address.
+sender: Account
The sender account.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Transfer fungible asset from sender to recipient
const transaction = await aptos.transferFungibleAsset({
sender: Account.generate(), // replace with a real sender account
fungibleAssetMetadataAddress: "0x123", // replace with a real fungible asset address
recipient: "0x456", // replace with a real recipient account
amount: 5
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
unfreeze
- unfreeze
Digital Asset Transafer Transaction(args): Promise<SimpleTransaction> Unfreeze the ability to transfer a digital asset. +This function allows the specified creator account to unfreeze the transfer of a digital asset identified by its address.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
}The parameters for unfreezing the digital asset transfer.
+creator: Account
The creator account that is unfreezing the digital asset transfer.
+digital
Asset Address: AccountAddressInput The address of the digital asset to unfreeze.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset being unfrozen.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Unfreeze the ability to transfer a digital asset
const transaction = await aptos.unfreezeDigitalAssetTransaferTransaction({
creator: Account.generate(), // replace with a real creator account
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
update
- update
Digital Asset Property Transaction(args): Promise<SimpleTransaction> Update a digital asset property on-chain.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
propertyKey: string;
propertyType:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY";
propertyValue: PropertyValue;
}The parameters for updating the digital asset property.
+creator: Account
The account that mints the digital asset.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+property
Key: string The property key for storing on-chain properties.
+property
Type:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY"The type of property value.
+property
Value: PropertyValue The property value to be stored on-chain.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Update a digital asset property
const transaction = await aptos.updateDigitalAssetPropertyTransaction({
creator: Account.generate(), // replace with a real account
propertyKey: "newKey",
propertyType: "BOOLEAN",
propertyValue: false,
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
update
- update
Digital Asset Typed Property Transaction(args): Promise<SimpleTransaction> Update a typed digital asset property on-chain. +This function allows you to modify the properties of a digital asset, enabling dynamic updates to its attributes.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
propertyKey: string;
propertyType:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY";
propertyValue: PropertyValue;
}The arguments for updating the digital asset property.
+creator: Account
The account that mints the digital asset.
+digital
Asset Address: AccountAddressInput The digital asset address.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` (Optional) The type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptions(Optional) Additional options for generating the transaction.
+property
Key: string The property key for storing on-chain properties.
+property
Type:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY"The type of property value.
+property
Value: PropertyValue The property value to be stored on-chain.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Update a typed digital asset property
const transaction = await aptos.updateDigitalAssetTypedPropertyTransaction({
creator: Account.generate(), // replace with a real account
propertyKey: "typedKey",
propertyType: "U8",
propertyValue: 2,
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
update
- update
Federated Keyless Jwk Set Transaction(args): Promise<SimpleTransaction> This installs a set of FederatedJWKs at an address for a given iss.
+It will fetch the JSON Web Keyset (JWK) set from the well-known endpoint and update the FederatedJWKs at the sender's address +to reflect it.
+Parameters
- args: {
iss: string;
jwksUrl?: string;
options?: InputGenerateTransactionOptions;
sender: Account;
}iss: string
the iss claim of the federated OIDC provider.
+OptionaljwksUrl?: string the URL to find the corresponding JWKs. For supported IDP providers this parameter in not necessary.
+Optionaloptions?: InputGenerateTransactionOptionssender: Account
The account that will install the JWKs
+
Returns Promise<SimpleTransaction>
The pending transaction that results from submission.
+- args: {
view
- view<T>(args): Promise<T>
Queries for a Move view function
+Type Parameters
- T extends MoveValue[]
Parameters
- args: {
options?: LedgerVersionArg;
payload: InputViewFunctionData;
}Optionaloptions?: LedgerVersionArgpayload: InputViewFunctionData
Payload for the view function
+
Returns Promise<T>
an array of Move values
+
view
- view
Json<T>(args): Promise<T> Queries for a Move view function with JSON, this provides compatability with the old
+aptospackageType Parameters
- T extends MoveValue[]
Parameters
- args: {
options?: LedgerVersionArg;
payload: InputViewFunctionJsonData;
}Optionaloptions?: LedgerVersionArgpayload: InputViewFunctionJsonData
Payload for the view function
+
Returns Promise<T>
an array of Move values
+
wait
- wait
For Transaction(args): Promise<CommittedTransactionResponse> Waits for a transaction to move past the pending state and provides the transaction response. +There are 4 cases.
+-
+
- Transaction is successfully processed and committed to the chain.
+
-
+
- The function will resolve with the transaction response from the API. +
+ - Transaction is rejected for some reason, and is therefore not committed to the blockchain.
+
-
+
- The function will throw an AptosApiError with an HTTP status code indicating some problem with the request. +
+ - Transaction is committed but execution failed, meaning no changes were
+written to the blockchain state.
+
-
+
- If
checkSuccessis true, the function will throw a FailedTransactionError +IfcheckSuccessis false, the function will resolve with the transaction response where thesuccessfield is false.
+
+ - If
- Transaction does not move past the pending state within
args.options.timeoutSecsseconds. +-
+
- The function will throw a WaitForTransactionError +
+
Parameters
- args: {
options?: WaitForTransactionOptions;
transactionHash: HexInput;
}Optionaloptions?: WaitForTransactionOptionsOptional parameters for waiting behavior.
+transaction
Hash: HexInput The hash of a transaction previously submitted to the blockchain.
+
Returns Promise<CommittedTransactionResponse>
The transaction on-chain response.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Wait for a transaction to complete using its hash
const transactionHash = "0x123"; // replace with a real transaction hash
const transactionResponse = await aptos.waitForTransaction({
transactionHash,
options: {
timeoutSecs: 30, // specify your own timeout if needed
checkSuccess: true,
},
});
console.log(transactionResponse);
}
runExample().catch(console.error); +- Transaction is successfully processed and committed to the chain.
+
Class AptosApiError
Represents an error returned from the Aptos API. +This class encapsulates the details of the error, including the request URL, response status, and additional data.
+Hierarchy (view full)
- Error
- AptosApiError
Index
Methods
Properties
Properties
Readonlydata
message
name
Readonlyrequest
Optionalstack
Readonlystatus
Readonlystatus
Readonlyurl
Static Optionalprepare
Optional override for formatting stack traces
+Staticstack
Class AptosConfig
Represents the configuration settings for an Aptos SDK client instance. +This class allows customization of various endpoints and client settings.
+Example
import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for connecting to the Aptos testnet
const config = new AptosConfig({ network: Network.TESTNET });
// Initialize the Aptos client with the configuration
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error);
+ Index
Constructors
Methods
Properties
Constructors
constructor
- new
Aptos Config(settings?): AptosConfig Initializes an instance of the Aptos client with the specified settings. +This allows users to configure various aspects of the client, such as network and endpoints.
+Parameters
Optionalsettings: AptosSettingsOptional configuration settings for the Aptos client.
+
Returns AptosConfig
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a new Aptos client with default settings
const config = new AptosConfig({ network: Network.TESTNET }); // Specify the network
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +
Methods
get
- get
Request Url(apiType): string Returns the URL endpoint to send the request to based on the specified API type. +If a custom URL was provided in the configuration, that URL is returned. Otherwise, the URL endpoint is derived from the network.
+Parameters
- apiType: AptosApiType
The type of Aptos API to get the URL for. This can be one of the following: FULLNODE, FAUCET, INDEXER, PEPPER, PROVER.
+
Returns string
Example
+ +import { Aptos, AptosConfig, Network, AptosApiType } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Getting the request URL for the FULLNODE API
const url = config.getRequestUrl(AptosApiType.FULLNODE);
console.log("Request URL for FULLNODE:", url);
}
runExample().catch(console.error); +- apiType: AptosApiType
is
- is
Pepper Service Request(url): boolean Checks if the provided URL is a known pepper service endpoint.
+Parameters
- url: string
The URL to check against the known pepper service endpoints.
+
Returns boolean
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const url = "https://example.pepper.service"; // replace with a real pepper service URL
// Check if the URL is a known pepper service endpoint
const isPepperService = config.isPepperServiceRequest(url);
console.log(`Is the URL a known pepper service? ${isPepperService}`);
}
runExample().catch(console.error); +- url: string
is
- is
Prover Service Request(url): boolean Checks if the provided URL is a known prover service endpoint.
+Parameters
- url: string
The URL to check against known prover service endpoints.
+
Returns boolean
A boolean indicating whether the URL is a known prover service endpoint.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
// Check if the URL is a known prover service endpoint
const url = "https://prover.testnet.aptos.dev"; // replace with a real URL if needed
const isProver = config.isProverServiceRequest(url);
console.log(`Is the URL a known prover service? ${isProver}`); +- url: string
Properties
Readonlyclient
The client instance the SDK uses. Defaults to `@aptos-labs/aptos-client
+Optional Readonlyclient
Optional client configurations
+Optional Readonlyfaucet
The optional hardcoded faucet URL to send requests to instead of using the network
+Optional Readonlyfaucet
Optional specific Faucet configurations
+Optional Readonlyfullnode
The optional hardcoded fullnode URL to send requests to instead of using the network
+Optional Readonlyfullnode
Optional specific Fullnode configurations
+Optional Readonlyindexer
The optional hardcoded indexer URL to send requests to instead of using the network
+Optional Readonlyindexer
Optional specific Indexer configurations
+Readonlynetwork
The Network that this SDK is associated with. Defaults to DEVNET
+Optional Readonlypepper
The optional hardcoded pepper service URL to send requests to instead of using the network
+Optional Readonlyprover
The optional hardcoded prover service URL to send requests to instead of using the network
+Class AuthenticationKey
Represents an authentication key used for account management. Each account stores an authentication key that enables account +owners to rotate their private key(s) without changing the address that hosts their account. The authentication key is a +SHA3-256 hash of data and is always 32 bytes in length.
+Hierarchy (view full)
- Serializable
- AuthenticationKey
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Authentication Key(args): AuthenticationKey Creates an instance of the AuthenticationKey using the provided hex input. +This ensures that the hex input is valid and conforms to the required length for an Authentication Key.
+Parameters
Returns AuthenticationKey
Methods
bcs
bcs
derived
- derived
Address(): AccountAddress Derives an account address from an AuthenticationKey by translating the AuthenticationKey bytes directly to an AccountAddress.
+Returns AccountAddress
AccountAddress - The derived account address.
+
serialize
- serialize(serializer): void
Serializes the fixed bytes data into a format suitable for transmission or storage.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
to
Staticdeserialize
- deserialize(deserializer): AuthenticationKey
Deserialize an AuthenticationKey from the byte buffer in a Deserializer instance.
+Parameters
- deserializer: Deserializer
The deserializer to deserialize the AuthenticationKey from.
+
Returns AuthenticationKey
An instance of AuthenticationKey.
+- deserializer: Deserializer
Staticfrom
- from
Public Key(args): AuthenticationKey Converts a PublicKey to an AuthenticationKey using the derivation scheme inferred from the provided PublicKey instance.
+Parameters
- args: {
publicKey: AccountPublicKey;
}The arguments for the function.
+public
Key: AccountPublicKey The PublicKey to be converted.
+
Returns AuthenticationKey
AuthenticationKey - The derived AuthenticationKey.
+- args: {
Staticfrom
- from
Public Key And Scheme(args): AuthenticationKey Derives an AuthenticationKey from the provided public key using a specified derivation scheme.
+Parameters
- args: {
publicKey: AccountPublicKey;
scheme: AuthenticationKeyScheme;
}The arguments for deriving the authentication key.
+public
Key: AccountPublicKey The public key used for the derivation.
+scheme: AuthenticationKeyScheme
The scheme to use for deriving the authentication key.
+
Returns AuthenticationKey
- args: {
Staticfrom
- from
Scheme And Bytes(args): AuthenticationKey Generates an AuthenticationKey from the specified scheme and input bytes. +This function is essential for creating a valid authentication key based on a given scheme.
+Parameters
- args: {
input: HexInput;
scheme: AuthenticationKeyScheme;
}The arguments for generating the AuthenticationKey.
+input: HexInput
The input data in hexadecimal format to derive the key.
+scheme: AuthenticationKeyScheme
The authentication key scheme to use.
+
Returns AuthenticationKey
An instance of AuthenticationKey containing the generated key data.
+- args: {
Class Bool
Represents a boolean value that can be serialized and deserialized. +This class extends the Serializable class and provides methods to serialize +the boolean value for different contexts, such as entry functions and script functions.
+Hierarchy (view full)
- Serializable
- Bool
Implements
Index
Methods
bcs
bcs
deserialize
- deserialize(deserializer): U256
Deserializes a U256 value from the provided deserializer.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the U256 data.
+
Returns U256
- deserializer: Deserializer
serialize
- serialize(serializer): void
Serializes the value using the provided serializer. +This function is essential for converting the value into a format suitable for transmission or storage.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serializes the current instance for use in an entry function by converting it to a byte sequence. +This allows the instance to be properly formatted for serialization in transactions.
+Parameters
- serializer: Serializer
The serializer instance used to serialize the byte sequence.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serializes the current instance for use in a script function. +This allows for the conversion of the instance into a format suitable for transmission or storage.
+Parameters
- serializer: Serializer
The serializer used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer): Bool
Parameters
- deserializer: Deserializer
Returns Bool
Class ChainId
Represents a ChainId that can be serialized and deserialized.
+Hierarchy (view full)
- Serializable
- ChainId
Index
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the current object using the provided serializer. +This function helps in converting the object into a format suitable for transmission or storage.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer): ChainId
Deserializes a ChainId from the provided deserializer. +This function allows you to reconstruct a ChainId object from serialized data.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns ChainId
- deserializer: Deserializer
Class Deserializer
A class that provides methods for deserializing various data types from a byte buffer. +It supports deserialization of primitive types, strings, and complex objects using a BCS (Binary Common Serialization) layout.
+ Constructors
constructor
- new
Deserializer(data): Deserializer Creates a new instance of the class with a copy of the provided data buffer. +This prevents outside mutation of the buffer.
+Parameters
- data: Uint8Array
The data to be copied into the internal buffer as a Uint8Array.
+
Returns Deserializer
- data: Uint8Array
Methods
deserialize
- deserialize<T>(cls): T
Helper function that primarily exists to support alternative syntax for deserialization. +That is, if we have a
+const deserializer: new Deserializer(...), instead of having to use +MyClass.deserialize(deserializer), we can calldeserializer.deserialize(MyClass).Type Parameters
Parameters
- cls: Deserializable<T>
The BCS-deserializable class to deserialize the buffered bytes into.
+
Returns T
the deserialized value of class type T
+- cls: Deserializable<T>
deserialize
deserialize
- deserialize
Bytes(): Uint8Array Deserializes an array of bytes.
+The BCS layout for "bytes" consists of a bytes_length followed by the bytes themselves, where bytes_length is a u32 integer +encoded as a uleb128 integer, indicating the length of the bytes array.
+Returns Uint8Array
The deserialized array of bytes.
+
deserialize
deserialize
- deserialize
Option(type): undefined | string Deserializes an optional value from the buffer.
+The BCS layout for Optional
+starts with a boolean byte (0 if none, 1 if some), +followed by the value if present. Parameters
- type: "string"
Either a Deserializable class or one of the string literals: "string", "bytes", or "fixedBytes"
+
Returns undefined | string
The deserialized value if present, undefined otherwise
+Example
+ +// Deserialize an optional string
const deserializer = new Deserializer(new Uint8Array([1, 3, 97, 98, 99]));
const optStr = deserializer.deserializeOption("string");
// optStr === "abc"
// Deserialize an optional custom type
const deserializer = new Deserializer(new Uint8Array([0]));
const optValue = deserializer.deserializeOption(MyClass);
// optValue === undefined
// Deserialize optional bytes
const deserializer = new Deserializer(new Uint8Array([1, 3, 1, 2, 3]));
const optBytes = deserializer.deserializeOption("bytes");
// optBytes === Uint8Array[1, 2, 3]
// Deserialize optional fixed bytes
const deserializer = new Deserializer(new Uint8Array([1, 1, 2, 3, 4]));
const optBytes = deserializer.deserializeOption("fixedBytes", 4);
// optBytes === Uint8Array[1, 2, 3, 4] +- type: "string"
- deserialize
Option(type): undefined | Uint8Array Parameters
- type: "bytes"
Returns undefined | Uint8Array
- deserialize
Option(type, len): undefined | Uint8Array Parameters
- type: "fixedBytes"
- len: number
Returns undefined | Uint8Array
- deserialize
Option<T>(type): undefined | T Type Parameters
Parameters
- type: Deserializable<T>
Returns undefined | T
deserialize
- deserialize
Str(): string Returns string
Deprecated
use
+deserializeOptioninstead. +Deserializes a UTF-8 encoded string from a byte array. It first reads the length of the string in bytes, +followed by the actual byte content, and decodes it into a string.BCS layout for "string": string_length | string_content +where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
+
deserialize
deserialize
deserialize
deserialize
deserialize
deserialize
deserialize
deserialize
- deserialize
Vector<T>(cls): T[] Deserializes an array of BCS Deserializable values given an existing Deserializer instance with a loaded byte buffer.
+Type Parameters
Parameters
- cls: Deserializable<T>
The BCS-deserializable class to deserialize the buffered bytes into.
+
Returns T[]
An array of deserialized values of type T.
+Example
+ +// serialize a vector of addresses
const addresses = new Array<AccountAddress>(
AccountAddress.from("0x1"),
AccountAddress.from("0x2"),
AccountAddress.from("0xa"),
AccountAddress.from("0xb"),
);
const serializer = new Serializer();
serializer.serializeVector(addresses);
const serializedBytes = serializer.toUint8Array();
// deserialize the bytes into an array of addresses
const deserializer = new Deserializer(serializedBytes);
const deserializedAddresses = deserializer.deserializeVector(AccountAddress);
// deserializedAddresses is now an array of AccountAddress instances +- cls: Deserializable<T>
remaining
Class Ed25519Account
Represents an Ed25519 account that provides signing capabilities through an Ed25519 private key. +This class allows for the creation of accounts, signing messages and transactions, and verifying signatures.
+Note: Generating an instance of this class does not create the account on-chain.
+Implements
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Ed25519 Account(args): Ed25519Account Creates an instance of the Ed25519Signer with the specified parameters. +This constructor initializes the private key, public key, and account address for the signer.
+Parameters
- args: Ed25519SignerConstructorArgs
The constructor arguments for the Ed25519Signer.
+
Returns Ed25519Account
- args: Ed25519SignerConstructorArgs
Methods
sign
- sign(message): Ed25519Signature
Sign the given message using the account's Ed25519 private key.
+Parameters
- message: HexInput
The message to be signed in HexInput format.
+
Returns Ed25519Signature
Signature - The resulting signature of the signed message.
+- message: HexInput
sign
- sign
Transaction(transaction): Ed25519Signature Sign the given transaction using the available signing capabilities. +This function helps ensure that the transaction is properly authenticated before submission.
+Parameters
- transaction: AnyRawTransaction
The transaction to be signed.
+
Returns Ed25519Signature
Signature - The resulting signature for the transaction.
+- transaction: AnyRawTransaction
sign
- sign
Transaction With Authenticator(transaction): AccountAuthenticatorEd25519 Sign a transaction using the account's Ed25519 private key. +This function returns an AccountAuthenticator that contains the signature of the transaction along with the account's public key.
+Parameters
- transaction: AnyRawTransaction
The raw transaction to be signed.
+
Returns AccountAuthenticatorEd25519
An AccountAuthenticator containing the signature and the public key.
+- transaction: AnyRawTransaction
sign
- sign
With Authenticator(message): AccountAuthenticatorEd25519 Sign a message using the account's Ed25519 private key. +This function returns an AccountAuthenticator containing the signature along with the account's public key.
+Parameters
- message: HexInput
The signing message, represented as hexadecimal input.
+
Returns AccountAuthenticatorEd25519
An AccountAuthenticator containing the signature and the account's public key.
+- message: HexInput
verify
- verify
Signature(args): boolean Verify the given message and signature with the public key.
+Parameters
- args: VerifyEd25519SignatureArgs
The arguments for verifying the signature.
+
Returns boolean
A boolean indicating whether the signature is valid.
+- args: VerifyEd25519SignatureArgs
Staticfrom
- from
Derivation Path(args): Ed25519Account Derives an Ed25519 account using a specified BIP44 path and mnemonic seed phrase.
+Parameters
- args: Ed25519SignerFromDerivationPathArgs
The arguments for deriving the account.
+
Returns Ed25519Account
- args: Ed25519SignerFromDerivationPathArgs
Staticgenerate
- generate(): Ed25519Account
Generates a new Ed25519 account using a randomly generated private key. +This function is useful for creating a signer that can be used for cryptographic operations.
+Returns Ed25519Account
The newly generated Ed25519 account.
+
Class Ed25519PrivateKey
Represents the private key of an Ed25519 key pair.
+Hierarchy (view full)
- Serializable
- Ed25519PrivateKey
Implements
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Ed25519 Private Key(hexInput, strict?): Ed25519PrivateKey Create a new PrivateKey instance from a Uint8Array or String.
+ +Parameters
- hexInput: HexInput
HexInput (string or Uint8Array)
+ Optionalstrict: booleanIf true, private key must AIP-80 compliant.
+
Returns Ed25519PrivateKey
- hexInput: HexInput
Methods
bcs
bcs
public
- public
Key(): Ed25519PublicKey Derive the Ed25519PublicKey for this private key.
+Returns Ed25519PublicKey
Ed25519PublicKey - The derived public key corresponding to the private key.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
sign
- sign(message): Ed25519Signature
Sign the given message with the private key. +This function generates a digital signature for the specified message, ensuring its authenticity and integrity.
+Parameters
- message: HexInput
A message as a string or Uint8Array in HexInput format.
+
Returns Ed25519Signature
A digital signature for the provided message.
+- message: HexInput
toAIP80
to
to
to
to
Staticdeserialize
- deserialize(deserializer): Ed25519PrivateKey
Parameters
- deserializer: Deserializer
Returns Ed25519PrivateKey
Staticfrom
- from
Derivation Path(path, mnemonics): Ed25519PrivateKey Derives a private key from a mnemonic seed phrase using a specified BIP44 path. +To derive multiple keys from the same phrase, change the path
+IMPORTANT: Ed25519 supports hardened derivation only, as it lacks a key homomorphism, making non-hardened derivation impossible.
+Parameters
- path: string
The BIP44 path used for key derivation.
+ - mnemonics: string
The mnemonic seed phrase from which the key will be derived.
+
Returns Ed25519PrivateKey
- path: string
Staticgenerate
- generate(): Ed25519PrivateKey
Generate a new random private key.
+Returns Ed25519PrivateKey
Ed25519PrivateKey A newly generated Ed25519 private key.
+
Staticis
- is
Private Key(privateKey): privateKey is Ed25519PrivateKey Determines if the provided private key is an instance of Ed25519PrivateKey.
+Parameters
- privateKey: PrivateKey
The private key to check.
+
Returns privateKey is Ed25519PrivateKey
A boolean indicating whether the private key is an Ed25519PrivateKey.
+- privateKey: PrivateKey
Properties
Static ReadonlyLENGTH
Length of an Ed25519 private key
+Static ReadonlySLIP_
The Ed25519 key seed to use for BIP-32 compatibility +See more https://github.com/satoshilabs/slips/blob/master/slip-0010.md
+Class Ed25519PublicKey
Represents the public key of an Ed25519 key pair.
+Since AIP-55 Aptos supports
+Legacy and Unified authentication keys.
Ed25519 scheme is represented in the SDK as Legacy authentication key and also
+as AnyPublicKey that represents any Unified authentication key.
Hierarchy (view full)
- AccountPublicKey
- Ed25519PublicKey
Index
Constructors
constructor
- new
Ed25519 Public Key(hexInput): Ed25519PublicKey Creates an instance of the Ed25519Signature class from a hex input. +This constructor validates the length of the signature to ensure it meets the required specifications.
+Parameters
- hexInput: HexInput
The hex input representing the Ed25519 signature.
+
Returns Ed25519PublicKey
- hexInput: HexInput
Methods
auth
- auth
Key(): AuthenticationKey Generates an authentication key from the public key using the Ed25519 scheme. +This function is essential for creating a secure authentication key that can be used for further cryptographic operations.
+Returns AuthenticationKey
The generated authentication key.
+
bcs
bcs
serialize
- serialize(serializer): void
Serializes the data into a byte array using the provided serializer. +This allows for the conversion of data into a format suitable for transmission or storage.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
to
verify
- verify
Signature(args): boolean Verifies a signed message using a public key.
+Parameters
- args: VerifySignatureArgs
The arguments for verification.
+
Returns boolean
- args: VerifySignatureArgs
Staticdeserialize
- deserialize(deserializer): Ed25519PublicKey
Deserialize bytes into an Ed25519Signature object. +This function is used to convert serialized byte data into a usable Ed25519Signature instance.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the byte data.
+
Returns Ed25519PublicKey
- deserializer: Deserializer
Staticis
- is
Instance(publicKey): publicKey is Ed25519PublicKey Determines if the provided public key is a valid Ed25519 public key. +This function checks for the presence of the "key" property and verifies that its data length matches the expected length +for Ed25519 public keys.
+Parameters
- publicKey: PublicKey
The public key to validate.
+
Returns publicKey is Ed25519PublicKey
A boolean indicating whether the public key is a valid Ed25519 public key.
+- publicKey: PublicKey
Staticis
- is
Public Key(publicKey): publicKey is Ed25519PublicKey Determine if the provided public key is an instance of Ed25519PublicKey.
+Parameters
- publicKey: AccountPublicKey
The public key to check.
+
Returns publicKey is Ed25519PublicKey
True if the public key is an instance of Ed25519PublicKey, otherwise false.
+- publicKey: AccountPublicKey
Class Ed25519Signature
Represents a signature of a message signed using an Ed25519 private key.
+Hierarchy (view full)
- Signature
- Ed25519Signature
Index
Constructors
constructor
- new
Ed25519 Signature(hexInput): Ed25519Signature Parameters
- hexInput: HexInput
Returns Ed25519Signature
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
Staticdeserialize
- deserialize(deserializer): Ed25519Signature
Parameters
- deserializer: Deserializer
Returns Ed25519Signature
Class EntryFunction
Represents an entry function that can be serialized and deserialized. +This class encapsulates the details required to invoke a function within a module, +including the module name, function name, type arguments, and function arguments.
+ Index
Constructors
Methods
Properties
Constructors
constructor
- new
Entry Function(module_name, function_name, type_args, args): EntryFunction Contains the payload to run a function within a module.
+Parameters
- module_name: ModuleId
Fully qualified module name in format "account_address::module_name" e.g. "0x1::coin"
+ - function_name: Identifier
The function name. e.g "transfer"
+ - type_args: TypeTag[]
Type arguments that move function requires.
+ - args: EntryFunctionArgument[]
arguments to the move function.
+
Returns EntryFunction
- module_name: ModuleId
Methods
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
Staticbuild
- build(module_id, function_name, type_args, args): EntryFunction
Build an EntryFunction payload from raw primitive values.
+Parameters
- module_id: `${string}::${string}`
Fully qualified module name in the format "AccountAddress::module_id", e.g., "0x1::coin".
+ - function_name: string
The name of the function to be called.
+ - type_args: TypeTag[]
Type arguments that the Move function requires.
+ - args: EntryFunctionArgument[]
Arguments to the Move function.
+
Returns EntryFunction
EntryFunction
+Example
A coin transfer function has one type argument "CoinType".
+
+ +public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64) +A coin transfer function has three arguments "from", "to", and "amount".
+
+ +public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64) +- module_id: `${string}::${string}`
Staticdeserialize
- deserialize(deserializer): EntryFunction
Deserializes an entry function payload with the arguments represented as EntryFunctionBytes instances.
+Parameters
- deserializer: Deserializer
Returns EntryFunction
A deserialized EntryFunction payload for a transaction.
+See
EntryFunctionBytes
+NOTE: When you deserialize an EntryFunction payload with this method, the entry function +arguments are populated into the deserialized instance as type-agnostic, raw fixed bytes +in the form of the EntryFunctionBytes class.
+In order to correctly deserialize these arguments as their actual type representations, you +must know the types of the arguments beforehand and deserialize them yourself individually.
+One way you could achieve this is by using the ABIs for an entry function and deserializing each +argument as its given, corresponding type.
+
Class EntryFunctionBytes
This class exists solely to represent a sequence of fixed bytes as a serialized entry function, because +serializing an entry function appends a prefix that's only used for entry function arguments.
+NOTE: Using this class for serialized script functions will lead to erroneous and unexpected behavior.
+If you wish to convert this class back to a TransactionArgument, you must know the type +of the argument beforehand, and use the appropriate class to deserialize the bytes within +an instance of this class.
+Hierarchy (view full)
- Serializable
- EntryFunctionBytes
Implements
Index
Methods
Properties
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the value using the provided serializer. +This function is essential for accurately representing a sequence of bytes that are already BCS-serialized as a type.
+Note that to see the Move, BCS-serialized representation of the underlying fixed byte vector, +we must not serialize the length prefix.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serializes the current instance for use as an entry function argument by converting the underlying fixed byte vector to a +type-agnostic byte vector. +This process includes serializing the length prefix of the byte vector.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer, length): EntryFunctionBytes
The only way to create an instance of this class is to use this static method. +This function should only be used when deserializing a sequence of EntryFunctionPayload arguments.
+Parameters
- deserializer: Deserializer
The deserializer instance with the buffered bytes.
+ - length: number
The length of the bytes to deserialize.
+
Returns EntryFunctionBytes
An instance of this class, which will now only be usable as an EntryFunctionArgument.
+- deserializer: Deserializer
Class EphemeralCertificate
Represents an ephemeral certificate containing a signature, specifically a ZeroKnowledgeSig. +This class can be extended to support additional signature types, such as OpenIdSignature.
+Hierarchy (view full)
- Signature
- EphemeralCertificate
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Ephemeral Certificate(signature, variant): EphemeralCertificate Returns EphemeralCertificate
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
Staticdeserialize
- deserialize(deserializer): EphemeralCertificate
Parameters
- deserializer: Deserializer
Returns EphemeralCertificate
Class EphemeralKeyPair
Represents an ephemeral key pair used for signing transactions via the Keyless authentication scheme. +This key pair is temporary and includes an expiration time. +For more details on how this class is used, refer to the documentation: +https://aptos.dev/guides/keyless-accounts/#1-present-the-user-with-a-sign-in-with-idp-button-on-the-ui
+Hierarchy (view full)
- Serializable
- EphemeralKeyPair
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Ephemeral Key Pair(args): EphemeralKeyPair Creates an instance of the class with a specified private key, optional expiry date, and optional blinder. +This constructor initializes the public key, sets the expiry date to a default value if not provided, +generates a blinder if not supplied, and calculates the nonce based on the public key, expiry date, and blinder.
+Parameters
- args: {
blinder?: HexInput;
expiryDateSecs?: number;
privateKey: PrivateKey;
}The parameters for constructing the instance.
+Optionalblinder?: HexInputOptional blinder value. If not provided, a new blinder will be generated.
+OptionalexpiryDate Secs?: number Optional expiry date in seconds from the current time. Defaults to two weeks from now.
+private
Key: PrivateKey The private key used for creating the instance.
+
Returns EphemeralKeyPair
- args: {
Methods
bcs
bcs
get
- get
Public Key(): EphemeralPublicKey Returns the public key of the key pair.
+Returns EphemeralPublicKey
EphemeralPublicKey
+
is
serialize
- serialize(serializer): void
Serializes the object's properties into a format suitable for transmission or storage. +This function is essential for preparing the object data for serialization processes.
+Parameters
- serializer: Serializer
The serializer instance used to serialize the object's properties.
+
Returns void
- serializer: Serializer
sign
- sign(data): EphemeralSignature
Sign the given data using the private key, returning an ephemeral signature. +This function is essential for creating a secure signature that can be used for authentication or verification purposes.
+Parameters
- data: HexInput
The data to be signed, provided in HexInput format.
+
Returns EphemeralSignature
EphemeralSignature - The resulting ephemeral signature.
+- data: HexInput
to
to
Staticdeserialize
- deserialize(deserializer): EphemeralKeyPair
Deserializes an ephemeral key pair from the provided deserializer. +This function helps in reconstructing an ephemeral key pair, which is essential for cryptographic operations.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns EphemeralKeyPair
- deserializer: Deserializer
Staticfrom
- from
Bytes(bytes): EphemeralKeyPair Deserialize a byte array into an EphemeralKeyPair object. +This function allows you to reconstruct an EphemeralKeyPair from its serialized byte representation.
+Parameters
- bytes: Uint8Array
The byte array representing the serialized EphemeralKeyPair.
+
Returns EphemeralKeyPair
- bytes: Uint8Array
Staticgenerate
- generate(args?): EphemeralKeyPair
Generates a new ephemeral key pair with an optional expiry date. +This function allows you to create a temporary key pair for secure operations.
+Parameters
Optionalargs: {
expiryDateSecs?: number;
scheme?: Ed25519;
}Optional parameters for key pair generation.
+OptionalexpiryDate Secs?: number The date of expiry for the key pair in seconds.
+Optionalscheme?: Ed25519The type of key pair to use for the EphemeralKeyPair. Only Ed25519 is supported for now.
+
Returns EphemeralKeyPair
An instance of EphemeralKeyPair containing the generated private key and expiry date.
+
Properties
Readonlyblinder
A byte array of length BLINDER_LENGTH used to obfuscate the public key from the IdP. +Used in calculating the nonce passed to the IdP and as a secret witness in proof generation.
+Readonlyexpiry
A timestamp in seconds indicating when the ephemeral key pair is expired. After expiry, a new +EphemeralKeyPair must be generated and a new JWT needs to be created.
+Readonlynonce
The value passed to the IdP when the user authenticates. It consists of a hash of the +ephemeral public key, expiry date, and blinder.
+Static ReadonlyBLINDER_
Class EphemeralPublicKey
Represents ephemeral public keys for Aptos Keyless accounts.
+These keys are used only temporarily within Keyless accounts and are not utilized as public keys for account identification.
+Hierarchy (view full)
- PublicKey
- EphemeralPublicKey
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Ephemeral Public Key(publicKey): EphemeralPublicKey Creates an instance of EphemeralPublicKey using the provided public key. +This constructor ensures that only supported signature types are accepted.
+Parameters
- publicKey: PublicKey
The public key to be used for the ephemeral public key.
+
Returns EphemeralPublicKey
- publicKey: PublicKey
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the current instance, specifically handling the Ed25519 signature type. +This function ensures that the signature is properly serialized using the provided serializer.
+Parameters
- serializer: Serializer
The serializer instance used to serialize the signature.
+
Returns void
- serializer: Serializer
to
to
to
verify
- verify
Signature(args): boolean Verifies a signed message using the ephemeral public key.
+Parameters
- args: {
message: HexInput;
signature: EphemeralSignature;
}The arguments for the verification.
+message: HexInput
The message that was signed.
+signature: EphemeralSignature
The signature that was signed by the private key of the ephemeral public key.
+
Returns boolean
true if the signature is valid, otherwise false.
+- args: {
Staticdeserialize
- deserialize(deserializer): EphemeralPublicKey
Deserializes an EphemeralSignature from the provided deserializer. +This function allows you to retrieve an EphemeralSignature based on the deserialized data.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns EphemeralPublicKey
- deserializer: Deserializer
Staticis
- is
Public Key(publicKey): publicKey is EphemeralPublicKey Determines if the provided public key is an instance of
+EphemeralPublicKey.Parameters
- publicKey: PublicKey
The public key to check.
+
Returns publicKey is EphemeralPublicKey
A boolean indicating whether the public key is an ephemeral type.
+- publicKey: PublicKey
Class EphemeralSignature
Represents ephemeral signatures used in Aptos Keyless accounts.
+These signatures are utilized within the KeylessSignature framework.
+Hierarchy (view full)
- Signature
- EphemeralSignature
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Ephemeral Signature(signature): EphemeralSignature Parameters
- signature: Signature
Returns EphemeralSignature
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
Staticdeserialize
- deserialize(deserializer): EphemeralSignature
Parameters
- deserializer: Deserializer
Returns EphemeralSignature
Staticfrom
- from
Hex(hexInput): EphemeralSignature Deserializes an ephemeral signature from a hexadecimal input. +This function allows you to convert a hexadecimal representation of an ephemeral signature into its deserialized form for +further processing.
+Parameters
- hexInput: HexInput
The hexadecimal input representing the ephemeral signature.
+
Returns EphemeralSignature
- hexInput: HexInput
Class FederatedKeylessAccount
Account implementation for the FederatedKeyless authentication scheme.
+Used to represent a FederatedKeyless based account and sign transactions with it.
+Use FederatedKeylessAccount.create() to instantiate a KeylessAccount with a JSON Web Token (JWT), proof, EphemeralKeyPair and the
+address the JSON Web Key Set (JWKS) are installed that will be used to verify the JWT.
When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT, +EphemeralKeyPair, and corresponding proof.
+Hierarchy (view full)
- AbstractKeylessAccount
- FederatedKeylessAccount
Index
Methods
Properties
Methods
bcs
bcs
check
- check
Keyless Account Validity(aptosConfig): Promise<void> Validates that the Keyless Account can be used to sign transactions.
+Parameters
- aptosConfig: AptosConfig
Returns Promise<void>
init
- init(promise): Promise<void>
This initializes the asynchronous proof fetch.
+Parameters
- promise: Promise<ZeroKnowledgeSig>
Returns Promise<void>
Emits whether the proof succeeds or fails, but has no return.
+
is
serialize
- serialize(serializer): void
Serializes the transaction data into a format suitable for transmission or storage. +This function ensures that both the transaction bytes and the proof are properly serialized.
+Parameters
- serializer: Serializer
The serializer instance used to convert the transaction data into bytes.
+
Returns void
- serializer: Serializer
sign
- sign(message): KeylessSignature
Sign the given message using Keyless.
+Parameters
- message: HexInput
in HexInput format
+
Returns KeylessSignature
Signature
+- message: HexInput
sign
- sign
Transaction(transaction): KeylessSignature Sign the given transaction with Keyless. +Signs the transaction and proof to guard against proof malleability.
+Parameters
- transaction: AnyRawTransaction
the transaction to be signed
+
Returns KeylessSignature
KeylessSignature
+- transaction: AnyRawTransaction
sign
- sign
Transaction With Authenticator(transaction): AccountAuthenticatorSingleKey Sign a transaction using Keyless.
+Parameters
- transaction: AnyRawTransaction
the raw transaction
+
Returns AccountAuthenticatorSingleKey
the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+- transaction: AnyRawTransaction
sign
- sign
With Authenticator(message): AccountAuthenticatorSingleKey Sign a message using Keyless.
+Parameters
- message: HexInput
the message to sign, as binary input
+
Returns AccountAuthenticatorSingleKey
the AccountAuthenticator containing the signature, together with the account's public key
+- message: HexInput
to
to
verify
- verify
Signature(args): boolean Note - This function is currently incomplete and should only be used to verify ownership of the KeylessAccount
+Verifies a signature given the message.
+TODO: Groth16 proof verification
+Parameters
- args: {
message: HexInput;
signature: KeylessSignature;
}message: HexInput
the message that was signed.
+signature: KeylessSignature
the KeylessSignature to verify
+
Returns boolean
boolean
+- args: {
wait
Staticcreate
- create(args): FederatedKeylessAccount
Creates a KeylessAccount instance using the provided parameters. +This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT. +This is used instead of the KeylessAccount constructor.
+Parameters
- args: {
address?: AccountAddress;
ephemeralKeyPair: EphemeralKeyPair;
jwkAddress: AccountAddressInput;
jwt: string;
pepper: HexInput;
proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
proofFetchCallback?: ProofFetchCallback;
uidKey?: string;
verificationKey?: Groth16VerificationKey;
}The parameters for creating a KeylessAccount.
+Optionaladdress?: AccountAddressOptional account address associated with the KeylessAccount.
+ephemeral
Key Pair: EphemeralKeyPair The ephemeral key pair used in the account creation.
+jwk
Address: AccountAddressInput The address which stores the JSON Web Key Set (JWKS) used to verify the JWT.
+jwt: string
A JSON Web Token used for authentication.
+pepper: HexInput
proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>
A Zero Knowledge Signature or a promise that resolves to one.
+OptionalproofFetch Callback?: ProofFetchCallback Optional callback function for fetching proof.
+OptionaluidKey?: string Optional key for user identification, defaults to "sub".
+OptionalverificationKey?: Groth16VerificationKey
Returns FederatedKeylessAccount
- args: {
Staticdeserialize
- deserialize(deserializer): FederatedKeylessAccount
Deserializes the provided deserializer to create a KeylessAccount instance. +This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.
+Parameters
- deserializer: Deserializer
The deserializer instance used to retrieve the serialized data.
+
Returns FederatedKeylessAccount
A KeylessAccount instance created from the deserialized data.
+- deserializer: Deserializer
StaticfetchJWK
- fetchJWK(args): Promise<MoveJWK>
Fetches the JWK from the issuer's well-known JWKS endpoint.
+Parameters
- args: {
aptosConfig: AptosConfig;
kid: string;
publicKey: KeylessPublicKey | FederatedKeylessPublicKey;
}aptos
Config: AptosConfig kid: string
The kid of the JWK to fetch
+public
Key: KeylessPublicKey | FederatedKeylessPublicKey The keyless public key to query
+
Returns Promise<MoveJWK>
A JWK matching the
+kidin the JWT header.- args: {
Staticfrom
- from
Bytes(bytes): FederatedKeylessAccount Deserialize bytes using this account's information.
+Parameters
- bytes: HexInput
The bytes being interpreted.
+
Returns FederatedKeylessAccount
- bytes: HexInput
Staticpartial
- partial
Deserialize(deserializer): {
address: AccountAddress;
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
pepper: Uint8Array;
proof: ZeroKnowledgeSig;
uidKey: string;
verificationKeyHash?: Uint8Array;
} Parameters
- deserializer: Deserializer
Returns {
address: AccountAddress;
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
pepper: Uint8Array;
proof: ZeroKnowledgeSig;
uidKey: string;
verificationKeyHash?: Uint8Array;
}address: AccountAddress
ephemeral
Key Pair: EphemeralKeyPair jwt: string
pepper: Uint8Array
proof: ZeroKnowledgeSig
uid
Key: string OptionalverificationKey Hash?: Uint8Array
Properties
Readonlyaccount
Account address associated with the account
+Readonlyaud
The value of the 'aud' claim on the JWT, also known as client ID. This is the identifier for the dApp's +OIDC registration with the identity provider.
+Readonlyephemeral
The EphemeralKeyPair used to generate sign.
+Readonlyjwt
The JWT token used to derive the account
+Readonlypepper
A value contains 31 bytes of entropy that preserves privacy of the account. Typically fetched from a pepper provider.
+proof
The zero knowledge signature (if ready) which contains the proof used to validate the EphemeralKeyPair.
+Readonlyproof
The proof of the EphemeralKeyPair or a promise that provides the proof. This is used to allow for awaiting on +fetching the proof.
+Readonlypublic
The FederatedKeylessPublicKey associated with the account
+Readonlysigning
Signing scheme used to sign transactions
+Readonlyuid
The claim on the JWT to identify a user. This is typically 'sub' or 'email'.
+Readonlyuid
The value of the uidKey claim on the JWT. This intended to be a stable user identifier.
+Optional Readonlyverification
The hash of the verification key used to verify the proof. This is optional and can be used to check verifying key +rotations which may invalidate the proof.
+Static ReadonlyPEPPER_
Class FederatedKeylessPublicKey
Represents the FederatedKeylessPublicKey public key
+These keys use an on-chain address as a source of truth for the JWK used to verify signatures.
+FederatedKeylessPublicKey authentication key is represented in the SDK as AnyPublicKey.
Hierarchy (view full)
- AccountPublicKey
- FederatedKeylessPublicKey
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Federated Keyless Public Key(jwkAddress, keylessPublicKey): FederatedKeylessPublicKey Parameters
- jwkAddress: AccountAddressInput
- keylessPublicKey: KeylessPublicKey
Returns FederatedKeylessPublicKey
Methods
auth
- auth
Key(): AuthenticationKey Get the authentication key for the federated keyless public key
+Returns AuthenticationKey
AuthenticationKey
+
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
verify
- verify
Signature(args): boolean Verifies a signed data with a public key
+Parameters
- args: {
message: HexInput;
signature: KeylessSignature;
}message: HexInput
message
+signature: KeylessSignature
The signature
+
Returns boolean
true if the signature is valid
+- args: {
Staticcreate
- create(args): FederatedKeylessPublicKey
Creates a FederatedKeylessPublicKey from the JWT components plus pepper
+Parameters
- args: {
aud: string;
iss: string;
jwkAddress: AccountAddressInput;
pepper: HexInput;
uidKey: string;
uidVal: string;
}aud: string
the client ID of the application
+iss: string
the iss of the identity
+jwk
Address: AccountAddressInput pepper: HexInput
The pepper used to maintain privacy of the account
+uid
Key: string the key to use to get the uidVal in the JWT token
+uid
Val: string the value of the uidKey in the JWT token
+
Returns FederatedKeylessPublicKey
FederatedKeylessPublicKey
+- args: {
Staticdeserialize
- deserialize(deserializer): FederatedKeylessPublicKey
Parameters
- deserializer: Deserializer
Returns FederatedKeylessPublicKey
Staticfrom
- from
Jwt And Pepper(args): FederatedKeylessPublicKey Parameters
- args: {
jwkAddress: AccountAddressInput;
jwt: string;
pepper: HexInput;
uidKey?: string;
}jwk
Address: AccountAddressInput jwt: string
pepper: HexInput
OptionaluidKey?: string
Returns FederatedKeylessPublicKey
- args: {
Staticis
- is
Instance(publicKey): boolean Parameters
- publicKey: PublicKey
Returns boolean
Staticis
- is
Public Key(publicKey): publicKey is FederatedKeylessPublicKey Parameters
- publicKey: PublicKey
Returns publicKey is FederatedKeylessPublicKey
Class FeePayerRawTransaction
Represents a Fee Payer Transaction that can be serialized and deserialized.
+Hierarchy (view full)
- RawTransactionWithData
- FeePayerRawTransaction
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Fee Payer Raw Transaction(raw_txn, secondary_signer_addresses, fee_payer_address): FeePayerRawTransaction Parameters
- raw_txn: RawTransaction
- secondary_signer_addresses: AccountAddress[]
- fee_payer_address: AccountAddress
Returns FeePayerRawTransaction
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize a Raw Transaction With Data
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): RawTransactionWithData
Deserialize a Raw Transaction With Data
+Parameters
- deserializer: Deserializer
Returns RawTransactionWithData
Staticload
- load(deserializer): FeePayerRawTransaction
Parameters
- deserializer: Deserializer
Returns FeePayerRawTransaction
Class FixedBytes
Represents a contiguous sequence of already serialized BCS bytes.
+This class differs from most other Serializable classes in that its internal byte buffer is serialized to BCS
+bytes exactly as-is, without prepending the length of the bytes. It is ideal for scenarios where custom serialization
+is required, such as passing serialized bytes as transaction arguments. Additionally, it serves as a representation
+of type-agnostic BCS bytes, akin to a vector
An example use case includes handling bytes resulting from entry function arguments that have been serialized +for an entry function.
+Example
const yourCustomSerializedBytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
const fixedBytes = new FixedBytes(yourCustomSerializedBytes);
const payload = await generateTransactionPayload({
function: "0xbeefcafe::your_module::your_function_that_requires_custom_serialization",
functionArguments: [yourCustomBytes],
});
This class is particularly useful when you want to handle a fixed-size byte array without the overhead of
length prepending, such as when dealing with 32-byte addresses stored as U8 in a MoveVector<U8>.
For example, if you store each of the 32 bytes for an address as a U8 in a MoveVector<U8>, when you
serialize that MoveVector<U8>, it will be serialized to 33 bytes. If you solely want to pass around
the 32 bytes as a Serializable class that *does not* prepend the length to the BCS-serialized representation,
use this class.*
+Hierarchy (view full)
- Serializable
- FixedBytes
Implements
Index
Constructors
constructor
- new
Fixed Bytes(value): FixedBytes Creates an instance of the class with a specified hexadecimal input. +The value is converted from hexadecimal format to a Uint8Array.
+Parameters
- value: HexInput
The hexadecimal input to be converted.
+
Returns FixedBytes
- value: HexInput
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the fixed bytes value using the provided serializer. +This function is essential for converting the fixed bytes into a format suitable for storage or transmission.
+Parameters
- serializer: Serializer
The serializer instance used for serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serializes the current instance for an entry function using the provided serializer. +This allows the instance to be converted into a format suitable for transmission or storage.
+Parameters
- serializer: Serializer
The serializer used to perform the serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serializes the current instance using the provided serializer. +This function is essential for preparing data to be passed as arguments in script functions.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer, length): FixedBytes
Deserializes a fixed-length byte array from the provided deserializer. +This function helps in reconstructing a FixedBytes object from the serialized data.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the byte data.
+ - length: number
The length of the byte array to be deserialized.
+
Returns FixedBytes
- deserializer: Deserializer
Class Groth16VerificationKey
Represents the verification key stored on-chain used to verify Groth16 proofs.
+ Index
Constructors
Methods
Properties
Constructors
constructor
- new
Groth16 Verification Key(args): Groth16VerificationKey Parameters
Returns Groth16VerificationKey
Methods
hash
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
Staticfrom
- from
Groth16 Verification Key Response(res): Groth16VerificationKey Converts a Groth16VerificationKeyResponse object into a Groth16VerificationKey instance.
+Parameters
- res: Groth16VerificationKeyResponse
The Groth16VerificationKeyResponse object containing the verification key data.
+
Returns Groth16VerificationKey
A Groth16VerificationKey instance constructed from the provided response data.
+- res: Groth16VerificationKeyResponse
Properties
Readonlyalpha
The alpha * G, where G is the generator of G1
Readonlybeta
The alpha * H, where H is the generator of G2
Readonlydelta
The delta * H, where H is the generator of G2
Readonlygamma
The gamma^{-1} * (beta * a_i + alpha * b_i + c_i) * H, where H is the generator of G1
Readonlygamma
The gamma * H, where H is the generator of G2
Class Groth16Zkp
Represents a Groth16 zero-knowledge proof, consisting of three proof points in compressed serialization format. +The points are the compressed serialization of affine representation of the proof.
+Hierarchy (view full)
- Proof
- Groth16Zkp
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Groth16 Zkp(args): Groth16Zkp Returns Groth16Zkp
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): Groth16Zkp
Parameters
- deserializer: Deserializer
Returns Groth16Zkp
Class Hex
NOTE: Do not use this class when working with account addresses; use AccountAddress instead. +When accepting hex data as input to a function, prefer to accept HexInput and
+A helper class for working with hex data. Hex data, when represented as a string, +generally looks like this, for example: 0xaabbcc, 45cd32, etc.
+then use the static helper methods of this class to convert it into the desired +format. This enables the greatest flexibility for the developer.
+Example usage:
+getTransactionByHash(txnHash: HexInput): Promise<Transaction> {
const txnHashString = Hex.fromHexInput(txnHash).toString();
return await getTransactionByHashInner(txnHashString);
}
+This call to Hex.fromHexInput().toString() converts the HexInput to a hex string
+with a leading 0x prefix, regardless of what the input format was.
Other ways to chain the functions together:
+-
+
Hex.fromHexString({ hexInput: "0x1f" }).toUint8Array()
+new Hex([1, 3]).toStringWithoutPrefix()
+
Index
Constructors
Methods
Methods
equals
- equals(other): boolean
Determine if two Hex instances are equal by comparing their underlying byte data.
+Parameters
- other: Hex
The Hex instance to compare to.
+
Returns boolean
true if the Hex instances are equal, false if not.
+- other: Hex
to
to
to
Staticfrom
- from
Hex Input(hexInput): Hex Converts an instance of HexInput, which can be a string or a Uint8Array, into a Hex instance. +This function is useful for transforming hexadecimal representations into a structured Hex object for further manipulation.
+Parameters
- hexInput: HexInput
A HexInput which can be a string or Uint8Array.
+
Returns Hex
A Hex instance created from the provided hexInput.
+- hexInput: HexInput
Staticfrom
Statichex
- hex
Input To String(hexInput): string Converts a HexInput (string or Uint8Array) to a hex string with '0x' prefix.
+Parameters
- hexInput: HexInput
The input to convert, either a hex string (with/without '0x' prefix) or Uint8Array
+
Returns string
A hex string with '0x' prefix (e.g., "0x1234")
+- hexInput: HexInput
Statichex
- hex
Input To String Without Prefix(hexInput): string Converts a HexInput (string or Uint8Array) to a hex string without '0x' prefix.
+Parameters
- hexInput: HexInput
The input to convert, either a hex string (with/without '0x' prefix) or Uint8Array
+
Returns string
A hex string without '0x' prefix (e.g., "1234")
+- hexInput: HexInput
Statichex
- hex
Input To Uint8 Array(hexInput): Uint8Array Converts an instance of HexInput, which can be a string or a Uint8Array, into a Uint8Array.
+Parameters
- hexInput: HexInput
A HexInput which can be a string or Uint8Array.
+
Returns Uint8Array
A Uint8Array created from the provided hexInput.
+- hexInput: HexInput
Staticis
- is
Valid(str): ParsingResult<HexInvalidReason> Check if the provided string is a valid hexadecimal representation.
+Parameters
- str: string
A hex string representing byte data.
+
Returns ParsingResult<HexInvalidReason>
An object containing:
+-
+
- valid: A boolean indicating whether the string is valid. +
- invalidReason: The reason for invalidity if the string is not valid. +
- invalidReasonMessage: A message explaining why the string is invalid. +
- str: string
Class Identifier
Represents an Identifier that can be serialized and deserialized. +This class is used to denote the module "name" in "ModuleId" and +the "function name" in "EntryFunction".
+Hierarchy (view full)
- Serializable
- Identifier
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Identifier(identifier): Identifier Creates an instance of the class with a specified identifier.
+Parameters
- identifier: string
The unique identifier for the instance.
+
Returns Identifier
- identifier: string
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the identifier of the current instance using the provided serializer.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer): Identifier
Deserializes an identifier from the provided deserializer. +This function is useful for reconstructing an Identifier object from a serialized format.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns Identifier
- deserializer: Deserializer
Class KeylessAccount
Account implementation for the Keyless authentication scheme.
+Used to represent a Keyless based account and sign transactions with it.
+Use KeylessAccount.create() to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.
When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT, +EphemeralKeyPair, and corresponding proof.
+Hierarchy (view full)
- AbstractKeylessAccount
- KeylessAccount
Index
Methods
Properties
Methods
bcs
bcs
check
- check
Keyless Account Validity(aptosConfig): Promise<void> Validates that the Keyless Account can be used to sign transactions.
+Parameters
- aptosConfig: AptosConfig
Returns Promise<void>
init
- init(promise): Promise<void>
This initializes the asynchronous proof fetch.
+Parameters
- promise: Promise<ZeroKnowledgeSig>
Returns Promise<void>
Emits whether the proof succeeds or fails, but has no return.
+
is
serialize
- serialize(serializer): void
Serializes the transaction data into a format suitable for transmission or storage. +This function ensures that both the transaction bytes and the proof are properly serialized.
+Parameters
- serializer: Serializer
The serializer instance used to convert the transaction data into bytes.
+
Returns void
- serializer: Serializer
sign
- sign(message): KeylessSignature
Sign the given message using Keyless.
+Parameters
- message: HexInput
in HexInput format
+
Returns KeylessSignature
Signature
+- message: HexInput
sign
- sign
Transaction(transaction): KeylessSignature Sign the given transaction with Keyless. +Signs the transaction and proof to guard against proof malleability.
+Parameters
- transaction: AnyRawTransaction
the transaction to be signed
+
Returns KeylessSignature
KeylessSignature
+- transaction: AnyRawTransaction
sign
- sign
Transaction With Authenticator(transaction): AccountAuthenticatorSingleKey Sign a transaction using Keyless.
+Parameters
- transaction: AnyRawTransaction
the raw transaction
+
Returns AccountAuthenticatorSingleKey
the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+- transaction: AnyRawTransaction
sign
- sign
With Authenticator(message): AccountAuthenticatorSingleKey Sign a message using Keyless.
+Parameters
- message: HexInput
the message to sign, as binary input
+
Returns AccountAuthenticatorSingleKey
the AccountAuthenticator containing the signature, together with the account's public key
+- message: HexInput
to
to
verify
- verify
Signature(args): boolean Note - This function is currently incomplete and should only be used to verify ownership of the KeylessAccount
+Verifies a signature given the message.
+TODO: Groth16 proof verification
+Parameters
- args: {
message: HexInput;
signature: KeylessSignature;
}message: HexInput
the message that was signed.
+signature: KeylessSignature
the KeylessSignature to verify
+
Returns boolean
boolean
+- args: {
wait
Staticcreate
- create(args): KeylessAccount
Creates a KeylessAccount instance using the provided parameters. +This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT. +This is used instead of the KeylessAccount constructor.
+Parameters
- args: {
address?: AccountAddress;
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
pepper: HexInput;
proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
proofFetchCallback?: ProofFetchCallback;
uidKey?: string;
verificationKey?: Groth16VerificationKey;
}The parameters for creating a KeylessAccount.
+Optionaladdress?: AccountAddressOptional account address associated with the KeylessAccount.
+ephemeral
Key Pair: EphemeralKeyPair The ephemeral key pair used in the account creation.
+jwt: string
A JSON Web Token used for authentication.
+pepper: HexInput
A hexadecimal input used for additional security.
+proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>
A Zero Knowledge Signature or a promise that resolves to one.
+OptionalproofFetch Callback?: ProofFetchCallback Optional callback function for fetching proof.
+OptionaluidKey?: string Optional key for user identification, defaults to "sub".
+OptionalverificationKey?: Groth16VerificationKey
Returns KeylessAccount
- args: {
Staticdeserialize
- deserialize(deserializer): KeylessAccount
Deserializes the provided deserializer to create a KeylessAccount instance. +This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.
+Parameters
- deserializer: Deserializer
The deserializer instance used to retrieve the serialized data.
+
Returns KeylessAccount
A KeylessAccount instance created from the deserialized data.
+- deserializer: Deserializer
StaticfetchJWK
- fetchJWK(args): Promise<MoveJWK>
Fetches the JWK from the issuer's well-known JWKS endpoint.
+Parameters
- args: {
aptosConfig: AptosConfig;
kid: string;
publicKey: KeylessPublicKey | FederatedKeylessPublicKey;
}aptos
Config: AptosConfig kid: string
The kid of the JWK to fetch
+public
Key: KeylessPublicKey | FederatedKeylessPublicKey The keyless public key to query
+
Returns Promise<MoveJWK>
A JWK matching the
+kidin the JWT header.- args: {
Staticfrom
- from
Bytes(bytes): KeylessAccount Deserialize bytes using this account's information.
+Parameters
- bytes: HexInput
The bytes being interpreted.
+
Returns KeylessAccount
- bytes: HexInput
Staticpartial
- partial
Deserialize(deserializer): {
address: AccountAddress;
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
pepper: Uint8Array;
proof: ZeroKnowledgeSig;
uidKey: string;
verificationKeyHash?: Uint8Array;
} Parameters
- deserializer: Deserializer
Returns {
address: AccountAddress;
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
pepper: Uint8Array;
proof: ZeroKnowledgeSig;
uidKey: string;
verificationKeyHash?: Uint8Array;
}address: AccountAddress
ephemeral
Key Pair: EphemeralKeyPair jwt: string
pepper: Uint8Array
proof: ZeroKnowledgeSig
uid
Key: string OptionalverificationKey Hash?: Uint8Array
Properties
Readonlyaccount
Account address associated with the account
+Readonlyaud
The value of the 'aud' claim on the JWT, also known as client ID. This is the identifier for the dApp's +OIDC registration with the identity provider.
+Readonlyephemeral
The EphemeralKeyPair used to generate sign.
+Readonlyjwt
The JWT token used to derive the account
+Readonlypepper
A value contains 31 bytes of entropy that preserves privacy of the account. Typically fetched from a pepper provider.
+proof
The zero knowledge signature (if ready) which contains the proof used to validate the EphemeralKeyPair.
+Readonlyproof
The proof of the EphemeralKeyPair or a promise that provides the proof. This is used to allow for awaiting on +fetching the proof.
+Readonlypublic
The KeylessPublicKey associated with the account
+Readonlysigning
Signing scheme used to sign transactions
+Readonlyuid
The claim on the JWT to identify a user. This is typically 'sub' or 'email'.
+Readonlyuid
The value of the uidKey claim on the JWT. This intended to be a stable user identifier.
+Optional Readonlyverification
The hash of the verification key used to verify the proof. This is optional and can be used to check verifying key +rotations which may invalidate the proof.
+Static ReadonlyPEPPER_
Class KeylessConfiguration
Represents the on-chain configuration for how Keyless accounts operate.
+ Index
Constructors
constructor
- new
Keyless Configuration(verificationKey, maxExpHorizonSecs): KeylessConfiguration Parameters
- verificationKey: Groth16VerificationKey
- maxExpHorizonSecs: number
Returns KeylessConfiguration
Methods
Staticcreate
- create(res, maxExpHorizonSecs): KeylessConfiguration
Parameters
- res: Groth16VerificationKeyResponse
- maxExpHorizonSecs: number
Returns KeylessConfiguration
Class KeylessError
Hierarchy (view full)
- Error
- KeylessError
Index
Methods
Properties
Methods
Staticcapture
Staticconstruct
- construct
Message(message, tip, innerError?, details?): string Parameters
- message: string
- tip: KeylessErrorResolutionTip
OptionalinnerError: unknownOptionaldetails: string
Returns string
Staticfrom
- from
Error Type(args): KeylessError Static constructor that creates a KeylessError instance using the KeylessErrors constant
+Parameters
- args: {
details?: string;
error?: unknown;
type: KeylessErrorType;
}Optionaldetails?: stringoptional details to include in the error message
+Optionalerror?: unknowntype: KeylessErrorType
The type of KeylessError
+
Returns KeylessError
A new KeylessError instance
+- args: {
Properties
Readonlycategory
Optional Readonlydetails
Optional Readonlyinner
message
name
Readonlyresolution
Optionalstack
Readonlytype
Static Optionalprepare
Optional override for formatting stack traces
+Staticstack
Class KeylessPublicKey
Represents a Keyless Public Key used for authentication.
+This class encapsulates the public key functionality for keyless authentication,
+including methods for generating and verifying signatures, as well as serialization
+and deserialization of the key. The KeylessPublicKey is represented in the SDK
+as AnyPublicKey.
Hierarchy (view full)
- AccountPublicKey
- KeylessPublicKey
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Keyless Public Key(iss, idCommitment): KeylessPublicKey Constructs an instance with the specified parameters for cryptographic operations.
+Parameters
- iss: string
- idCommitment: HexInput
Returns KeylessPublicKey
Methods
auth
- auth
Key(): AuthenticationKey Get the authentication key for the keyless public key.
+Returns AuthenticationKey
AuthenticationKey - The authentication key derived from the keyless public key.
+
bcs
bcs
serialize
- serialize(serializer): void
Serializes the current instance into a format suitable for transmission or storage. +This function ensures that all relevant fields are properly serialized, including the proof and optional fields.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
to
verify
- verify
Signature(args): boolean Verifies the validity of a signature for a given message.
+Parameters
- args: {
message: HexInput;
signature: KeylessSignature;
}The arguments for signature verification.
+message: HexInput
The message that was signed.
+signature: KeylessSignature
The signature to verify against the message.
+
Returns boolean
true if the signature is valid; otherwise, false.
+- args: {
Staticcreate
- create(args): KeylessPublicKey
Creates a KeylessPublicKey from the JWT components plus pepper
+Parameters
- args: {
aud: string;
iss: string;
pepper: HexInput;
uidKey: string;
uidVal: string;
}aud: string
the client ID of the application
+iss: string
the iss of the identity
+pepper: HexInput
The pepper used to maintain privacy of the account
+uid
Key: string the key to use to get the uidVal in the JWT token
+uid
Val: string the value of the uidKey in the JWT token
+
Returns KeylessPublicKey
KeylessPublicKey
+- args: {
Staticdeserialize
- deserialize(deserializer): KeylessPublicKey
Deserializes a ZeroKnowledgeSig object from the provided deserializer. +This function allows you to reconstruct a ZeroKnowledgeSig instance from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns KeylessPublicKey
A new instance of ZeroKnowledgeSig.
+- deserializer: Deserializer
Staticfrom
- from
Jwt And Pepper(args): KeylessPublicKey Creates a KeylessPublicKey instance from a JWT and a pepper value. +This function is useful for generating a public key that can be used for authentication based on the provided JWT claims and pepper.
+Parameters
- args: {
jwt: string;
pepper: HexInput;
uidKey?: string;
}The arguments for creating the KeylessPublicKey.
+jwt: string
The JSON Web Token to decode.
+pepper: HexInput
The pepper value used in the key creation process.
+OptionaluidKey?: string An optional key to retrieve the unique identifier from the JWT payload, defaults to "sub".
+
Returns KeylessPublicKey
A KeylessPublicKey instance created from the provided JWT and pepper.
+- args: {
Staticis
- is
Instance(publicKey): boolean Checks if the provided public key is a valid instance by verifying its structure and types.
+Parameters
- publicKey: PublicKey
The public key to validate.
+
Returns boolean
A boolean indicating whether the public key is a valid instance.
+- publicKey: PublicKey
Staticis
- is
Public Key(publicKey): publicKey is KeylessPublicKey Determines if the provided public key is an instance of KeylessPublicKey.
+Parameters
- publicKey: PublicKey
The public key to check.
+
Returns publicKey is KeylessPublicKey
A boolean indicating whether the public key is a KeylessPublicKey instance.
+- publicKey: PublicKey
Staticload
- load(deserializer): KeylessPublicKey
Loads a KeylessPublicKey instance from the provided deserializer. +This function is used to deserialize the necessary components to create a KeylessPublicKey.
+Parameters
- deserializer: Deserializer
The deserializer used to extract the string and byte data.
+
Returns KeylessPublicKey
A new instance of KeylessPublicKey.
+- deserializer: Deserializer
Properties
Readonlyid
A value representing a cryptographic commitment to a user identity.
+It is calculated from the aud, uidKey, uidVal, pepper.
+Readonlyiss
The value of the 'iss' claim on the JWT which identifies the OIDC provider.
+Static ReadonlyID_
The number of bytes that idCommitment should be
Class KeylessSignature
Represents a signature of a message signed via a Keyless Account, utilizing proofs or a JWT token for authentication.
+Hierarchy (view full)
- Signature
- KeylessSignature
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Keyless Signature(args): KeylessSignature Parameters
- args: {
ephemeralCertificate: EphemeralCertificate;
ephemeralPublicKey: EphemeralPublicKey;
ephemeralSignature: EphemeralSignature;
expiryDateSecs: number;
jwtHeader: string;
}ephemeral
Certificate: EphemeralCertificate ephemeral
Public Key: EphemeralPublicKey ephemeral
Signature: EphemeralSignature expiry
Date Secs: number jwt
Header: string
Returns KeylessSignature
- args: {
Methods
bcs
bcs
get
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
Staticdeserialize
- deserialize(deserializer): KeylessSignature
Parameters
- deserializer: Deserializer
Returns KeylessSignature
Staticget
- get
Simulation Signature(): KeylessSignature Returns KeylessSignature
Staticis
- is
Signature(signature): signature is KeylessSignature Parameters
- signature: Signature
Returns signature is KeylessSignature
Properties
Readonlyephemeral
The inner signature ZeroKnowledgeSignature or OpenIdSignature
+Readonlyephemeral
The ephemeral public key used to verify the signature
+Readonlyephemeral
The signature resulting from signing with the private key of the EphemeralKeyPair
+Readonlyexpiry
The expiry timestamp in seconds of the EphemeralKeyPair used to sign
+Readonlyjwt
The jwt header in the token used to create the proof/signature. In json string representation.
+Class ModuleId
Represents a ModuleId that can be serialized and deserialized. +A ModuleId consists of a module address (e.g., "0x1") and a module name (e.g., "coin").
+Hierarchy (view full)
- Serializable
- ModuleId
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Module Id(address, name): ModuleId Initializes a new instance of the module with the specified account address and name.
+Parameters
- address: AccountAddress
The account address, e.g., "0x1".
+ - name: Identifier
The module name under the specified address, e.g., "coin".
+
Returns ModuleId
- address: AccountAddress
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the address and name properties using the provided serializer. +This function is essential for converting the object's data into a format suitable for transmission or storage.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer): ModuleId
Deserializes a ModuleId from the provided deserializer. +This function retrieves the account address and identifier to construct a ModuleId instance.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the data.
+
Returns ModuleId
- deserializer: Deserializer
Staticfrom
Class MoveJWK
This class serves as a base class for all serializable types. It facilitates +composable serialization of complex types and enables the serialization of +instances to their BCS (Binary Canonical Serialization) representation.
+Hierarchy (view full)
- Serializable
- MoveJWK
Index
Constructors
Methods
Properties
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): MoveJWK
Parameters
- deserializer: Deserializer
Returns MoveJWK
Staticfrom
- from
Move Struct(struct): MoveJWK Parameters
- struct: MoveAnyStruct
Returns MoveJWK
Class MoveOption<T>
Represents an argument for entry functions, providing methods to serialize the argument +to BCS-serialized bytes and convert it to different formats.
+Type Parameters
- T extends Serializable & EntryFunctionArgument
Hierarchy (view full)
- Serializable
- MoveOption
Implements
Index
Constructors
constructor
- new
Move Option<T>(value?): MoveOption<T> Type Parameters
- T extends Serializable & EntryFunctionArgument
Parameters
Optionalvalue: null | T
Returns MoveOption<T>
Methods
bcs
bcs
is
serialize
- serialize(serializer): void
Serialize an argument to BCS-serialized bytes.
+Parameters
- serializer: Serializer
The serializer instance used for serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serialize an argument to BCS-serialized bytes. +Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains +the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+Parameters
- serializer: Serializer
The serializer used to convert the argument.
+
Returns void
- serializer: Serializer
to
to
unwrap
StaticBool
- Bool(value?): MoveOption<Bool>
Factory method to generate a MoveOption
+from a booleanorundefined.Parameters
Optionalvalue: null | booleanthe value used to fill the MoveOption. If
+valueis undefined +the resulting MoveOption's .isSome() method will return false.
Returns MoveOption<Bool>
a MoveOption
+with an inner value value
Staticdeserialize
- deserialize<U>(deserializer, cls): MoveOption<U>
Type Parameters
- U extends Serializable & EntryFunctionArgument
Parameters
- deserializer: Deserializer
- cls: Deserializable<U>
Returns MoveOption<U>
StaticMove
- Move
String(value?): MoveOption<MoveString> Factory method to generate a MoveOption
+from a stringorundefined.Parameters
Optionalvalue: null | stringthe value used to fill the MoveOption. If
+valueis undefined +the resulting MoveOption's .isSome() method will return false.
Returns MoveOption<MoveString>
a MoveOption
+with an inner value value
StaticU128
- U128(value?): MoveOption<U128>
Factory method to generate a MoveOption
+from a numberor abigintorundefined.Parameters
Optionalvalue: null | AnyNumberthe value used to fill the MoveOption. If
+valueis undefined +the resulting MoveOption's .isSome() method will return false.
Returns MoveOption<U128>
a MoveOption
+with an inner value value
StaticU16
- U16(value?): MoveOption<U16>
Factory method to generate a MoveOption
+from a numberorundefined.Parameters
Optionalvalue: null | numberthe value used to fill the MoveOption. If
+valueis undefined +the resulting MoveOption's .isSome() method will return false.
Returns MoveOption<U16>
a MoveOption
+with an inner value value
StaticU256
- U256(value?): MoveOption<U256>
Factory method to generate a MoveOption
+from a numberor abigintorundefined.Parameters
Optionalvalue: null | AnyNumberthe value used to fill the MoveOption. If
+valueis undefined +the resulting MoveOption's .isSome() method will return false.
Returns MoveOption<U256>
a MoveOption
+with an inner value value
StaticU32
- U32(value?): MoveOption<U32>
Factory method to generate a MoveOption
+from a numberorundefined.Parameters
Optionalvalue: null | numberthe value used to fill the MoveOption. If
+valueis undefined +the resulting MoveOption's .isSome() method will return false.
Returns MoveOption<U32>
a MoveOption
+with an inner value value
StaticU64
- U64(value?): MoveOption<U64>
Factory method to generate a MoveOption
+from a numberor abigintorundefined.Parameters
Optionalvalue: null | AnyNumberthe value used to fill the MoveOption. If
+valueis undefined +the resulting MoveOption's .isSome() method will return false.
Returns MoveOption<U64>
a MoveOption
+with an inner value value
StaticU8
- U8(value?): MoveOption<U8>
Factory method to generate a MoveOption
+from a numberorundefined.Parameters
Optionalvalue: null | numberthe value used to fill the MoveOption. If
+valueis undefined +the resulting MoveOption's .isSome() method will return false.
Returns MoveOption<U8>
a MoveOption
+with an inner value value
Class MoveString
Represents a string value that can be serialized and deserialized. +This class extends the Serializable base class and provides methods +for serializing the string in different contexts, such as for entry +functions and script functions.
+Hierarchy (view full)
- Serializable
- MoveString
Implements
Index
Constructors
constructor
- new
Move String(value): MoveString Parameters
- value: string
Returns MoveString
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize an argument to BCS-serialized bytes.
+Parameters
- serializer: Serializer
The serializer instance used for serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serialize an argument to BCS-serialized bytes. +Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains +the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+Parameters
- serializer: Serializer
The serializer used to convert the argument.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serialize an argument to BCS-serialized bytes as a type aware byte sequence. +The byte sequence contains an enum variant index followed by the BCS-serialized +bytes for a typed argument.
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): MoveString
Parameters
- deserializer: Deserializer
Returns MoveString
Class MoveVector<T>
This class is the Aptos Typescript SDK representation of a Move vector<T>,
+where T represents either a primitive type (bool, u8, u64, ...)
+or a BCS-serializable struct itself.
It is a BCS-serializable, array-like type that contains an array of values of type T,
+where T is a class that implements Serializable.
The purpose of this class is to facilitate easy construction of BCS-serializable
+Move vector<T> types.
Example
// in Move: `vector<u8> [1, 2, 3, 4];`
const vecOfU8s = new MoveVector<U8>([new U8(1), new U8(2), new U8(3), new U8(4)]);
// in Move: `std::bcs::to_bytes(vector<u8> [1, 2, 3, 4]);`
const bcsBytes = vecOfU8s.toUint8Array();
// vector<vector<u8>> [ vector<u8> [1], vector<u8> [1, 2, 3, 4], vector<u8> [5, 6, 7, 8] ];
const vecOfVecs = new MoveVector<MoveVector<U8>>([
new MoveVector<U8>([new U8(1)]),
MoveVector.U8([1, 2, 3, 4]),
MoveVector.U8([5, 6, 7, 8]),
]);
// vector<Option<u8>> [ std::option::some<u8>(1), std::option::some<u8>(2) ];
const vecOfOptionU8s = new MoveVector<MoveOption<U8>>([
MoveOption.U8(1),
MoveOption.U8(2),
]);
// vector<MoveString> [ std::string::utf8(b"hello"), std::string::utf8(b"world") ];
const vecOfStrings = new MoveVector([new MoveString("hello"), new MoveString("world")]);
const vecOfStrings2 = MoveVector.MoveString(["hello", "world"]);
+Type Parameters
- T extends Serializable & EntryFunctionArgument
Hierarchy (view full)
- Serializable
- MoveVector
Implements
Index
Constructors
constructor
- new
Move Vector<T>(values): MoveVector<T> Initializes a new instance of the class with an optional value. +This constructor sets up the internal vector based on the provided value.
+Type Parameters
- T extends Serializable & EntryFunctionArgument
Parameters
- values: T[]
The initial value to be stored in the vector, or null to initialize an empty vector.
+
Returns MoveVector<T>
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the current object using the provided serializer. +This function will serialize the value if it is present.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serializes the current instance into a byte sequence suitable for entry functions. +This allows the data to be properly formatted for transmission or storage.
+Parameters
- serializer: Serializer
The serializer instance used to serialize the byte sequence.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serialize the string as a fixed byte string without the length prefix for use in a script function.
+Parameters
- serializer: Serializer
The serializer used to convert the byte vector into a format suitable for a script function.
+
Returns void
- serializer: Serializer
to
to
StaticBool
- Bool(values): MoveVector<Bool>
Factory method to generate a MoveVector
+from a booleanorundefined. +This method allows you to create an optional boolean value that can be used in various contexts where a boolean may or may +not be present.Parameters
- values: boolean[]
The value used to fill the MoveVector. If
+valueis undefined, the resulting MoveVector's .isSome() method +will return false.
Returns MoveVector<Bool>
A MoveVector
+with an inner value value.- values: boolean[]
Staticdeserialize
- deserialize<T>(deserializer, cls): MoveVector<T>
Deserialize a MoveVector of type T, specifically where T is a Serializable and Deserializable type.
+NOTE: This only works with a depth of one. Generics will not work.
+NOTE: This will not work with types that aren't of the Serializable class.
+If you're looking for a more flexible deserialization function, you can use the deserializeVector function +in the Deserializer class.
+Type Parameters
- T extends Serializable & EntryFunctionArgument
Parameters
- deserializer: Deserializer
the Deserializer instance to use, with bytes loaded into it already.
+ - cls: Deserializable<T>
the class to typecast the input values to, must be a Serializable and Deserializable type.
+
Returns MoveVector<T>
a MoveVector of the corresponding class T
+
StaticMove
- Move
String(values): MoveVector<MoveString> Factory method to generate a MoveVector
+from a stringorundefined. +This function creates a MoveVector that encapsulates a MoveString if the provided value is not null or undefined.Parameters
- values: string[]
The value used to fill the MoveVector. If
+valueis undefined, the resulting MoveVector's .isSome() method +will return false.
Returns MoveVector<MoveString>
A MoveVector
+with an inner value value.- values: string[]
StaticU128
- U128(values): MoveVector<U128>
Factory method to generate a MoveVector
+from a number, bigint, or undefined. Parameters
- values: AnyNumber[]
The value used to fill the MoveVector. If
+valueis undefined, the resulting MoveVector's.isSome()+method will return false.
Returns MoveVector<U128>
A MoveVector
+with an inner value value.- values: AnyNumber[]
StaticU16
- U16(values): MoveVector<U16>
Factory method to generate a MoveOption
+from a numberornull.This method allows you to create a MoveVector that can either hold a U16 value or be empty.
+Parameters
- values: number[]
The value used to fill the MoveVector. If
+valueis null or undefined, the resulting MoveVector's +.isSome()method will return false.
Returns MoveVector<U16>
A MoveVector
+with an inner value value.- values: number[]
StaticU256
- U256(values): MoveVector<U256>
Factory method to generate a MoveVector
+from a number, bigint, or null/undefined. +This allows for the creation of an optional U256 value, enabling checks for presence or absence of a value. Parameters
- values: AnyNumber[]
The value used to fill the MoveVector. If
+valueis undefined or null, +the resulting MoveVector's .isSome() method will return false.
Returns MoveVector<U256>
A MoveVector
+with an inner value value.- values: AnyNumber[]
StaticU32
- U32(values): MoveVector<U32>
Factory method to generate a MoveVector
+from a numberornull.This method allows you to create a MoveVector that can either hold a U32 value or be empty.
+Parameters
- values: number[]
The value used to fill the MoveVector. If
+valueis null or undefined, +the resulting MoveVector's .isSome() method will return false.
Returns MoveVector<U32>
A MoveVector
+with an inner value value.- values: number[]
StaticU64
- U64(values): MoveVector<U64>
Factory method to generate a MoveVector
+from a number, bigint, or null/undefined. +This allows for the creation of an optional U64 value that can be checked for presence. Parameters
- values: AnyNumber[]
The value used to fill the MoveVector. If
+valueis undefined or null, the resulting MoveVector's +.isSome()method will return false.
Returns MoveVector<U64>
A MoveVector
+with an inner value value.- values: AnyNumber[]
StaticU8
- U8(values): MoveVector<U8>
Factory method to generate a MoveVector
+from a numberorundefined.This method allows you to create a MoveVector that encapsulates a U8 value, enabling you to handle optional U8 values +effectively.
+Parameters
- values: HexInput | number[]
The values used to fill the MoveVector. If
+valuesis undefined or null, the resulting MoveVector's +.isSome()method will return false.
Returns MoveVector<U8>
A MoveVector
+with an inner value value.- values: HexInput | number[]
Class MultiAgentRawTransaction
Represents a multi-agent transaction that can be serialized and deserialized.
+Hierarchy (view full)
- RawTransactionWithData
- MultiAgentRawTransaction
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Multi Agent Raw Transaction(raw_txn, secondary_signer_addresses): MultiAgentRawTransaction Parameters
- raw_txn: RawTransaction
- secondary_signer_addresses: AccountAddress[]
Returns MultiAgentRawTransaction
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize a Raw Transaction With Data
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): RawTransactionWithData
Deserialize a Raw Transaction With Data
+Parameters
- deserializer: Deserializer
Returns RawTransactionWithData
Staticload
- load(deserializer): MultiAgentRawTransaction
Deserializes a Fee Payer Raw Transaction from the provided deserializer. +This function allows you to reconstruct a Fee Payer Raw Transaction object, which includes the raw transaction data, +secondary signer addresses, and the fee payer address.
+Parameters
- deserializer: Deserializer
The deserializer used to read the raw transaction data.
+
Returns MultiAgentRawTransaction
A FeePayerRawTransaction object constructed from the deserialized data.
+- deserializer: Deserializer
Class MultiAgentTransaction
Represents a multi-agent transaction that can be serialized and deserialized. +This transaction includes a raw transaction, optional fee payer address, and multiple secondary signer addresses.
+Hierarchy (view full)
- Serializable
- MultiAgentTransaction
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Multi Agent Transaction(rawTransaction, secondarySignerAddresses, feePayerAddress?): MultiAgentTransaction Represents a MultiAgentTransaction that can be submitted to the Aptos chain for execution. +This class encapsulates the raw transaction data, the secondary signer addresses, and an optional fee payer address.
+Parameters
- rawTransaction: RawTransaction
The raw transaction data.
+ - secondarySignerAddresses: AccountAddress[]
An array of secondary signer addresses.
+ OptionalfeePayerAddress: AccountAddressAn optional account address that sponsors the gas fees.
+
Returns MultiAgentTransaction
- rawTransaction: RawTransaction
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the transaction data, including the raw transaction, secondary signer addresses, and fee payer address. +This function is essential for preparing the transaction for transmission or storage in a serialized format.
+Parameters
- serializer: Serializer
The serializer instance used to serialize the transaction data.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer): MultiAgentTransaction
Deserializes a MultiAgentTransaction from the provided deserializer. +This function allows you to reconstruct a MultiAgentTransaction object from its serialized form, including any secondary +signer addresses and the fee payer address if present.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns MultiAgentTransaction
- deserializer: Deserializer
Class MultiEd25519PublicKey
Represents the public key of a K-of-N Ed25519 multi-sig transaction.
+A K-of-N multi-sig transaction requires at least K out of N authorized signers to sign the transaction +for it to be executed. This class encapsulates the logic for managing the public keys and the threshold +for valid signatures.
+Hierarchy (view full)
- AccountPublicKey
- MultiEd25519PublicKey
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Multi Ed25519 Public Key(args): MultiEd25519PublicKey Public key for a K-of-N multi-sig transaction. A K-of-N multi-sig transaction means that for such a +transaction to be executed, at least K out of the N authorized signers have signed the transaction +and passed the check conducted by the chain.
+Parameters
- args: {
publicKeys: Ed25519PublicKey[];
threshold: number;
}A wrapper to let you choose the param order.
+public
Keys: Ed25519PublicKey[] A list of public keys
+threshold: number
At least "threshold" signatures must be valid
+
Returns MultiEd25519PublicKey
- args: {
Methods
auth
- auth
Key(): AuthenticationKey Generates an authentication key based on the current instance's byte representation. +This function is essential for creating a secure authentication key that can be used for various cryptographic operations.
+Returns AuthenticationKey
The generated authentication key.
+
bcs
bcs
serialize
- serialize(serializer): void
Serializes the current instance into bytes using the provided serializer. +This allows for the conversion of the instance's data into a format suitable for transmission or storage.
+Parameters
- serializer: Serializer
The serializer used to convert the instance into bytes.
+
Returns void
- serializer: Serializer
to
to
to
verify
- verify
Signature(args): boolean Verifies a multi-signature against a given message. +This function ensures that the provided signatures meet the required threshold and are valid for the given message.
+Parameters
- args: VerifySignatureArgs
The arguments for verifying the signature.
+
Returns boolean
True if the signature is valid; otherwise, false.
+- args: VerifySignatureArgs
Staticdeserialize
- deserialize(deserializer): MultiEd25519PublicKey
Deserializes a MultiEd25519Signature from the provided deserializer. +This function helps in reconstructing a MultiEd25519Signature object from its serialized byte representation.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns MultiEd25519PublicKey
- deserializer: Deserializer
Properties
Readonlypublic
List of Ed25519 public keys for this LegacyMultiEd25519PublicKey
+Readonlythreshold
The minimum number of valid signatures required, for the number of public keys specified
+Static ReadonlyMAX_
Maximum number of public keys supported
+Static ReadonlyMIN_
Minimum number of public keys needed
+Static ReadonlyMIN_
Minimum threshold for the number of valid signatures required
+Class MultiEd25519Signature
Represents the signature of a K-of-N Ed25519 multi-sig transaction.
+Hierarchy (view full)
- Signature
- MultiEd25519Signature
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Multi Ed25519 Signature(args): MultiEd25519Signature Signature for a K-of-N multi-sig transaction.
+Parameters
- args: {
bitmap: Uint8Array | number[];
signatures: Ed25519Signature[];
}bitmap: Uint8Array | number[]
4 bytes, at most 32 signatures are supported. If Nth bit value is
+1, the Nth +signature should be provided insignatures. Bits are read from left to right. +Alternatively, you can specify an array of bitmap positions. +Valid position should range between 0 and 31.signatures: Ed25519Signature[]
A list of signatures
+
Returns MultiEd25519Signature
See
-
+
- Creating a Signed Transaction +
- MultiEd25519Signature.createBitmap +
- args: {
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
Staticcreate
- create
Bitmap(args): Uint8Array Helper method to create a bitmap out of the specified bit positions. +This function allows you to set specific bits in a 32-bit long bitmap based on the provided positions.
+Parameters
- args: {
bits: number[];
}The arguments for creating the bitmap.
+bits: number[]
The bitmap positions that should be set. A position starts at index 0. Valid positions should range between 0 and 31.
+
Returns Uint8Array
bitmap that is 32 bits long.
+- args: {
Staticdeserialize
- deserialize(deserializer): MultiEd25519Signature
Parameters
- deserializer: Deserializer
Returns MultiEd25519Signature
Properties
Readonlybitmap
32-bit Bitmap representing who signed the transaction
+This is represented where each public key can be masked to determine whether the message was signed by that key.
+Readonlysignatures
The list of underlying Ed25519 signatures
+StaticBITMAP_
Number of bytes in the bitmap representing who signed the transaction (32-bits)
+StaticMAX_
Maximum number of Ed25519 signatures supported
+Class MultiKey
Represents a multi-key authentication scheme for accounts, allowing multiple public keys +to be associated with a single account. This class enforces a minimum number of valid signatures +required to authorize actions, ensuring enhanced security for multi-agent accounts.
+The public keys of each individual agent can be any type of public key supported by Aptos.
+Since AIP-55, Aptos supports
+Legacy and Unified authentication keys.
Hierarchy (view full)
- AccountPublicKey
- MultiKey
Index
Constructors
Methods
Properties
Constructors
constructor
Methods
auth
- auth
Key(): AuthenticationKey Generates an authentication key based on the current instance's byte representation. +This key can be used for secure authentication processes within the system.
+Returns AuthenticationKey
The generated authentication key.
+
bcs
bcs
create
get
- get
Index(publicKey): number Get the index of the provided public key.
+This function retrieves the index of a specified public key within the MultiKey. +If the public key does not exist, it throws an error.
+Parameters
- publicKey: PublicKey
The public key to find the index for.
+
Returns number
The corresponding index of the public key, if it exists.
+- publicKey: PublicKey
serialize
- serialize(serializer): void
Serializes the object by writing its signatures and bitmap to the provided serializer. +This allows the object to be converted into a format suitable for transmission or storage.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
to
verify
- verify
Signature(args): boolean Verifies the provided signature against the given message. +This function helps ensure the integrity and authenticity of the message by checking if the signature is valid.
+Parameters
- args: VerifySignatureArgs
The arguments for verifying the signature.
+
Returns boolean
- args: VerifySignatureArgs
Staticdeserialize
- deserialize(deserializer): MultiKey
Deserializes a MultiKeySignature from the provided deserializer. +This function retrieves the signatures and bitmap necessary for creating a MultiKeySignature object.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns MultiKey
- deserializer: Deserializer
Staticis
Class MultiKeyAccount
Signer implementation for the MultiKey authentication scheme.
+This account utilizes an M of N signing scheme, where M and N are specified in the MultiKey. +It signs messages using an array of M accounts, each corresponding to a public key in the MultiKey.
+Note: Generating a signer instance does not create the account on-chain.
+Implements
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Multi Key Account(args): MultiKeyAccount Constructs a MultiKeyAccount instance, which requires multiple signatures for transactions.
+Parameters
- args: {
address?: AccountAddressInput;
multiKey: MultiKey;
signers: Account[];
}The arguments for creating a MultiKeyAccount.
+Optionaladdress?: AccountAddressInputAn optional account address input. If not provided, the derived address from the public key will be used.
+multi
Key: MultiKey The multikey of the account consisting of N public keys and a number M representing the required signatures.
+signers: Account[]
An array of M signers that will be used to sign the transaction.
+
Returns MultiKeyAccount
- args: {
Methods
check
- check
Keyless Account Validity(aptosConfig): Promise<void> Validates that the Keyless Account can be used to sign transactions.
+Parameters
- aptosConfig: AptosConfig
Returns Promise<void>
sign
- sign(data): MultiKeySignature
Sign the given message using the MultiKeyAccount's signers
+Parameters
- data: HexInput
Returns MultiKeySignature
MultiKeySignature
+
sign
- sign
Transaction(transaction): MultiKeySignature Sign the given transaction using the MultiKeyAccount's signers. +This function aggregates signatures from all signers associated with the MultiKeyAccount.
+Parameters
- transaction: AnyRawTransaction
The transaction to be signed.
+
Returns MultiKeySignature
MultiKeySignature - An object containing the aggregated signatures and a bitmap of the signatures.
+- transaction: AnyRawTransaction
sign
- sign
Transaction With Authenticator(transaction): AccountAuthenticatorMultiKey Sign a transaction using the account's signers, returning an AccountAuthenticator that contains the signature and the +account's public key.
+Parameters
- transaction: AnyRawTransaction
The raw transaction to be signed.
+
Returns AccountAuthenticatorMultiKey
An AccountAuthenticatorMultiKey containing the signature of the transaction along with the account's public key.
+- transaction: AnyRawTransaction
sign
- sign
With Authenticator(message): AccountAuthenticatorMultiKey Sign a message using the account's signers and return an AccountAuthenticator containing the signature along with the +account's public key.
+Parameters
- message: HexInput
The signing message, represented as binary input in hexadecimal format.
+
Returns AccountAuthenticatorMultiKey
An instance of AccountAuthenticatorMultiKey that includes the signature and the public key.
+- message: HexInput
verify
- verify
Signature(args): boolean Verify the given message and signature with the public keys.
+This function checks if the provided signatures are valid for the given message using the corresponding public keys.
+Parameters
- args: VerifyMultiKeySignatureArgs
The arguments for verifying the signature.
+
Returns boolean
A boolean indicating whether the signatures are valid for the message.
+- args: VerifyMultiKeySignatureArgs
wait
Staticfrom
- from
Public Keys And Signers(args): MultiKeyAccount Static constructor to create a MultiKeyAccount using the provided public keys and signers.
+Parameters
Returns MultiKeyAccount
MultiKeyAccount - The newly created MultiKeyAccount.
+
Staticis
- is
Multi Key Signer(account): account is MultiKeyAccount Determines if the provided account is a multi-key account.
+Parameters
- account: Account
The account to check.
+
Returns account is MultiKeyAccount
A boolean indicating whether the account is a multi-key account.
+- account: Account
Properties
Readonlyaccount
Account address associated with the account
+Readonlypublic
Public key associated with the account
+Readonlysignatures
Readonlysigner
An array of indices where for signer[i], signerIndicies[i] is the index of the corresponding public key in +publicKey.publicKeys. Used to derive the right public key to use for verification.
+Readonlysigners
The signers used to sign messages. These signers should correspond to public keys in the +MultiKeyAccount's public key. The number of signers should be equal or greater +than this.publicKey.signaturesRequired
+Readonlysigning
Signing scheme used to sign transactions
+Class MultiKeySignature
Represents a multi-signature transaction using Ed25519 signatures. +This class allows for the creation and management of a K-of-N multi-signature scheme, +where a specified number of signatures are required to authorize a transaction.
+It includes functionality to validate the number of signatures against a bitmap, +which indicates which public keys have signed the transaction.
+Hierarchy (view full)
- Signature
- MultiKeySignature
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Multi Key Signature(args): MultiKeySignature Signature for a K-of-N multi-sig transaction.
+Parameters
- args: {
bitmap: Uint8Array | number[];
signatures: (Signature | AnySignature)[];
}bitmap: Uint8Array | number[]
4 bytes, at most 32 signatures are supported. If Nth bit value is
+1, the Nth +signature should be provided insignatures. Bits are read from left to rightsignatures: (Signature | AnySignature)[]
A list of signatures
+
Returns MultiKeySignature
- args: {
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
Staticcreate
- create
Bitmap(args): Uint8Array Helper method to create a bitmap out of the specified bit positions
+Parameters
- args: {
bits: number[];
}bits: number[]
The bitmap positions that should be set. A position starts at index 0. +Valid position should range between 0 and 31.
+
Returns Uint8Array
bitmap that is 32bit long
+- args: {
Staticdeserialize
- deserialize(deserializer): MultiKeySignature
Parameters
- deserializer: Deserializer
Returns MultiKeySignature
Properties
Readonlybitmap
32-bit Bitmap representing who signed the transaction
+This is represented where each public key can be masked to determine whether the message was signed by that key.
+Readonlysignatures
The list of underlying Ed25519 signatures
+StaticBITMAP_
Number of bytes in the bitmap representing who signed the transaction (32-bits)
+StaticMAX_
Maximum number of Ed25519 signatures supported
+Class MultiSig
Represents a MultiSig account that can be serialized and deserialized.
+This class encapsulates the functionality to manage multi-signature transactions, including the address of the +multi-sig account and the associated transaction payload.
+ Index
Constructors
Methods
Properties
Constructors
constructor
- new
Multi Sig(multisig_address, transaction_payload?): MultiSig Contains the payload to run a multi-sig account transaction.
+Parameters
- multisig_address: AccountAddress
The multi-sig account address the transaction will be executed as.
+ Optionaltransaction_payload: MultiSigTransactionPayloadThe payload of the multi-sig transaction. This is optional when executing a multi-sig +transaction whose payload is already stored on chain.
+
Returns MultiSig
- multisig_address: AccountAddress
Methods
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
Staticdeserialize
- deserialize(deserializer): MultiSig
Parameters
- deserializer: Deserializer
Returns MultiSig
Class MultiSigTransactionPayload
Represents a multi-signature transaction payload that can be serialized and deserialized.
+This class is designed to encapsulate the transaction payload for multi-sig account transactions
+as defined in the multisig_account.move module. Future enhancements may allow support for script
+payloads as the multisig_account.move module evolves.
Hierarchy (view full)
- Serializable
- MultiSigTransactionPayload
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Multi Sig Transaction Payload(transaction_payload): MultiSigTransactionPayload Contains the payload to run a multi-sig account transaction.
+Parameters
- transaction_payload: EntryFunction
The payload of the multi-sig transaction. +This can only be EntryFunction for now but, +Script might be supported in the future.
+
Returns MultiSigTransactionPayload
- transaction_payload: EntryFunction
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): MultiSigTransactionPayload
Parameters
- deserializer: Deserializer
Returns MultiSigTransactionPayload
Class ParsingError<T>
This error is used to explain why parsing failed.
+Type Parameters
Hierarchy (view full)
- Error
- ParsingError
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Parsing Error<T>(message, invalidReason): ParsingError<T> Creates an instance of the error with a specified message and invalid reason.
+Type Parameters
Parameters
- message: string
The error message that describes the issue.
+ - invalidReason: T
The reason why the input is considered invalid.
+
Returns ParsingError<T>
- message: string
Properties
invalid
This provides a programmatic way to access why parsing failed. Downstream devs +might want to use this to build their own error messages if the default error +messages are not suitable for their use case. This should be an enum.
+message
name
Optionalstack
Static Optionalprepare
Optional override for formatting stack traces
+Staticstack
Class PrivateKey
Implemented by
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Private Key(): PrivateKey Returns PrivateKey
Methods
public
sign
to
Staticformat
- format
Private Key(privateKey, type): string Format a HexInput to an AIP-80 compliant string.
+ +Parameters
- privateKey: HexInput
The HexString or Uint8Array format of the private key.
+ - type: PrivateKeyVariants
Returns string
- privateKey: HexInput
Staticparse
- parse
Hex Input(value, type, strict?): Hex Parse a HexInput that may be a HexString, Uint8Array, or a AIP-80 compliant string to a Hex instance.
+ +Parameters
- value: HexInput
A HexString, Uint8Array, or a AIP-80 compliant string.
+ - type: PrivateKeyVariants
Optionalstrict: booleanIf true, the value MUST be compliant with AIP-80.
+
Returns Hex
- value: HexInput
Class PublicKeyAbstract
Represents an abstract public key.
+This class provides a common interface for verifying signatures associated with the public key. +It allows for the retrieval of the raw public key bytes and the public key in a hexadecimal string format.
+Hierarchy (view full)
Index
Constructors
Methods
Methods
bcs
bcs
Abstractserialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
Abstractverify
- verify
Signature(args): boolean Verifies that the private key associated with this public key signed the message with the given signature.
+Parameters
- args: VerifySignatureArgs
Returns boolean
Class RawTransaction
Represents a raw transaction that can be serialized and deserialized. +Raw transactions contain the metadata and payloads that can be submitted to the Aptos chain for execution. +They must be signed before the Aptos chain can execute them.
+Hierarchy (view full)
- Serializable
- RawTransaction
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Raw Transaction(sender, sequence_number, payload, max_gas_amount, gas_unit_price, expiration_timestamp_secs, chain_id): RawTransaction RawTransactions contain the metadata and payloads that can be submitted to Aptos chain for execution. +RawTransactions must be signed before Aptos chain can execute them.
+Parameters
- sender: AccountAddress
The sender Account Address
+ - sequence_number: bigint
Sequence number of this transaction. This must match the sequence number stored in +the sender's account at the time the transaction executes.
+ - payload: TransactionPayload
Instructions for the Aptos Blockchain, including publishing a module, +execute an entry function or execute a script payload.
+ - max_gas_amount: bigint
Maximum total gas to spend for this transaction. The account must have more +than this gas or the transaction will be discarded during validation.
+ - gas_unit_price: bigint
Price to be paid per gas unit.
+ - expiration_timestamp_secs: bigint
The blockchain timestamp at which the blockchain would discard this transaction.
+ - chain_id: ChainId
The chain ID of the blockchain that this transaction is intended to be run on.
+
Returns RawTransaction
- sender: AccountAddress
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the transaction data, including the fee payer transaction type, raw transaction, secondary signer addresses, +and fee payer address. +This function is essential for preparing the transaction for transmission or storage in a serialized format.
+Parameters
- serializer: Serializer
The serializer instance used to serialize the transaction data.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer): RawTransaction
Deserialize a Raw Transaction With Data. +This function retrieves the appropriate raw transaction based on the variant index provided by the deserializer.
+Parameters
- deserializer: Deserializer
An instance of the Deserializer used to read the serialized data.
+
Returns RawTransaction
- deserializer: Deserializer
Class RawTransactionWithDataAbstract
Represents a raw transaction with associated data that can be serialized and deserialized.
+Hierarchy (view full)
- Serializable
- RawTransactionWithData
Index
Constructors
Methods
Constructors
constructor
- new
Raw Transaction With Data(): RawTransactionWithData Returns RawTransactionWithData
Methods
bcs
bcs
Abstractserialize
- serialize(serializer): void
Serialize a Raw Transaction With Data
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): RawTransactionWithData
Deserialize a Raw Transaction With Data
+Parameters
- deserializer: Deserializer
Returns RawTransactionWithData
Class RotationProofChallenge
Represents a challenge required for the account owner to sign in order to rotate the authentication key.
+Hierarchy (view full)
- Serializable
- RotationProofChallenge
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Rotation Proof Challenge(args): RotationProofChallenge Initializes a new instance of the class with the specified parameters. +This constructor sets up the necessary attributes for managing account keys.
+Parameters
- args: {
currentAuthKey: AccountAddress;
newPublicKey: PublicKey;
originator: AccountAddress;
sequenceNumber: AnyNumber;
}The parameters required to create the instance.
+current
Auth Key: AccountAddress The current authentication key of the account.
+new
Public Key: PublicKey The new public key to be set for the account.
+originator: AccountAddress
The account address of the originator.
+sequence
Number: AnyNumber The sequence number associated with the transaction.
+
Returns RotationProofChallenge
- args: {
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the properties of the current instance for transmission or storage. +This function helps in converting the instance data into a format suitable for serialization.
+Parameters
- serializer: Serializer
The serializer used to serialize the instance properties.
+
Returns void
- serializer: Serializer
to
to
Class Script
Represents a Script that can be serialized and deserialized. +Scripts contain the Move bytecode payload that can be submitted to the Aptos chain for execution.
+ Index
Constructors
constructor
- new
Script(bytecode, type_args, args): Script Scripts contain the Move bytecodes payload that can be submitted to Aptos chain for execution.
+Parameters
- bytecode: Uint8Array
The move module bytecode
+ - type_args: TypeTag[]
The type arguments that the bytecode function requires.
+ - args: ScriptFunctionArgument[]
The arguments that the bytecode function requires.
+
Returns Script
- bytecode: Uint8Array
Methods
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
Staticdeserialize
- deserialize(deserializer): Script
Parameters
- deserializer: Deserializer
Returns Script
Class Secp256k1PrivateKey
Represents a Secp256k1 ECDSA private key, providing functionality to create, sign messages, +derive public keys, and serialize/deserialize the key.
+Hierarchy (view full)
- Serializable
- Secp256k1PrivateKey
Implements
Index
Constructors
constructor
- new
Secp256k1 Private Key(hexInput, strict?): Secp256k1PrivateKey Create a new PrivateKey instance from a Uint8Array or String.
+ +Parameters
- hexInput: HexInput
A HexInput (string or Uint8Array)
+ Optionalstrict: booleanIf true, private key must AIP-80 compliant.
+
Returns Secp256k1PrivateKey
- hexInput: HexInput
Methods
bcs
bcs
public
- public
Key(): Secp256k1PublicKey Derive the Secp256k1PublicKey from this private key.
+Returns Secp256k1PublicKey
Secp256k1PublicKey The derived public key.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
sign
- sign(message): Secp256k1Signature
Sign the given message with the private key. +This function generates a cryptographic signature for the provided message, ensuring the signature is canonical and non-malleable.
+Parameters
- message: HexInput
A message in HexInput format to be signed.
+
Returns Secp256k1Signature
Signature - The generated signature for the provided message.
+- message: HexInput
toAIP80
to
to
to
to
Staticdeserialize
- deserialize(deserializer): Secp256k1PrivateKey
Parameters
- deserializer: Deserializer
Returns Secp256k1PrivateKey
Staticfrom
- from
Derivation Path(path, mnemonics): Secp256k1PrivateKey Derives a private key from a mnemonic seed phrase using a specified BIP44 path.
+Parameters
- path: string
The BIP44 path to derive the key from.
+ - mnemonics: string
The mnemonic seed phrase used for key generation.
+
Returns Secp256k1PrivateKey
The generated private key.
+- path: string
Staticgenerate
- generate(): Secp256k1PrivateKey
Generate a new random private key.
+Returns Secp256k1PrivateKey
Secp256k1PrivateKey - A newly generated Secp256k1 private key.
+
Staticis
- is
Private Key(privateKey): privateKey is Secp256k1PrivateKey Determines if the provided private key is an instance of Secp256k1PrivateKey.
+Parameters
- privateKey: PrivateKey
The private key to be checked.
+
Returns privateKey is Secp256k1PrivateKey
- privateKey: PrivateKey
Class Secp256k1PublicKey
Represents a Secp256k1 ECDSA public key.
+Hierarchy (view full)
- PublicKey
- Secp256k1PublicKey
Index
Constructors
constructor
- new
Secp256k1 Public Key(hexInput): Secp256k1PublicKey Create a new PublicKey instance from a HexInput, which can be a string or Uint8Array. +This constructor validates the length of the provided signature data.
+Parameters
- hexInput: HexInput
A HexInput (string or Uint8Array) representing the signature data.
+
Returns Secp256k1PublicKey
- hexInput: HexInput
Methods
bcs
bcs
deserialize
- deserialize(deserializer): Secp256k1Signature
Deserializes a Secp256k1Signature from the provided deserializer. +This function allows you to reconstruct a Secp256k1Signature object from its serialized byte representation.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns Secp256k1Signature
- deserializer: Deserializer
serialize
- serialize(serializer): void
Serializes the data into a byte array using the provided serializer. +This function is essential for converting data into a format suitable for transmission or storage.
+Parameters
- serializer: Serializer
The serializer instance used to convert the data.
+
Returns void
- serializer: Serializer
to
to
to
verify
- verify
Signature(args): boolean Verifies a Secp256k1 signature against the public key.
+This function checks the validity of a signature for a given message, ensuring that the signature is canonical as a malleability check.
+Parameters
- args: VerifySignatureArgs
The arguments for verifying the signature.
+
Returns boolean
- args: VerifySignatureArgs
Staticdeserialize
- deserialize(deserializer): Secp256k1PublicKey
Parameters
- deserializer: Deserializer
Returns Secp256k1PublicKey
Staticis
- is
Instance(publicKey): publicKey is Secp256k1PublicKey Determines if the provided public key is a valid instance of a Secp256k1 public key. +This function checks for the presence of a "key" property and validates the length of the key data.
+Parameters
- publicKey: PublicKey
The public key to validate.
+
Returns publicKey is Secp256k1PublicKey
A boolean indicating whether the public key is a valid Secp256k1 public key.
+- publicKey: PublicKey
Staticis
- is
Public Key(publicKey): publicKey is Secp256k1PublicKey Determine if the provided public key is an instance of Secp256k1PublicKey.
+Parameters
- publicKey: PublicKey
The public key to check.
+
Returns publicKey is Secp256k1PublicKey
- publicKey: PublicKey
Class Secp256k1Signature
Represents a signature of a message signed using a Secp256k1 ECDSA private key.
+Hierarchy (view full)
- Signature
- Secp256k1Signature
Index
Constructors
constructor
- new
Secp256k1 Signature(hexInput): Secp256k1Signature Create a new Signature instance from a Uint8Array or String.
+Parameters
- hexInput: HexInput
A HexInput (string or Uint8Array)
+
Returns Secp256k1Signature
- hexInput: HexInput
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
Staticdeserialize
- deserialize(deserializer): Secp256k1Signature
Parameters
- deserializer: Deserializer
Returns Secp256k1Signature
Class SerializableAbstract
This class serves as a base class for all serializable types. It facilitates +composable serialization of complex types and enables the serialization of +instances to their BCS (Binary Canonical Serialization) representation.
+Hierarchy (view full)
- Serializable
- EphemeralKeyPair
- AbstractKeylessAccount
- TransactionAndProof
- EntryFunctionBytes
- FixedBytes
- Bool
- U8
- U16
- U32
- U64
- U128
- U256
- MoveVector
- Serialized
- MoveString
- MoveOption
- AccountAddress
- AuthenticationKey
- Ed25519PrivateKey
- ZkProof
- MoveJWK
- PublicKey
- Secp256k1PrivateKey
- Signature
- AccountAuthenticator
- TransactionAuthenticator
- ChainId
- Identifier
- ModuleId
- RawTransaction
- RawTransactionWithData
- RotationProofChallenge
- SignedTransaction
- TransactionPayload
- MultiSigTransactionPayload
- SimpleTransaction
- MultiAgentTransaction
- TypeTag
- StructTag
- Proof
- G1Bytes
- G2Bytes
Index
Constructors
Methods
Constructors
constructor
- new
Serializable(): Serializable Returns Serializable
Methods
bcs
bcs
Abstractserialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Class Serialized
Represents a serialized data structure that encapsulates a byte array. +This class extends the Serializable class and provides methods for serialization +and deserialization of byte data, as well as converting to a MoveVector.
+Hierarchy (view full)
- Serializable
- Serialized
Implements
Index
Constructors
constructor
- new
Serialized(value): Serialized Parameters
- value: HexInput
Returns Serialized
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize an argument to BCS-serialized bytes.
+Parameters
- serializer: Serializer
The serializer instance used for serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serialize an argument to BCS-serialized bytes. +Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains +the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+Parameters
- serializer: Serializer
The serializer used to convert the argument.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serialize an argument to BCS-serialized bytes as a type aware byte sequence. +The byte sequence contains an enum variant index followed by the BCS-serialized +bytes for a typed argument.
+Parameters
- serializer: Serializer
Returns void
to
- to
Move Vector<T>(cls): MoveVector<T> Deserialize the bytecode into a MoveVector of the specified type. +This function allows you to convert serialized data into a usable MoveVector format.
+Type Parameters
- T extends Serializable & EntryFunctionArgument
Parameters
- cls: Deserializable<T>
The class type of the elements in the MoveVector.
+
Returns MoveVector<T>
to
to
Staticdeserialize
- deserialize(deserializer): Serialized
Parameters
- deserializer: Deserializer
Returns Serialized
Class Serializer
A class for serializing various data types into a binary format. +It provides methods to serialize strings, bytes, numbers, and other serializable objects +using the Binary Coded Serialization (BCS) layout. The serialized data can be retrieved as a +Uint8Array.
+ Index
Constructors
constructor
- new
Serializer(length?): Serializer Constructs a serializer with a buffer of size
+lengthbytes, 64 bytes by default. +Thelengthmust be greater than 0.Parameters
- length: number = 64
The size of the buffer in bytes.
+
Returns Serializer
- length: number = 64
Methods
serialize
- serialize<T>(value): void
Serializes a
+Serializablevalue, facilitating composable serialization.Type Parameters
- T extends Serializable
Parameters
- value: T
The Serializable value to serialize.
+
Returns void
the serializer instance
+
serialize
serialize
- serialize
Bytes(value): void Serializes an array of bytes.
+This function encodes the length of the byte array as a u32 integer in uleb128 format, followed by the byte array itself. +BCS layout for "bytes": bytes_length | bytes +where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.
+Parameters
- value: Uint8Array
The byte array to serialize.
+
Returns void
- value: Uint8Array
serialize
- serialize
Fixed Bytes(value): void Serializes an array of bytes with a known length, allowing for efficient deserialization without needing to serialize the +length itself. +When deserializing, the number of bytes to deserialize needs to be passed in.
+Parameters
- value: Uint8Array
The Uint8Array to be serialized.
+
Returns void
- value: Uint8Array
serialize
- serialize
Option<T>(value?, len?): void Serializes an optional value which can be a Serializable, string, or Uint8Array. +For strings and Uint8Arrays, it uses the appropriate serialization method.
+Type Parameters
- T extends string | Uint8Array | Serializable
Parameters
Optionalvalue: TThe value to serialize (Serializable, string, Uint8Array, or undefined)
+Optionallen: numberOptional fixed length for Uint8Array serialization. If provided, uses serializeFixedBytes instead of serializeBytes
+
Returns void
Example
+ +const serializer = new Serializer();
serializer.serializeOption("hello"); // Serializes optional string
serializer.serializeOption(new Uint8Array([1, 2, 3])); // Serializes optional bytes
serializer.serializeOption(new Uint8Array([1, 2, 3]), 3); // Serializes optional fixed-length bytes
serializer.serializeOption(new AccountAddress(...)); // Serializes optional Serializable
serializer.serializeOption(undefined); // Serializes none case +
serialize
- serialize
Option Str(value?): void Parameters
Optionalvalue: stringThe optional string to serialize. If undefined, it will serialize as 0.
+
Returns void
Deprecated
use
+serializeOptioninstead. +Serializes an optional string, supporting UTF8 encoding. +The function encodes the existence of the string first, followed by the length and content if it exists.BCS layout for optional "string": 1 | string_length | string_content +where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content. +BCS layout for undefined: 0
+
serialize
- serialize
Str(value): void Serializes a string. UTF8 string is supported. +The number of bytes in the string content is serialized first, as a uleb128-encoded u32 integer. +Then the string content is serialized as UTF8 encoded bytes.
+BCS layout for "string": string_length | string_content +where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
+Parameters
- value: string
The string to serialize.
+
Returns void
- value: string
serialize
- serialize
U128(value): void Serializes a U128 value into a format suitable for storage or transmission.
+Parameters
- value: AnyNumber
The U128 value to serialize, represented as a number.
+
Returns void
- value: AnyNumber
serialize
serialize
- serialize
U256(value): void Serializes a U256 value into a byte representation. +This function is essential for encoding large numbers in a compact format suitable for transmission or storage.
+Parameters
- value: AnyNumber
The U256 value to serialize, represented as an AnyNumber.
+
Returns void
- value: AnyNumber
serialize
serialize
- serialize
U32 As Uleb128(val): void Serializes a 32-bit unsigned integer as a variable-length ULEB128 encoded byte array. +BCS uses uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
+Parameters
- val: number
The 32-bit unsigned integer value to be serialized.
+
Returns void
- val: number
serialize
- serialize
U64(value): void Serializes a 64-bit unsigned integer into a format suitable for storage or transmission. +This function breaks down the value into two 32-bit components and writes them in little-endian order.
+Parameters
- value: AnyNumber
The 64-bit unsigned integer to serialize, represented as a number.
+
Returns void
- value: AnyNumber
serialize
serialize
- serialize
Vector<T>(values): void Serializes an array of BCS Serializable values to a serializer instance. +The bytes are added to the serializer instance's byte buffer.
+Type Parameters
- T extends Serializable
Parameters
- values: T[]
The array of BCS Serializable values
+
Returns void
Example
+ +const addresses = new Array<AccountAddress>(
AccountAddress.from("0x1"),
AccountAddress.from("0x2"),
AccountAddress.from("0xa"),
AccountAddress.from("0xb"),
);
const serializer = new Serializer();
serializer.serializeVector(addresses);
const serializedBytes = serializer.toUint8Array();
// serializedBytes is now the BCS-serialized bytes
// The equivalent value in Move would be:
// `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`; +
to
Class SignatureAbstract
An abstract representation of a crypto signature, +associated with a specific signature scheme, e.g., Ed25519 or Secp256k1.
+This class represents the product of signing a message directly from a +PrivateKey and can be verified against a CryptoPublicKey.
+Hierarchy (view full)
Index
Constructors
Methods
Methods
bcs
bcs
Abstractserialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
Class SignedTransaction
Represents a signed transaction that includes a raw transaction and an authenticator. +The authenticator contains a client's public key and the signature of the raw transaction.
+Hierarchy (view full)
- Serializable
- SignedTransaction
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Signed Transaction(raw_txn, authenticator): SignedTransaction Represents a signed transaction that includes a raw transaction and an authenticator. +The authenticator contains a client's public key and the signature of the raw transaction, +which can be of three types: single signature, multi-signature, and multi-agent.
+Parameters
- raw_txn: RawTransaction
The raw transaction to be signed.
+ - authenticator: TransactionAuthenticator
Contains a client's public key and the signature of the raw transaction. The authenticator has 3 +flavors: single signature, multi-signature and multi-agent.
+
Returns SignedTransaction
- raw_txn: RawTransaction
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the raw transaction and its authenticator using the provided serializer. +This function is essential for preparing the transaction data for transmission or storage.
+Parameters
- serializer: Serializer
The serializer instance used to serialize the transaction and authenticator.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer): SignedTransaction
Deserializes a signed transaction from the provided deserializer. +This function allows you to reconstruct a SignedTransaction object from its serialized form, enabling further processing or validation.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns SignedTransaction
- deserializer: Deserializer
Class SimpleTransaction
Represents a simple transaction type that can be submitted to the Aptos chain for execution.
+This transaction type is designed for a single signer and includes metadata such as the Raw Transaction +and an optional sponsor Account Address to cover gas fees.
+Hierarchy (view full)
- Serializable
- SimpleTransaction
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Simple Transaction(rawTransaction, feePayerAddress?): SimpleTransaction SimpleTransaction represents a transaction signed by a single account that +can be submitted to the Aptos chain for execution.
+Parameters
- rawTransaction: RawTransaction
The Raw Transaction.
+ OptionalfeePayerAddress: AccountAddressThe optional sponsor Account Address to pay the gas fees.
+
Returns SimpleTransaction
- rawTransaction: RawTransaction
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the transaction data using the provided serializer. +This function ensures that the raw transaction and fee payer address are properly serialized for further processing.
+Parameters
- serializer: Serializer
The serializer instance used to serialize the transaction data.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer): SimpleTransaction
Deserializes a SimpleTransaction from the given deserializer. +This function helps in reconstructing a SimpleTransaction object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns SimpleTransaction
- deserializer: Deserializer
Class SingleKeyAccount
Signer implementation for the SingleKey authentication scheme. +This class extends a SingleKeyAccount by adding signing capabilities through a valid private key. +Currently, the only supported signature schemes are Ed25519 and Secp256k1.
+Note: Generating a signer instance does not create the account on-chain.
+Implements
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Single Key Account(args): SingleKeyAccount Creates an instance of the SingleKeySigner using the provided private key and address. +This allows for signing transactions and messages with the specified private key.
+Parameters
- args: SingleKeySignerConstructorArgs
The constructor arguments for initializing the SingleKeySigner.
+
Returns SingleKeyAccount
- args: SingleKeySignerConstructorArgs
Methods
sign
- sign(message): AnySignature
Sign the given message using the account's private key.
+Parameters
- message: HexInput
The message to be signed in HexInput format.
+
Returns AnySignature
A new AnySignature containing the signature of the message.
+- message: HexInput
sign
- sign
Transaction(transaction): AnySignature Sign the given transaction using the account's private key. +This function generates a signing message for the transaction and then signs it.
+Parameters
- transaction: AnyRawTransaction
The transaction to be signed.
+
Returns AnySignature
Signature - The resulting signature for the signed transaction.
+- transaction: AnyRawTransaction
sign
- sign
Transaction With Authenticator(transaction): AccountAuthenticatorSingleKey Sign a transaction using the account's private key. +This function returns an AccountAuthenticator that contains the signature of the transaction along with the account's public key.
+Parameters
- transaction: AnyRawTransaction
The raw transaction to be signed.
+
Returns AccountAuthenticatorSingleKey
An AccountAuthenticatorSingleKey containing the signature of the transaction and the account's public key.
+- transaction: AnyRawTransaction
sign
- sign
With Authenticator(message): AccountAuthenticatorSingleKey Sign a message using the account's private key and return an AccountAuthenticator containing the signature along with the +account's public key.
+Parameters
- message: HexInput
The signing message, represented as binary input in hexadecimal format.
+
Returns AccountAuthenticatorSingleKey
An instance of AccountAuthenticatorSingleKey containing the signature and the public key.
+- message: HexInput
verify
- verify
Signature(args): boolean Verify the given message and signature with the public key.
+Parameters
- args: VerifySingleKeySignatureArgs
The arguments for verifying the signature.
+
Returns boolean
A boolean indicating whether the signature is valid.
+- args: VerifySingleKeySignatureArgs
Staticfrom
- from
Derivation Path(args): SingleKeyAccount Derives an account using a specified BIP44 path and mnemonic seed phrase, defaulting to the Ed25519 signature scheme. +This function allows you to create a single key account based on the provided derivation path and mnemonic.
+Parameters
- args: SingleKeySignerFromDerivationPathArgs
The arguments for deriving the account.
+
Returns SingleKeyAccount
- args: SingleKeySignerFromDerivationPathArgs
Staticgenerate
- generate(args?): SingleKeyAccount
Derives an account from a randomly generated private key based on the specified signing scheme. +The default generation scheme is Ed25519, but it can also support Secp256k1Ecdsa.
+Parameters
- args: SingleKeySignerGenerateArgs = {}
The arguments for generating the account.
+
Returns SingleKeyAccount
An account with the generated private key based on the specified signing scheme.
+- args: SingleKeySignerGenerateArgs = {}
Class StructTag
Represents a structured tag that includes an address, module name, +name, and type arguments. This class is used to define and manage +structured data types within the SDK.
+Hierarchy (view full)
- Serializable
- StructTag
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Struct Tag(address, module_name, name, type_args): StructTag Parameters
- address: AccountAddress
- module_name: Identifier
- name: Identifier
- type_args: TypeTag[]
Returns StructTag
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): StructTag
Parameters
- deserializer: Deserializer
Returns StructTag
Class TransactionAndProof
A container class to hold a transaction and a proof. It implements CryptoHashable which is used to create +the signing message for Keyless transactions. We sign over the proof to ensure non-malleability.
+Hierarchy (view full)
- Serializable
- TransactionAndProof
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Transaction And Proof(transaction, proof?): TransactionAndProof Parameters
- transaction: AnyRawTransactionInstance
Optionalproof: ZkProof
Returns TransactionAndProof
Methods
bcs
bcs
hash
serialize
- serialize(serializer): void
Serializes the transaction data into a format suitable for transmission or storage. +This function ensures that both the transaction bytes and the proof are properly serialized.
+Parameters
- serializer: Serializer
The serializer instance used to convert the transaction data into bytes.
+
Returns void
- serializer: Serializer
to
to
Class TransactionAuthenticatorAbstract
Represents an abstract base class for transaction authenticators. +This class provides methods for serializing and deserializing different types of transaction authenticators.
+Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Transaction Authenticator(): TransactionAuthenticator Returns TransactionAuthenticator
Methods
bcs
bcs
is
- is
Ed25519(): this is TransactionAuthenticatorEd25519 Returns this is TransactionAuthenticatorEd25519
is
- is
Fee Payer(): this is TransactionAuthenticatorFeePayer Returns this is TransactionAuthenticatorFeePayer
is
- is
Multi Agent(): this is TransactionAuthenticatorMultiAgent Returns this is TransactionAuthenticatorMultiAgent
is
- is
Multi Ed25519(): this is TransactionAuthenticatorMultiEd25519 Returns this is TransactionAuthenticatorMultiEd25519
is
- is
Single Sender(): this is TransactionAuthenticatorSingleSender Returns this is TransactionAuthenticatorSingleSender
Abstractserialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TransactionAuthenticator
Deserializes a TransactionAuthenticator from the provided deserializer. +This function helps in reconstructing the TransactionAuthenticator based on the variant index found in the serialized data.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns TransactionAuthenticator
- deserializer: Deserializer
Class TransactionAuthenticatorEd25519
Represents a transaction authenticator using Ed25519 for a single signer transaction. +This class encapsulates the client's public key and the Ed25519 signature of a raw transaction.
+See
Creating a Signed Transaction +for details about generating a signature.
+Hierarchy (view full)
- TransactionAuthenticator
- TransactionAuthenticatorEd25519
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Transaction Authenticator Ed25519(public_key, signature): TransactionAuthenticatorEd25519 Creates an instance of the class with the specified account authenticator.
+Parameters
- public_key: Ed25519PublicKey
The Ed25519PublicKey that will be used for authentication.
+ - signature: Ed25519Signature
The Ed25519Signature that will be used for authentication.
+
Returns TransactionAuthenticatorEd25519
- public_key: Ed25519PublicKey
Methods
bcs
bcs
is
- is
Ed25519(): this is TransactionAuthenticatorEd25519 Returns this is TransactionAuthenticatorEd25519
is
- is
Fee Payer(): this is TransactionAuthenticatorFeePayer Returns this is TransactionAuthenticatorFeePayer
is
- is
Multi Agent(): this is TransactionAuthenticatorMultiAgent Returns this is TransactionAuthenticatorMultiAgent
is
- is
Multi Ed25519(): this is TransactionAuthenticatorMultiEd25519 Returns this is TransactionAuthenticatorMultiEd25519
is
- is
Single Sender(): this is TransactionAuthenticatorSingleSender Returns this is TransactionAuthenticatorSingleSender
serialize
- serialize(serializer): void
Serializes the transaction authenticator by encoding the sender information.
+Parameters
- serializer: Serializer
The serializer instance used to perform the serialization.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer): TransactionAuthenticator
Deserializes a TransactionAuthenticator from the provided deserializer. +This function helps in reconstructing the TransactionAuthenticator based on the variant index found in the serialized data.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns TransactionAuthenticator
- deserializer: Deserializer
Staticload
- load(deserializer): TransactionAuthenticatorEd25519
Loads a TransactionAuthenticatorSingleSender instance from the provided deserializer. +This function helps in deserializing the sender information to create a transaction authenticator.
+Parameters
- deserializer: Deserializer
The deserializer used to extract the sender data.
+
Returns TransactionAuthenticatorEd25519
- deserializer: Deserializer
Class TransactionAuthenticatorFeePayer
Represents a transaction authenticator specifically for fee payer transactions. +It encapsulates the sender's account authenticator, addresses of secondary signers, +their respective authenticators, and the fee payer's account information.
+Hierarchy (view full)
- TransactionAuthenticator
- TransactionAuthenticatorFeePayer
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Transaction Authenticator Fee Payer(sender, secondary_signer_addresses, secondary_signers, fee_payer): TransactionAuthenticatorFeePayer Parameters
- sender: AccountAuthenticator
- secondary_signer_addresses: AccountAddress[]
- secondary_signers: AccountAuthenticator[]
- fee_payer: {
address: AccountAddress;
authenticator: AccountAuthenticator;
}address: AccountAddress
authenticator: AccountAuthenticator
Returns TransactionAuthenticatorFeePayer
Methods
bcs
bcs
is
- is
Ed25519(): this is TransactionAuthenticatorEd25519 Returns this is TransactionAuthenticatorEd25519
is
- is
Fee Payer(): this is TransactionAuthenticatorFeePayer Returns this is TransactionAuthenticatorFeePayer
is
- is
Multi Agent(): this is TransactionAuthenticatorMultiAgent Returns this is TransactionAuthenticatorMultiAgent
is
- is
Multi Ed25519(): this is TransactionAuthenticatorMultiEd25519 Returns this is TransactionAuthenticatorMultiEd25519
is
- is
Single Sender(): this is TransactionAuthenticatorSingleSender Returns this is TransactionAuthenticatorSingleSender
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TransactionAuthenticator
Deserializes a TransactionAuthenticator from the provided deserializer. +This function helps in reconstructing the TransactionAuthenticator based on the variant index found in the serialized data.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns TransactionAuthenticator
- deserializer: Deserializer
Staticload
- load(deserializer): TransactionAuthenticatorMultiAgent
Parameters
- deserializer: Deserializer
Returns TransactionAuthenticatorMultiAgent
Class TransactionAuthenticatorMultiAgent
Represents a transaction authenticator for a multi-agent transaction.
+This class manages the authentication process involving a primary sender and multiple secondary signers.
+Hierarchy (view full)
- TransactionAuthenticator
- TransactionAuthenticatorMultiAgent
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Transaction Authenticator Multi Agent(sender, secondary_signer_addresses, secondary_signers): TransactionAuthenticatorMultiAgent Parameters
- sender: AccountAuthenticator
- secondary_signer_addresses: AccountAddress[]
- secondary_signers: AccountAuthenticator[]
Returns TransactionAuthenticatorMultiAgent
Methods
bcs
bcs
is
- is
Ed25519(): this is TransactionAuthenticatorEd25519 Returns this is TransactionAuthenticatorEd25519
is
- is
Fee Payer(): this is TransactionAuthenticatorFeePayer Returns this is TransactionAuthenticatorFeePayer
is
- is
Multi Agent(): this is TransactionAuthenticatorMultiAgent Returns this is TransactionAuthenticatorMultiAgent
is
- is
Multi Ed25519(): this is TransactionAuthenticatorMultiEd25519 Returns this is TransactionAuthenticatorMultiEd25519
is
- is
Single Sender(): this is TransactionAuthenticatorSingleSender Returns this is TransactionAuthenticatorSingleSender
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TransactionAuthenticator
Deserializes a TransactionAuthenticator from the provided deserializer. +This function helps in reconstructing the TransactionAuthenticator based on the variant index found in the serialized data.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns TransactionAuthenticator
- deserializer: Deserializer
Staticload
- load(deserializer): TransactionAuthenticatorMultiAgent
Parameters
- deserializer: Deserializer
Returns TransactionAuthenticatorMultiAgent
Class TransactionAuthenticatorMultiEd25519
Represents a transaction authenticator for multi-signature transactions using Ed25519. +This class is used to validate transactions that require multiple signatures from different signers.
+Hierarchy (view full)
- TransactionAuthenticator
- TransactionAuthenticatorMultiEd25519
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Transaction Authenticator Multi Ed25519(public_key, signature): TransactionAuthenticatorMultiEd25519 Parameters
- public_key: MultiEd25519PublicKey
- signature: MultiEd25519Signature
Returns TransactionAuthenticatorMultiEd25519
Methods
bcs
bcs
is
- is
Ed25519(): this is TransactionAuthenticatorEd25519 Returns this is TransactionAuthenticatorEd25519
is
- is
Fee Payer(): this is TransactionAuthenticatorFeePayer Returns this is TransactionAuthenticatorFeePayer
is
- is
Multi Agent(): this is TransactionAuthenticatorMultiAgent Returns this is TransactionAuthenticatorMultiAgent
is
- is
Multi Ed25519(): this is TransactionAuthenticatorMultiEd25519 Returns this is TransactionAuthenticatorMultiEd25519
is
- is
Single Sender(): this is TransactionAuthenticatorSingleSender Returns this is TransactionAuthenticatorSingleSender
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TransactionAuthenticator
Deserializes a TransactionAuthenticator from the provided deserializer. +This function helps in reconstructing the TransactionAuthenticator based on the variant index found in the serialized data.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns TransactionAuthenticator
- deserializer: Deserializer
Staticload
- load(deserializer): TransactionAuthenticatorMultiEd25519
Parameters
- deserializer: Deserializer
Returns TransactionAuthenticatorMultiEd25519
Class TransactionAuthenticatorSingleSender
Represents a single sender authenticator for transactions that require a single signer. +This class is responsible for managing the authentication of a transaction initiated by a single sender.
+Hierarchy (view full)
- TransactionAuthenticator
- TransactionAuthenticatorSingleSender
Index
Constructors
constructor
- new
Transaction Authenticator Single Sender(sender): TransactionAuthenticatorSingleSender Parameters
- sender: AccountAuthenticator
Returns TransactionAuthenticatorSingleSender
Methods
bcs
bcs
is
- is
Ed25519(): this is TransactionAuthenticatorEd25519 Returns this is TransactionAuthenticatorEd25519
is
- is
Fee Payer(): this is TransactionAuthenticatorFeePayer Returns this is TransactionAuthenticatorFeePayer
is
- is
Multi Agent(): this is TransactionAuthenticatorMultiAgent Returns this is TransactionAuthenticatorMultiAgent
is
- is
Multi Ed25519(): this is TransactionAuthenticatorMultiEd25519 Returns this is TransactionAuthenticatorMultiEd25519
is
- is
Single Sender(): this is TransactionAuthenticatorSingleSender Returns this is TransactionAuthenticatorSingleSender
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TransactionAuthenticator
Deserializes a TransactionAuthenticator from the provided deserializer. +This function helps in reconstructing the TransactionAuthenticator based on the variant index found in the serialized data.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns TransactionAuthenticator
- deserializer: Deserializer
Staticload
- load(deserializer): TransactionAuthenticatorSingleSender
Parameters
- deserializer: Deserializer
Returns TransactionAuthenticatorSingleSender
Class TransactionPayloadAbstract
Represents a supported Transaction Payload that can be serialized and deserialized.
+This class serves as a base for different types of transaction payloads, allowing for +their serialization into a format suitable for transmission and deserialization back +into their original form.
+Hierarchy (view full)
Index
Constructors
Methods
Constructors
constructor
- new
Transaction Payload(): TransactionPayload Returns TransactionPayload
Methods
bcs
bcs
Abstractserialize
- serialize(serializer): void
Serialize a Transaction Payload
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TransactionPayload
Deserializes a multisig transaction payload from the provided deserializer. +This function enables the reconstruction of a MultiSigTransactionPayload object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns TransactionPayload
- deserializer: Deserializer
Class TransactionPayloadEntryFunction
Represents a transaction payload entry function that can be serialized and deserialized.
+Hierarchy (view full)
- TransactionPayload
- TransactionPayloadEntryFunction
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Transaction Payload Entry Function(entryFunction): TransactionPayloadEntryFunction Parameters
- entryFunction: EntryFunction
Returns TransactionPayloadEntryFunction
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize a Transaction Payload
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TransactionPayload
Deserializes a multisig transaction payload from the provided deserializer. +This function enables the reconstruction of a MultiSigTransactionPayload object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns TransactionPayload
- deserializer: Deserializer
Staticload
- load(deserializer): TransactionPayloadEntryFunction
Parameters
- deserializer: Deserializer
Returns TransactionPayloadEntryFunction
Class TransactionPayloadMultiSig
Represents a multi-signature transaction payload that can be serialized and deserialized.
+Hierarchy (view full)
- TransactionPayload
- TransactionPayloadMultiSig
Index
Constructors
constructor
- new
Transaction Payload Multi Sig(multiSig): TransactionPayloadMultiSig Parameters
- multiSig: MultiSig
Returns TransactionPayloadMultiSig
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize a Transaction Payload
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TransactionPayload
Deserializes a multisig transaction payload from the provided deserializer. +This function enables the reconstruction of a MultiSigTransactionPayload object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns TransactionPayload
- deserializer: Deserializer
Staticload
- load(deserializer): TransactionPayloadMultiSig
Parameters
- deserializer: Deserializer
Returns TransactionPayloadMultiSig
Class TransactionPayloadScript
Represents a transaction payload script that can be serialized and deserialized.
+This class encapsulates a script that defines the logic for a transaction payload.
+Hierarchy (view full)
- TransactionPayload
- TransactionPayloadScript
Index
Constructors
constructor
- new
Transaction Payload Script(script): TransactionPayloadScript Initializes a multi-sig account transaction with the provided payload.
+Parameters
- script: Script
The payload of the multi-sig transaction. This can only be an EntryFunction for now, but Script might be +supported in the future.
+
Returns TransactionPayloadScript
- script: Script
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serializes the transaction payload, enabling future support for multiple types of inner transaction payloads.
+Parameters
- serializer: Serializer
The serializer instance used to serialize the transaction data.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer): TransactionPayload
Deserializes a multisig transaction payload from the provided deserializer. +This function enables the reconstruction of a MultiSigTransactionPayload object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns TransactionPayload
- deserializer: Deserializer
Staticload
- load(deserializer): TransactionPayloadScript
Loads a MultiSig transaction payload from the provided deserializer. +This function helps in reconstructing a MultiSig transaction payload from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer used to read the serialized data.
+
Returns TransactionPayloadScript
- deserializer: Deserializer
Class TransactionWorker
TransactionWorker provides a simple framework for receiving payloads to be processed.
+Once one start() the process and pushes a new transaction, the worker acquires
+the current account's next sequence number (by using the AccountSequenceNumber class),
+generates a signed transaction and pushes an async submission process into the outstandingTransactions queue.
+At the same time, the worker processes transactions by reading the outstandingTransactions queue
+and submits the next transaction to chain, it
-
+
- waits for resolution of the submission process or get pre-execution validation error +and 2) waits for the resolution of the execution process or get an execution error. +The worker fires events for any submission and/or execution success and/or failure. +
Hierarchy (view full)
- EventEmitter<TransactionWorkerEvents>
- TransactionWorker
Index
Constructors
Events
Methods
Properties
Constructors
constructor
- new
Transaction Worker(aptosConfig, account, maxWaitTime?, maximumInFlight?, sleepTime?): TransactionWorker Initializes a new instance of the class, providing a framework for receiving payloads to be processed.
+Parameters
- aptosConfig: AptosConfig
A configuration object for Aptos.
+ - account: Account
The account that will be used for sending transactions.
+ - maxWaitTime: number = 30
The maximum wait time to wait before re-syncing the sequence number to the current on-chain state, +default is 30 seconds.
+ - maximumInFlight: number = 100
The maximum number of transactions that can be submitted per account, default is 100.
+ - sleepTime: number = 10
The time to wait in seconds before re-evaluating if the maximum number of transactions are in flight, +default is 10 seconds.
+
Returns TransactionWorker
- aptosConfig: AptosConfig
Events
process
- process
Transactions(): Promise<void> Reads the outstanding transaction queue and submits the transactions to the chain. +This function processes each transaction, checking their status and emitting events based on whether they were successfully +sent or failed.
+Returns Promise<void>
Throws
Throws an error if the process execution fails. +TransactionWorkerEventsEnum.TransactionSent - Emitted when a transaction has been successfully committed to the chain. +TransactionWorkerEventsEnum.TransactionSendFailed - Emitted when a transaction fails to commit, along with the error +reason. +TransactionWorkerEventsEnum.ExecutionFinish - Emitted when the execution of transactions is complete.
+
Methods
add
- add
Listener<T>(event, fn, context?): this Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
- fn: ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)
- (...args): void
Parameters
Rest...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]
Returns void
Optionalcontext: any
Returns this
check
- check
Transaction(sentTransaction, sequenceNumber): Promise<void> Once a transaction has been sent to the chain, this function checks for its execution status.
+Parameters
- sentTransaction: PromiseFulfilledResult<PendingTransactionResponse>
The transaction that was sent to the chain and is now waiting to be executed.
+ - sequenceNumber: bigint
The account's sequence number that was sent with the transaction.
+
Returns Promise<void>
- sentTransaction: PromiseFulfilledResult<PendingTransactionResponse>
emit
- emit<T>(event, ...args): boolean
Calls each of the listeners registered for a given event.
+Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
Rest...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]
Returns boolean
event
- event
Names(): (keyof TransactionWorkerEvents)[] Return an array listing the events for which the emitter has registered +listeners.
+Returns (keyof TransactionWorkerEvents)[]
generate
- generate
Next Transaction(account, sequenceNumber): Promise<undefined | SimpleTransaction> Generates a signed transaction that can be submitted to the chain.
+Parameters
- account: Account
An Aptos account used as the sender of the transaction.
+ - sequenceNumber: bigint
A sequence number the transaction will be generated with.
+
Returns Promise<undefined | SimpleTransaction>
A signed transaction object or undefined if the transaction queue is empty.
+- account: Account
listener
- listener
Count(event): number Return the number of listeners listening to a given event.
+Parameters
- event: keyof TransactionWorkerEvents
Returns number
listeners
- listeners<T>(event): ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)[]
Return the listeners registered for a given event.
+Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
Returns ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)[]
off
- off<T>(event, fn?, context?, once?): this
Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
Optionalfn: ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)- (...args): void
Parameters
Rest...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]
Returns void
Optionalcontext: anyOptionalonce: boolean
Returns this
on
- on<T>(event, fn, context?): this
Add a listener for a given event.
+Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
- fn: ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)
- (...args): void
Parameters
Rest...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]
Returns void
Optionalcontext: any
Returns this
once
- once<T>(event, fn, context?): this
Add a one-time listener for a given event.
+Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
- fn: ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)
- (...args): void
Parameters
Rest...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]
Returns void
Optionalcontext: any
Returns this
push
- push(transactionData, options?): Promise<void>
Pushes a transaction to the transactions queue for processing.
+Parameters
- transactionData: InputGenerateTransactionPayloadData
The transaction payload containing necessary details.
+ Optionaloptions: InputGenerateTransactionOptionsOptional parameters for transaction configuration.
+
Returns Promise<void>
- transactionData: InputGenerateTransactionPayloadData
remove
remove
- remove
Listener<T>(event, fn?, context?, once?): this Remove the listeners of a given event.
+Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
Optionalfn: ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)- (...args): void
Parameters
Rest...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]
Returns void
Optionalcontext: anyOptionalonce: boolean
Returns this
run
start
stop
submit
- submit
Next Transaction(): Promise<void> Submits the next transaction for the account by generating it with the current sequence number +and adding it to the outstanding transaction queue for processing. +This function continues to submit transactions until there are no more to process.
+Returns Promise<void>
Properties
Readonlyaccount
Readonlyaccount
Readonlyaptos
executed
transactions that have been committed to chain
+outstanding
signed transactions waiting to be submitted
+sent
transactions that have been submitted to chain
+started
Readonlytask
transactions
transactions payloads waiting to be generated and signed
+TODO support entry function payload from ABI builder
+Staticprefixed
Class TypeTagAbstract
Represents a type tag in the serialization framework, serving as a base class for various specific type tags. +This class provides methods for serialization and deserialization of type tags, as well as type checking methods +to determine the specific type of the tag at runtime.
+Hierarchy (view full)
Index
Constructors
Methods
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
Abstractserialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
Abstractto
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Class TypeTagAddress
Represents a type tag for an address in the system. +This class extends the TypeTag class and provides functionality +to serialize the address type and load it from a deserializer.
+Hierarchy (view full)
- TypeTag
- TypeTagAddress
Index
Constructors
Methods
Constructors
constructor
- new
Type Tag Address(): TypeTagAddress Returns TypeTagAddress
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(_deserializer): TypeTagAddress
Parameters
- _deserializer: Deserializer
Returns TypeTagAddress
Class TypeTagBool
Represents a boolean type tag in the type system. +This class extends the base TypeTag class and provides +methods for serialization and deserialization of the boolean +type tag.
+Hierarchy (view full)
- TypeTag
- TypeTagBool
Index
Constructors
Methods
Constructors
constructor
- new
Type Tag Bool(): TypeTagBool Returns TypeTagBool
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Serializes the current instance's properties into a provided serializer. +This function ensures that the address, module name, name, and type arguments are properly serialized.
+Parameters
- serializer: Serializer
The serializer instance used to serialize the properties.
+
Returns void
- serializer: Serializer
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(_deserializer): TypeTagBool
Deserializes a StructTag and returns a new TypeTagStruct instance.
+Parameters
- _deserializer: Deserializer
The deserializer used to read the StructTag data.
+
Returns TypeTagBool
- _deserializer: Deserializer
Class TypeTagGeneric
Represents a generic type tag used for type parameters in entry functions. +Generics are not serialized into a real type, so they cannot be used as a type directly.
+Hierarchy (view full)
- TypeTag
- TypeTagGeneric
Index
Constructors
constructor
- new
Type Tag Generic(value): TypeTagGeneric Parameters
- value: number
Returns TypeTagGeneric
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(deserializer): TypeTagGeneric
Parameters
- deserializer: Deserializer
Returns TypeTagGeneric
Class TypeTagParserError
Represents an error that occurs during the parsing of a type tag. +This error extends the built-in Error class and provides additional context +regarding the specific type tag that failed to parse and the reason for the failure.
+Hierarchy (view full)
- Error
- TypeTagParserError
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Type Tag Parser Error(typeTagStr, invalidReason): TypeTagParserError Constructs an error indicating a failure to parse a type tag. +This error provides details about the specific type tag that could not be parsed and the reason for the failure.
+Parameters
- typeTagStr: string
The string representation of the type tag that failed to parse.
+ - invalidReason: TypeTagParserErrorType
The reason why the type tag is considered invalid.
+
Returns TypeTagParserError
- typeTagStr: string
Class TypeTagReference
Represents a reference to a type tag in the type system. +This class extends the TypeTag class and provides functionality +to serialize and deserialize type tag references.
+Hierarchy (view full)
- TypeTag
- TypeTagReference
Index
Constructors
constructor
- new
Type Tag Reference(value): TypeTagReference Initializes a new instance of the class with the specified parameters.
+Parameters
- value: TypeTag
The TypeTag to reference.
+
Returns TypeTagReference
- value: TypeTag
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(deserializer): TypeTagReference
Parameters
- deserializer: Deserializer
Returns TypeTagReference
Class TypeTagSigner
Represents a type tag for a signer in the system. +This class extends the base TypeTag and provides specific functionality +related to the signer type.
+Hierarchy (view full)
- TypeTag
- TypeTagSigner
Index
Constructors
Methods
Constructors
constructor
- new
Type Tag Signer(): TypeTagSigner Returns TypeTagSigner
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(_deserializer): TypeTagSigner
Parameters
- _deserializer: Deserializer
Returns TypeTagSigner
Class TypeTagStruct
Represents a structured type tag in the system, extending the base TypeTag class. +This class encapsulates information about a specific structure, including its address, +module name, and type arguments, and provides methods for serialization and type checking.
+Hierarchy (view full)
- TypeTag
- TypeTagStruct
Index
Constructors
constructor
- new
Type Tag Struct(value): TypeTagStruct Parameters
- value: StructTag
Returns TypeTagStruct
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
Type Tag(address, moduleName, structName): boolean Determines if the provided address, module name, and struct name match the current type tag.
+Parameters
- address: AccountAddress
The account address to compare against the type tag.
+ - moduleName: string
The name of the module to compare against the type tag.
+ - structName: string
The name of the struct to compare against the type tag.
+
Returns boolean
True if the address, module name, and struct name match the type tag; otherwise, false.
+- address: AccountAddress
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(deserializer): TypeTagStruct
Parameters
- deserializer: Deserializer
Returns TypeTagStruct
Class TypeTagU128
Represents a type tag for the u128 data type. +This class extends the base TypeTag class and provides methods for serialization and deserialization.
+Hierarchy (view full)
- TypeTag
- TypeTagU128
Index
Constructors
Methods
Constructors
constructor
- new
Type Tag U128(): TypeTagU128 Returns TypeTagU128
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(_deserializer): TypeTagU128
Parameters
- _deserializer: Deserializer
Returns TypeTagU128
Class TypeTagU16
Represents a type tag for unsigned 16-bit integers (u16). +This class extends the base TypeTag class and provides methods for serialization and deserialization.
+Hierarchy (view full)
- TypeTag
- TypeTagU16
Index
Constructors
Methods
Constructors
constructor
- new
Type Tag U16(): TypeTagU16 Returns TypeTagU16
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(_deserializer): TypeTagU16
Parameters
- _deserializer: Deserializer
Returns TypeTagU16
Class TypeTagU256
Represents a type tag for the U256 data type. +This class extends the base TypeTag class and provides methods for serialization and deserialization.
+Hierarchy (view full)
- TypeTag
- TypeTagU256
Index
Constructors
Methods
Constructors
constructor
- new
Type Tag U256(): TypeTagU256 Returns TypeTagU256
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(_deserializer): TypeTagU256
Parameters
- _deserializer: Deserializer
Returns TypeTagU256
Class TypeTagU32
Represents a type tag for a 32-bit unsigned integer (u32). +This class extends the base TypeTag class and provides methods for serialization +and deserialization specific to the u32 type.
+Hierarchy (view full)
- TypeTag
- TypeTagU32
Index
Constructors
Methods
Constructors
constructor
- new
Type Tag U32(): TypeTagU32 Returns TypeTagU32
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(_deserializer): TypeTagU32
Parameters
- _deserializer: Deserializer
Returns TypeTagU32
Class TypeTagU64
Represents a type tag for 64-bit unsigned integers (u64). +This class extends the base TypeTag class and provides methods for serialization and deserialization.
+Hierarchy (view full)
- TypeTag
- TypeTagU64
Index
Constructors
Methods
Constructors
constructor
- new
Type Tag U64(): TypeTagU64 Returns TypeTagU64
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(_deserializer): TypeTagU64
Parameters
- _deserializer: Deserializer
Returns TypeTagU64
Class TypeTagU8
Represents a type tag for an 8-bit unsigned integer (u8). +This class extends the base TypeTag class and provides methods +for serialization and deserialization specific to the u8 type.
+Hierarchy (view full)
- TypeTag
- TypeTagU8
Index
Constructors
Methods
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(_deserializer): TypeTagU8
Parameters
- _deserializer: Deserializer
Returns TypeTagU8
Class TypeTagVector
Represents a vector type tag, which encapsulates a single type tag value. +This class extends the base TypeTag class and provides methods for serialization, +deserialization, and string representation of the vector type tag.
+Hierarchy (view full)
- TypeTag
- TypeTagVector
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Type Tag Vector(value): TypeTagVector Parameters
- value: TypeTag
Returns TypeTagVector
Methods
bcs
bcs
deserialize
- deserialize(deserializer): StructTag
Deserializes a StructTag from the provided deserializer. +This function allows you to reconstruct a StructTag object from its serialized form.
+Parameters
- deserializer: Deserializer
The deserializer instance used to read the serialized data.
+
Returns StructTag
- deserializer: Deserializer
is
- is
Address(): this is TypeTagAddress Determines if the current instance is of type TypeTagAddress.
+Returns this is TypeTagAddress
True if the instance is a TypeTagAddress, otherwise false.
+
is
- is
Bool(): this is TypeTagBool Determines if the current instance is of type TypeTagBool.
+Returns this is TypeTagBool
True if the instance is a TypeTagBool, otherwise false.
+
is
- is
Generic(): this is TypeTagGeneric Determines if the current instance is of type TypeTagGeneric.
+Returns this is TypeTagGeneric
Returns true if the instance is a TypeTagGeneric, otherwise false.
+
is
is
- is
Signer(): this is TypeTagSigner Determine if the current instance is a TypeTagSigner.
+Returns this is TypeTagSigner
Returns true if the instance is a TypeTagSigner, otherwise false.
+
is
- is
Struct(): this is TypeTagStruct Determines if the current instance is a structure type.
+Returns this is TypeTagStruct
True if the instance is of type TypeTagStruct, otherwise false.
+
is
- is
U128(): this is TypeTagU128 Determines if the current instance is of the TypeTagU128 type.
+Returns this is TypeTagU128
True if the instance is of TypeTagU128, otherwise false.
+
is
- is
U16(): this is TypeTagU16 Checks if the current instance is of type TypeTagU16.
+Returns this is TypeTagU16
True if the instance is TypeTagU16, otherwise false.
+
is
- is
U256(): this is TypeTagU256 Checks if the current instance is of type TypeTagU256.
+Returns this is TypeTagU256
Returns true if the instance is of type TypeTagU256, otherwise false.
+
is
- is
U32(): this is TypeTagU32 Checks if the current instance is of type TypeTagU32.
+Returns this is TypeTagU32
Returns true if the instance is TypeTagU32, otherwise false.
+
is
- is
U64(): this is TypeTagU64 Checks if the current instance is of type TypeTagU64.
+Returns this is TypeTagU64
True if the instance is a TypeTagU64, otherwise false.
+
is
is
- is
Vector(): this is TypeTagVector Checks if the current instance is a vector type. +This can help determine the specific type of data structure being used.
+Returns this is TypeTagVector
True if the instance is of type TypeTagVector, otherwise false.
+
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): TypeTag
Parameters
- deserializer: Deserializer
Returns TypeTag
Staticload
- load(deserializer): TypeTagVector
Parameters
- deserializer: Deserializer
Returns TypeTagVector
Staticu8
- u8(): TypeTagVector
Creates a new TypeTagVector instance with a TypeTagU8 type.
+Returns TypeTagVector
A new TypeTagVector initialized with TypeTagU8.
+
Class U128
Represents a 128-bit unsigned integer value. +This class provides methods for serialization and deserialization +of U128 values, ensuring that the values are within the valid range.
+Hierarchy (view full)
- Serializable
- U128
Implements
Index
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize an argument to BCS-serialized bytes.
+Parameters
- serializer: Serializer
The serializer instance used for serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serialize an argument to BCS-serialized bytes. +Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains +the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+Parameters
- serializer: Serializer
The serializer used to convert the argument.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serialize an argument to BCS-serialized bytes as a type aware byte sequence. +The byte sequence contains an enum variant index followed by the BCS-serialized +bytes for a typed argument.
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): U128
Parameters
- deserializer: Deserializer
Returns U128
Class U16
Represents a 16-bit unsigned integer (U16) value. +This class extends the Serializable class and provides methods for serialization +and deserialization of the U16 value.
+Hierarchy (view full)
- Serializable
- U16
Implements
Index
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize an argument to BCS-serialized bytes.
+Parameters
- serializer: Serializer
The serializer instance used for serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serialize an argument to BCS-serialized bytes. +Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains +the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+Parameters
- serializer: Serializer
The serializer used to convert the argument.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serialize an argument to BCS-serialized bytes as a type aware byte sequence. +The byte sequence contains an enum variant index followed by the BCS-serialized +bytes for a typed argument.
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): U16
Parameters
- deserializer: Deserializer
Returns U16
Class U256
Represents a 256-bit unsigned integer (U256) that extends the Serializable class. +This class provides methods for serialization and deserialization of U256 values, +ensuring that the values are within the valid range.
+Hierarchy (view full)
- Serializable
- U256
Implements
Index
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize an argument to BCS-serialized bytes.
+Parameters
- serializer: Serializer
The serializer instance used for serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serialize an argument to BCS-serialized bytes. +Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains +the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+Parameters
- serializer: Serializer
The serializer used to convert the argument.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serialize an argument to BCS-serialized bytes as a type aware byte sequence. +The byte sequence contains an enum variant index followed by the BCS-serialized +bytes for a typed argument.
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): U256
Parameters
- deserializer: Deserializer
Returns U256
Class U32
Represents a 32-bit unsigned integer (U32) that can be serialized and deserialized. +This class ensures that the value is within the valid range for a U32.
+Hierarchy (view full)
- Serializable
- U32
Implements
Index
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize an argument to BCS-serialized bytes.
+Parameters
- serializer: Serializer
The serializer instance used for serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serialize an argument to BCS-serialized bytes. +Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains +the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+Parameters
- serializer: Serializer
The serializer used to convert the argument.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serialize an argument to BCS-serialized bytes as a type aware byte sequence. +The byte sequence contains an enum variant index followed by the BCS-serialized +bytes for a typed argument.
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): U32
Parameters
- deserializer: Deserializer
Returns U32
Class U64
Represents a 64-bit unsigned integer (U64) and provides methods for serialization.
+This class ensures that the value is within the valid range for a U64 and provides +functionality to serialize the value for various use cases, including entry functions +and script functions.
+Hierarchy (view full)
- Serializable
- U64
Implements
Index
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize an argument to BCS-serialized bytes.
+Parameters
- serializer: Serializer
The serializer instance used for serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serialize an argument to BCS-serialized bytes. +Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains +the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+Parameters
- serializer: Serializer
The serializer used to convert the argument.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serialize an argument to BCS-serialized bytes as a type aware byte sequence. +The byte sequence contains an enum variant index followed by the BCS-serialized +bytes for a typed argument.
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): U64
Parameters
- deserializer: Deserializer
Returns U64
Class U8
Represents an unsigned 8-bit integer (U8) value. +This class extends the Serializable class and provides methods for serialization and deserialization of U8 values.
+Hierarchy (view full)
Implements
Index
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize an argument to BCS-serialized bytes.
+Parameters
- serializer: Serializer
The serializer instance used for serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serialize an argument to BCS-serialized bytes. +Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains +the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+Parameters
- serializer: Serializer
The serializer used to convert the argument.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serialize an argument to BCS-serialized bytes as a type aware byte sequence. +The byte sequence contains an enum variant index followed by the BCS-serialized +bytes for a typed argument.
+Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): U8
Parameters
- deserializer: Deserializer
Returns U8
Class ZeroKnowledgeSig
Represents a zero-knowledge signature, encapsulating the proof and its associated metadata.
+Hierarchy (view full)
- Signature
- ZeroKnowledgeSig
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Zero Knowledge Sig(args): ZeroKnowledgeSig Parameters
- args: {
expHorizonSecs: number;
extraField?: string;
overrideAudVal?: string;
proof: ZkProof;
trainingWheelsSignature?: EphemeralSignature;
}exp
Horizon Secs: number OptionalextraField?: string OptionaloverrideAud Val?: string proof: ZkProof
OptionaltrainingWheels Signature?: EphemeralSignature
Returns ZeroKnowledgeSig
- args: {
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
to
Staticdeserialize
- deserialize(deserializer): ZeroKnowledgeSig
Parameters
- deserializer: Deserializer
Returns ZeroKnowledgeSig
Staticfrom
- from
Bytes(bytes): ZeroKnowledgeSig Deserialize a ZeroKnowledgeSig object from its BCS serialization in bytes.
+Parameters
- bytes: Uint8Array
The bytes representing the serialized ZeroKnowledgeSig.
+
Returns ZeroKnowledgeSig
ZeroKnowledgeSig - The deserialized ZeroKnowledgeSig object.
+- bytes: Uint8Array
Properties
Readonlyexp
The max lifespan of the proof
+Optional Readonlyextra
A key value pair on the JWT token that can be specified on the signature which would reveal the value on chain. +Can be used to assert identity or other attributes.
+Optional Readonlyoverride
The 'aud' value of the recovery service which is set when recovering an account.
+Readonlyproof
The proof
+Optional Readonlytraining
The training wheels signature
+Class ZkProof
Represents a container for different types of zero-knowledge proofs.
+Hierarchy (view full)
- Serializable
- ZkProof
Index
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): ZkProof
Parameters
- deserializer: Deserializer
Returns ZkProof
Class ANS
A class to handle all ANS operations.
Hierarchy (view full)
- ANS
Index
Constructors
constructor
- new ANS(config): ANS
Initializes a new instance of the Aptos class with the provided configuration. +This allows you to interact with the Aptos blockchain using the specified network settings.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns ANS
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for connecting to the Aptos testnet
const config = new AptosConfig({ network: Network.TESTNET });
// Initialize the Aptos client with the configuration
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
get
- get
Account Domains(args): Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]> Fetches all top-level domain names for a specified account.
+Parameters
- args: GetAccountDomainsArgs
The arguments for retrieving account domains.
+
Returns Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]>A promise of an array of ANSName.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching all top-level domain names for a specific account
const domains = await aptos.getAccountDomains({
accountAddress: "0x1", // replace with a real account address
options: {
limit: 10, // specify the number of names to fetch
offset: 0, // specify the offset for pagination
orderBy: "created_at", // specify the order by which to sort the names
where: {
// additional filters can be specified here
},
},
});
console.log(domains);
}
runExample().catch(console.error); +- args: GetAccountDomainsArgs
get
- get
Account Names(args): Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]> Fetches all names for an account, including both top-level domains and subdomains.
+Parameters
- args: GetAccountNamesArgs
The arguments for fetching account names.
+
Returns Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]>A promise of an array of ANSName.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetch account names for a specific address
const accountNames = await aptos.getAccountNames({
accountAddress: "0x1", // replace with a real account address
options: {
limit: 10, // specify how many names to fetch
orderBy: "name", // specify the order by which to sort the names
},
});
console.log(accountNames);
}
runExample().catch(console.error); +- args: GetAccountNamesArgs
get
- get
Account Subdomains(args): Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]> Fetches all subdomain names for a specified account.
+Parameters
- args: GetAccountSubdomainsArgs
The arguments for retrieving subdomains.
+
Returns Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]>A promise of an array of ANSName.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching subdomain names for a specific account
const subdomains = await aptos.getAccountSubdomains({
accountAddress: "0x1", // replace with a real account address
options: {
limit: 10, // specify the number of subdomains to fetch
offset: 0, // specify the offset for pagination
orderBy: "name", // specify the order by which to sort the names
},
});
console.log(subdomains);
}
runExample().catch(console.error); +- args: GetAccountSubdomainsArgs
get
- get
Domain Subdomains(args): Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]> Fetches all subdomain names for a given domain, excluding the domain itself.
+Parameters
- args: GetDomainSubdomainsArgs
The arguments for fetching subdomains.
+
Returns Promise<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}[]>A promise that resolves to an array of ANSName.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching subdomains for a specific domain
const subdomains = await aptos.getDomainSubdomains({
domain: "test", // replace with your domain
options: {
limit: 10, // specify the number of subdomains to fetch
offset: 0, // specify the starting point for fetching
orderBy: "name", // specify the order by which to sort the results
},
});
console.log(subdomains);
}
runExample().catch(console.error); +- args: GetDomainSubdomainsArgs
get
- get
Expiration(args): Promise<undefined | number> Retrieve the expiration time of a domain name or subdomain name from the contract.
+Parameters
- args: {
name: string;
}The arguments for retrieving the expiration.
+name: string
A string of the name to retrieve.
+
Returns Promise<undefined | number>
number as a unix timestamp in milliseconds.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the expiration time for the domain "test.aptos"
const exp = await aptos.getExpiration({ name: "test.aptos" });
// Log the expiration date
console.log(new Date(exp)); // Outputs the expiration date
}
runExample().catch(console.error); +- args: {
get
- get
Name(args): Promise<undefined | {
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}> Fetches a single name from the indexer based on the provided name argument.
+Parameters
- args: {
name: string;
}The arguments for retrieving the name.
+name: string
A string of the name to retrieve, e.g. "test.aptos.apt" or "test.apt" or "test". +Can be inclusive or exclusive of the .apt suffix and can be a subdomain.
+
Returns Promise<undefined | {
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}>A promise of an ANSName or undefined if the name is not active.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching a name from the indexer
const name = await aptos.getName({ name: "test.aptos" }); // replace with a real name
console.log(name);
}
runExample().catch(console.error); +- args: {
get
- get
Owner Address(args): Promise<undefined | AccountAddress> Retrieve the owner address of a specified domain name or subdomain name from the contract.
+Parameters
- args: {
name: string;
}The arguments for retrieving the owner address.
+name: string
A string representing the name of the domain or subdomain to retrieve the owner address for.
+
Returns Promise<undefined | AccountAddress>
AccountAddress if the name is owned, undefined otherwise.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve the owner address of "test.aptos"
const owner = await aptos.getOwnerAddress({ name: "test.aptos" });
console.log(owner); // Logs the owner address or undefined if not owned
}
runExample().catch(console.error); +- args: {
get
- get
Primary Name(args): Promise<undefined | string> Retrieve the primary name for an account. An account can have multiple names, but only one primary name, which may not exist.
+Parameters
- args: {
address: AccountAddressInput;
}The arguments for retrieving the primary name.
+address: AccountAddressInput
An AccountAddressInput (address) of the account.
+
Returns Promise<undefined | string>
A string if the account has a primary name, undefined otherwise.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve the primary name for the specified account address
const name = await aptos.getPrimaryName({ address: "0x1" }); // replace with a real account address
console.log(name);
}
runExample().catch(console.error); +- args: {
get
- get
Target Address(args): Promise<undefined | AccountAddress> Retrieve the target address of a domain or subdomain name, which indicates the address the name points to for use on-chain. +Note that the target address can point to addresses that do not own the name.
+Parameters
- args: {
name: string;
}The arguments for retrieving the target address.
+name: string
A string representing the name, which can be a primary name, a subdomain, or a combination (e.g., +"primary", "primary.apt", "secondary.primary", "secondary.primary.apt").
+
Returns Promise<undefined | AccountAddress>
AccountAddress if the name has a target, undefined otherwise.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve the target address for the specified domain name
const targetAddr = await aptos.getTargetAddress({ name: "test.aptos" });
console.log(targetAddr); // Logs the target address, e.g., 0x123...
}
runExample().catch(console.error); +- args: {
register
- register
Name(args): Promise<SimpleTransaction> Registers a new name.
+This function allows you to register a domain or subdomain name with specific expiration policies and options.
+Parameters
- args: Omit<RegisterNameParameters, "aptosConfig">
Returns Promise<SimpleTransaction>
SimpleTransaction
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Registering a subdomain name assuming def.apt is already registered and belongs to the sender alice.
const txn = await aptos.registerName({
sender: "0x1", // replace with a real sender account
name: "test.aptos.apt",
expiration: {
policy: "subdomain:independent",
expirationDate: Date.now() + 30 * 24 * 60 * 60 * 1000, // expires in 30 days
},
});
console.log("Transaction:", txn);
}
runExample().catch(console.error); +
renew
- renew
Domain(args): Promise<SimpleTransaction> Renews a domain name for one year. +If a domain name was minted with V1 of the contract, it will automatically be upgraded to V2 via this transaction.
+Parameters
- args: {
name: string;
options?: InputGenerateTransactionOptions;
sender: Account;
years?: 1;
}The arguments for renewing the domain.
+name: string
A string representing the domain to renew. Subdomains cannot be renewed.
+Optionaloptions?: InputGenerateTransactionOptionsOptional transaction options.
+sender: Account
The sender account, which must be the domain owner.
+Optionalyears?: 1The number of years to renew the name. Currently, only one year is permitted.
+
Returns Promise<SimpleTransaction>
SimpleTransaction
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Renew the domain "test" for one year
const transaction = await aptos.renewDomain({
sender: Account.generate(), // replace with a real account
name: "test"
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
set
- set
Primary Name(args): Promise<SimpleTransaction> Sets the primary name for the sender account, allowing them to designate a single primary name among potentially multiple +names. An account may not have a primary name.
+Parameters
- args: {
name?: string;
options?: InputGenerateTransactionOptions;
sender: Account;
}The arguments for setting the primary name.
+Optionalname?: stringA string representing the name to set as primary (e.g., "test.aptos").
+Optionaloptions?: InputGenerateTransactionOptionsOptional transaction options.
+sender: Account
The sender account.
+
Returns Promise<SimpleTransaction>
SimpleTransaction
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Set the primary name for the sender account
const sender = Account.generate(); // replace with a real account
await aptos.setPrimaryName({ sender, name: "test.aptos" });
const primaryName = await aptos.getPrimaryName({ address: sender.accountAddress });
console.log("Primary Name:", primaryName); // Should log: "Primary Name: test.aptos"
}
runExample().catch(console.error); +- args: {
set
- set
Target Address(args): Promise<SimpleTransaction> Sets the target address of a domain or subdomain name, pointing it to a specified address for use on-chain. +The target address can be different from the owner of the name.
+Parameters
- args: {
address: AccountAddressInput;
name: string;
options?: InputGenerateTransactionOptions;
sender: Account;
}The arguments for setting the target address.
+address: AccountAddressInput
The AccountAddressInput of the address to set the domain or subdomain to.
+name: string
A string representing the domain or subdomain name (e.g., "test.aptos").
+Optionaloptions?: InputGenerateTransactionOptionsOptional settings for generating the transaction.
+sender: Account
The account initiating the transaction.
+
Returns Promise<SimpleTransaction>
SimpleTransaction
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Setting the target address for a domain name
const sender = Account.generate(); // replace with a real account
const address = "0x1"; // replace with a real account address
await aptos.setTargetAddress({
sender: sender,
name: "test.aptos",
address: address,
});
const targetAddress = await aptos.getTargetAddress({ name: "test.aptos" });
console.log(targetAddress); // Should log the address set for "test.aptos"
}
runExample().catch(console.error); +- args: {
Class Account
A class to query all Account related queries on Aptos.
Hierarchy (view full)
- Account
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Account(config): Account Creates an instance of the Aptos client with the provided configuration.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns Account
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Initialize the Aptos client with testnet configuration
const config = new AptosConfig({ network: Network.TESTNET }); // specify your own network if needed
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
derive
- derive
Account From Private Key(args): Promise<Account> Derives an account by providing a private key. This function resolves the provided private key type and derives the public +key from it.
+If the privateKey is a Secp256k1 type, it derives the account using the derived public key and auth key using the SingleKey +scheme locally. +If the privateKey is an ED25519 type, it looks up the authentication key on chain to determine whether it is a Legacy ED25519 +key or a Unified ED25519 key, and then derives the account based on that.
+Parameters
- args: {
privateKey: PrivateKey;
}The arguments for deriving the account.
+private
Key: PrivateKey An account private key.
+
Returns Promise<Account>
The derived Account type.
+Example
+ +import { Aptos, AptosConfig, Network, Ed25519PrivateKey } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Deriving an account from a private key
const account = await aptos.deriveAccountFromPrivateKey({
privateKey: new Ed25519PrivateKey("0x123") // replace with a real private key
});
console.log(account);
}
runExample().catch(console.error); +- args: {
get
- get
AccountAPTAmount(args): Promise<number> Retrieves the current amount of APT for a specified account.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The arguments for the account query.
+account
Address: AccountAddressInput The account address for which to retrieve the APT amount.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<number>
The current amount of APT for the specified account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the APT amount for a specific account
const accountAPTAmount = await aptos.getAccountAPTAmount({ accountAddress: "0x1" }); // replace with a real account address
console.log("Account APT Amount:", accountAPTAmount);
}
runExample().catch(console.error); +- args: {
get
- get
Account Coin Amount(args): Promise<number> Queries the current amount of a specified coin held by an account.
+Parameters
- args: {
accountAddress: AccountAddressInput;
coinType?: `${string}::${string}::${string}`;
faMetadataAddress?: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for querying the account's coin amount.
+account
Address: AccountAddressInput The account address to query for the coin amount.
+OptionalcoinType?: `${string}::${string}::${string}` The coin type to query. Note: If not provided, it may be automatically populated if
+faMetadataAddress+is specified.OptionalfaMetadata Address?: AccountAddressInput The fungible asset metadata address to query. Note: If not provided, it may be automatically +populated if
+coinTypeis specified.OptionalminimumLedger Version?: AnyNumber Not used anymore, here for backward compatibility +see https://github.com/aptos-labs/aptos-ts-sdk/pull/519, will be removed in the near future. +Optional ledger version to sync up to before querying.
+
Returns Promise<number>
The current amount of the specified coin held by the account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Query the account's coin amount for a specific coin type
const accountCoinAmount = await aptos.getAccountCoinAmount({
accountAddress: "0x1", // replace with a real account address
coinType: "0x1::aptos_coin::AptosCoin" // specify the coin type
});
console.log(`Account coin amount: ${accountCoinAmount}`);
}
runExample().catch(console.error); +- args: {
get
- get
Account Coins Count(args): Promise<number> Retrieves the current count of an account's coins aggregated across all types.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for the account coins count query.
+account
Address: AccountAddressInput The account address we want to get the total count for.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<number>
The current count of the aggregated coins for the specified account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Getting the account coins count for a specific account
const accountCoinsCount = await aptos.getAccountCoinsCount({ accountAddress: "0x1" }); // replace with a real account address
console.log("Account Coins Count:", accountCoinsCount);
}
runExample().catch(console.error); +- args: {
get
- get
Account Coins Data(args): Promise<{
amount?: any;
asset_type?: null | string;
is_frozen: boolean;
is_primary?: null | boolean;
last_transaction_timestamp?: any;
last_transaction_version?: any;
metadata?: null | {
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
symbol: string;
token_standard: string;
};
owner_address: string;
storage_id: string;
token_standard?: null | string;
}[]> Retrieves the coins data for a specified account.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
amount?: any;
asset_type?: null | string;
is_frozen: boolean;
is_primary?: null | boolean;
last_transaction_timestamp?: any;
last_transaction_version?: any;
metadata?: null | {
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
symbol: string;
token_standard: string;
};
owner_address: string;
storage_id: string;
token_standard?: null | string;
}> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
}account
Address: AccountAddressInput The account address for which to retrieve the coin's data.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
amount?: any;
asset_type?: null | string;
is_frozen: boolean;
is_primary?: null | boolean;
last_transaction_timestamp?: any;
last_transaction_version?: any;
metadata?: null | {
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
symbol: string;
token_standard: string;
};
owner_address: string;
storage_id: string;
token_standard?: null | string;
}> & WhereArg<CurrentFungibleAssetBalancesBoolExp>
Returns Promise<{
amount?: any;
asset_type?: null | string;
is_frozen: boolean;
is_primary?: null | boolean;
last_transaction_timestamp?: any;
last_transaction_version?: any;
metadata?: null | {
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
symbol: string;
token_standard: string;
};
owner_address: string;
storage_id: string;
token_standard?: null | string;
}[]>An array containing the coins data for the specified account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching coins data for a specific account
const accountCoinsData = await aptos.getAccountCoinsData({
accountAddress: "0x1", // replace with a real account address
options: {
limit: 10, // specify the number of results to return
orderBy: { asset_type: "asc" }, // specify the order of results
},
});
console.log(accountCoinsData);
}
runExample().catch(console.error); +- args: {
get
- get
Account Collections With Owned Tokens(args): Promise<{
collection_id?: null | string;
collection_name?: null | string;
collection_uri?: null | string;
creator_address?: null | string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
distinct_tokens?: any;
last_transaction_version?: any;
owner_address?: null | string;
single_token_uri?: null | string;
}[]> Queries for all collections that an account currently has tokens for, including NFTs, fungible tokens, and soulbound tokens. +If you want to filter by a specific token standard, you can pass an optional tokenStandard parameter.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg & PaginationArgs & OrderByArg<{
collection_id?: null | string;
collection_name?: null | string;
collection_uri?: null | string;
creator_address?: null | string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
distinct_tokens?: any;
last_transaction_version?: any;
owner_address?: null | string;
single_token_uri?: null | string;
}>;
}account
Address: AccountAddressInput The account address we want to get the collections for.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArg & PaginationArgs & OrderByArg<{
collection_id?: null | string;
collection_name?: null | string;
collection_uri?: null | string;
creator_address?: null | string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
distinct_tokens?: any;
last_transaction_version?: any;
owner_address?: null | string;
single_token_uri?: null | string;
}>
Returns Promise<{
collection_id?: null | string;
collection_name?: null | string;
collection_uri?: null | string;
creator_address?: null | string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
distinct_tokens?: any;
last_transaction_version?: any;
owner_address?: null | string;
single_token_uri?: null | string;
}[]>Collections array with the collections data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get account collections with owned tokens for a specific account
const accountCollectionsWithOwnedTokens = await aptos.getAccountCollectionsWithOwnedTokens({
accountAddress: "0x1", // replace with a real account address
options: {
tokenStandard: "NFT", // specify the token standard if needed
limit: 10, // specify the number of results to return
},
});
console.log(accountCollectionsWithOwnedTokens);
}
runExample().catch(console.error); +- args: {
get
- get
Account Info(args): Promise<AccountData> Queries the current state for an Aptos account given its account address.
+Parameters
- args: {
accountAddress: AccountAddressInput;
}The arguments for retrieving account information.
+account
Address: AccountAddressInput The Aptos account address to query.
+
Returns Promise<AccountData>
The account data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve account information for a specific address
const accountInfo = await aptos.getAccountInfo({ accountAddress: "0x1" }); // replace with a real account address
console.log(accountInfo);
}
runExample().catch(console.error); +- args: {
get
- get
Account Module(args): Promise<MoveModuleBytecode> Queries for a specific account module given an account address and module name.
+Parameters
- args: {
accountAddress: AccountAddressInput;
moduleName: string;
options?: LedgerVersionArg;
}account
Address: AccountAddressInput The Aptos account address.
+module
Name: string The name of the module.
+Optionaloptions?: LedgerVersionArg
Returns Promise<MoveModuleBytecode>
The account module associated with the specified account address and module name.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the account module for a specific account address and module name
const module = await aptos.getAccountModule({
accountAddress: "0x1", // replace with a real account address
moduleName: "MyModule" // specify the module name
});
console.log(module);
}
runExample().catch(console.error); +- args: {
get
- get
Account Modules(args): Promise<MoveModuleBytecode[]> Queries for all modules in an account given an account address. +This function may call the API multiple times to auto paginate through results.
+Parameters
- args: {
accountAddress: AccountAddressInput;
options?: PaginationArgs & LedgerVersionArg;
}account
Address: AccountAddressInput The Aptos account address to query modules for.
+Optionaloptions?: PaginationArgs & LedgerVersionArg
Returns Promise<MoveModuleBytecode[]>
-
+
- The account modules associated with the specified address. +
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching account modules for a specific account
const accountModules = await aptos.getAccountModules({
accountAddress: "0x1", // replace with a real account address
options: {
offset: 0, // starting from the first module
limit: 10, // limiting to 10 modules
},
});
console.log(accountModules);
}
runExample().catch(console.error); +- args: {
get
- get
Account Owned Objects(args): Promise<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}[]> Queries an account's owned objects.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}>;
}account
Address: AccountAddressInput The account address we want to get the objects for.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}>
Returns Promise<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}[]>Objects array with the object data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the objects owned by the specified account
const accountOwnedObjects = await aptos.getAccountOwnedObjects({
accountAddress: "0x1", // replace with a real account address
minimumLedgerVersion: 1, // optional, specify if needed
options: {
offset: 0, // optional, specify if needed
limit: 10, // optional, specify if needed
orderBy: "created_at", // optional, specify if needed
},
});
console.log(accountOwnedObjects);
}
runExample().catch(console.error); +- args: {
get
- get
Account Owned Tokens(args): Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}[]> Queries the tokens currently owned by a specified account, including NFTs and fungible tokens. +If desired, you can filter the results by a specific token standard.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg & PaginationArgs & OrderByArg<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>;
}account
Address: AccountAddressInput The account address for which to retrieve owned tokens.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArg & PaginationArgs & OrderByArg<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>
Returns Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}[]>An array of tokens with their respective data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the tokens owned by a specific account
const accountOwnedTokens = await aptos.getAccountOwnedTokens({
accountAddress: "0x1", // replace with a real account address
options: {
limit: 10, // specify how many tokens to return
orderBy: "created_at", // specify the order of the results
},
});
console.log(accountOwnedTokens);
}
runExample().catch(console.error); +- args: {
get
- get
Account Owned Tokens From Collection Address(args): Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}[]> Queries all current tokens of a specific collection that an account owns by the collection address. +This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc. +If you want to get only the token from a specific standard, you can pass an optional tokenStandard parameter.
+Parameters
- args: {
accountAddress: AccountAddressInput;
collectionAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg & PaginationArgs & OrderByArg<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>;
}account
Address: AccountAddressInput The account address we want to get the tokens for.
+collection
Address: AccountAddressInput The address of the collection being queried.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to, before querying.
+Optionaloptions?: TokenStandardArg & PaginationArgs & OrderByArg<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>
Returns Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}[]>Tokens array with the token data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get tokens owned by a specific account in a specific collection
const accountOwnedTokens = await aptos.getAccountOwnedTokensFromCollectionAddress({
accountAddress: "0x1", // replace with a real account address
collectionAddress: "0x2", // replace with a real collection address
});
console.log(accountOwnedTokens);
}
runExample().catch(console.error); +- args: {
get
- get
Account Resource<T>(args): Promise<T> Queries a specific account resource given an account address and resource type.
+Type Parameters
Parameters
- args: {
accountAddress: AccountAddressInput;
options?: LedgerVersionArg;
resourceType: `${string}::${string}::${string}`;
}account
Address: AccountAddressInput The Aptos account address to query.
+Optionaloptions?: LedgerVersionArgresource
Type: `${string}::${string}::${string}` The string representation of an on-chain Move struct type, e.g., "0x1::aptos_coin::AptosCoin".
+
Returns Promise<T>
The account resource of the specified type.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the account resource for a specific account address and resource type
const resource = await aptos.getAccountResource({
accountAddress: "0x1", // replace with a real account address
resourceType: "0x1::aptos_coin::AptosCoin"
});
console.log(resource);
}
runExample().catch(console.error); +- args: {
get
- get
Account Resources(args): Promise<MoveResource[]> Queries all account resources given an account address. +This function may call the API multiple times to auto paginate through results.
+Parameters
- args: {
accountAddress: AccountAddressInput;
options?: PaginationArgs & LedgerVersionArg;
}account
Address: AccountAddressInput The Aptos account address to query resources for.
+Optionaloptions?: PaginationArgs & LedgerVersionArg
Returns Promise<MoveResource[]>
Account resources.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching account resources for a specific account address
const resources = await aptos.getAccountResources({ accountAddress: "0x1" }); // replace with a real account address
console.log(resources);
}
runExample().catch(console.error); +- args: {
get
- get
Account Tokens Count(args): Promise<number> Queries the current count of tokens owned by a specified account.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for the query.
+account
Address: AccountAddressInput The account address to query the token count for.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<number>
The current count of tokens owned by the account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the count of tokens owned by the account
const tokensCount = await aptos.getAccountTokensCount({ accountAddress: "0x1" }); // replace with a real account address
console.log(`Tokens Count: ${tokensCount}`);
}
runExample().catch(console.error); +- args: {
get
- get
Account Transactions(args): Promise<TransactionResponse[]> Queries account transactions given an account address. +This function may call the API multiple times to auto paginate and retrieve all account transactions.
+Parameters
- args: {
accountAddress: AccountAddressInput;
options?: PaginationArgs;
}account
Address: AccountAddressInput The Aptos account address to query transactions for.
+Optionaloptions?: PaginationArgsOptional pagination arguments.
+
Returns Promise<TransactionResponse[]>
The account transactions.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetch transactions for a specific account
const transactions = await aptos.getAccountTransactions({
accountAddress: "0x1", // replace with a real account address
options: {
offset: 0, // starting from the first transaction
limit: 10, // limiting to 10 transactions
},
});
console.log(transactions);
}
runExample().catch(console.error); +- args: {
get
- get
Account Transactions Count(args): Promise<number> Queries the current count of transactions submitted by an account.
+Parameters
- args: {
accountAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for the query.
+account
Address: AccountAddressInput The account address we want to get the total count for.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<number>
Current count of transactions made by an account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the count of transactions for a specific account
const accountTransactionsCount = await aptos.getAccountTransactionsCount({
accountAddress: "0x1", // replace with a real account address
minimumLedgerVersion: 1, // specify your own minimum ledger version if needed
});
console.log(accountTransactionsCount);
}
runExample().catch(console.error); +- args: {
lookup
- lookup
Original Account Address(args): Promise<AccountAddress> Looks up the account address for a given authentication key, handling both rotated and non-rotated keys.
+Parameters
- args: {
authenticationKey: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: LedgerVersionArg;
}authentication
Key: AccountAddressInput The authentication key for which to look up the account address.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: LedgerVersionArg
Returns Promise<AccountAddress>
Promise
+- The account address associated with the authentication key. Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Look up the original account address for a given authentication key
const accountAddress = await aptos.lookupOriginalAccountAddress({
authenticationKey: "0x1", // replace with a real authentication key
});
console.log("Original Account Address:", accountAddress);
}
runExample().catch(console.error); +- args: {
Class AptosObject
A class to query all Object related queries on Aptos.
Hierarchy (view full)
- AptosObject
Index
Constructors
constructor
- new
Aptos Object(config): AptosObject Creates an instance of the Aptos client with the provided configuration. +This allows interaction with the Aptos blockchain using the specified settings.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns AptosObject
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for the Aptos client
const config = new AptosConfig({
network: Network.TESTNET, // Specify the desired network
nodeUrl: "https://testnet.aptos.dev", // Replace with your node URL
});
// Create an instance of the Aptos client
const aptos = new Aptos(config);
console.log("Aptos client created successfully", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
get
- get
Object Data By Object Address(args): Promise<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}> Fetches the object data based on the specified object address.
+Parameters
- args: {
minimumLedgerVersion?: AnyNumber;
objectAddress: AccountAddressInput;
options?: PaginationArgs & OrderByArg<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}>;
}OptionalminimumLedger Version?: AnyNumber Optional minimum ledger version to wait for.
+object
Address: AccountAddressInput The object address to retrieve data for.
+Optionaloptions?: PaginationArgs & OrderByArg<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}>Optional configuration options for pagination and ordering.
+
Returns Promise<{
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}>The object data corresponding to the provided address.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching object data by object address
const objectData = await aptos.getObjectDataByObjectAddress({
objectAddress: "0x1", // replace with a real object address
});
console.log(objectData);
}
runExample().catch(console.error); +- args: {
Class AsyncQueue<T>
Type Parameters
Index
Constructors
constructor
- new
Async Queue<T>(): AsyncQueue<T> Type Parameters
Returns AsyncQueue<T>
Methods
cancel
dequeue
enqueue
- enqueue(item): void
Adds an item to the queue. If there are pending dequeued promises, it resolves the oldest promise with the enqueued item +immediately; otherwise, it adds the item to the queue.
+Parameters
- item: T
The item to be added to the queue.
+
Returns void
- item: T
is
is
pending
Class AsyncQueueCancelledError
Represents an error that occurs when an asynchronous queue operation is cancelled. +This error extends the built-in Error class to provide additional context for cancellation events.
+Hierarchy (view full)
- Error
- AsyncQueueCancelledError
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Async Queue Cancelled Error(message?): AsyncQueueCancelledError Parameters
Optionalmessage: string
Returns AsyncQueueCancelledError
Class Build
A class to handle all Build transaction operations.
Index
Constructors
constructor
- new
Build(config): Build Initializes a new instance of the Aptos client with the specified configuration. +This allows you to interact with the Aptos blockchain using the provided settings.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns Build
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for the Aptos client
const config = new AptosConfig({
network: Network.TESTNET, // specify the network
nodeUrl: "https://testnet.aptos.dev", // specify the node URL
});
// Initialize the Aptos client
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
multi
- multi
Agent(args): Promise<MultiAgentTransaction> Build a multi-agent transaction that allows multiple signers to authorize a transaction.
+Parameters
- args: {
data: InputGenerateTransactionPayloadData;
options?: InputGenerateTransactionOptions;
secondarySignerAddresses: AccountAddressInput[];
sender: AccountAddressInput;
withFeePayer?: boolean;
}The parameters for creating the multi-agent transaction.
+data: InputGenerateTransactionPayloadData
The transaction data.
+Optionaloptions?: InputGenerateTransactionOptionsOptional transaction configurations.
+secondary
Signer Addresses: AccountAddressInput[] An array of the secondary signers' account addresses.
+sender: AccountAddressInput
The sender account address.
+OptionalwithFee Payer?: boolean Whether there is a fee payer for the transaction.
+
Returns Promise<MultiAgentTransaction>
MultiAgentTransaction
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Build a multi-agent transaction
const transaction = await aptos.multiAgent({
sender: "0x1", // replace with a real sender account address
data: {
// Transaction data structure
function: "0x1::aptos_account::transfer",
functionArguments: ["0x2", 100], // replace with a real destination account address and amount
},
secondarySignerAddresses: ["0x3", "0x4"], // replace with real secondary signer addresses
options: {
// Optional transaction configurations
maxGasAmount: "1000",
gasUnitPrice: "1",
},
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
simple
- simple(args): Promise<SimpleTransaction>
Build a simple transaction.
+This function allows you to create a transaction with specified sender and data.
+Parameters
- args: {
data: InputGenerateTransactionPayloadData;
options?: InputGenerateTransactionOptions;
sender: AccountAddressInput;
withFeePayer?: boolean;
}data: InputGenerateTransactionPayloadData
The transaction data.
+Optionaloptions?: InputGenerateTransactionOptionsOptional transaction configurations.
+sender: AccountAddressInput
The sender account address.
+OptionalwithFee Payer?: boolean Whether there is a fee payer for the transaction.
+
Returns Promise<SimpleTransaction>
SimpleTransaction
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Build a simple transaction
const transaction = await aptos.transaction.simple({
sender: "0x1", // replace with a real sender account address
data: {
function: "0x1::aptos_account::transfer",
functionArguments: ["0x2", 100], // replace with a real destination account address
},
options: {
gasUnitPrice: 100, // specify your own gas unit price if needed
maxGasAmount: 1000, // specify your own max gas amount if needed
},
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
Class Coin
A class to handle all Coin operations.
Hierarchy (view full)
- Coin
Index
Constructors
constructor
- new
Coin(config): Coin Initializes a new instance of the Aptos client with the specified configuration. +This allows you to interact with the Aptos blockchain using the provided settings.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns Coin
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a new Aptos client with testnet configuration
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
transfer
- transfer
Coin Transaction(args): Promise<SimpleTransaction> Generate a transfer coin transaction that can be simulated, signed, and submitted. +This function helps you create a transaction to transfer a specified amount of coins +from one account to another within the Aptos network.
+Parameters
- args: {
amount: AnyNumber;
coinType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
recipient: AccountAddressInput;
sender: AccountAddressInput;
}The arguments for the transfer transaction.
+amount: AnyNumber
The amount of coins to transfer.
+OptionalcoinType?: `${string}::${string}::${string}` Optional. The coin struct type to transfer. Defaults to 0x1::aptos_coin::AptosCoin.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+recipient: AccountAddressInput
The recipient account address.
+sender: AccountAddressInput
The sender account address.
+
Returns Promise<SimpleTransaction>
SimpleTransaction
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Generate a transfer coin transaction
const transaction = await aptos.transferCoinTransaction({
sender: "0x1", // replace with a real sender account address
recipient: "0x2", // replace with a real recipient account address
amount: 10,
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
Class DigitalAsset
A class to query all DigitalAsset related queries on Aptos.
Hierarchy (view full)
- DigitalAsset
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Digital Asset(config): DigitalAsset Initializes a new instance of the Aptos client with the specified configuration. +This allows you to interact with the Aptos blockchain using the provided settings.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns DigitalAsset
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for the Aptos client
const config = new AptosConfig({ network: Network.TESTNET }); // Specify your desired network
// Initialize the Aptos client with the configuration
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
add
- add
Digital Asset Property Transaction(args): Promise<SimpleTransaction> Add a digital asset property to the blockchain. +This function allows you to specify a new property for a digital asset, including its key, type, and value.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
propertyKey: string;
propertyType:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY";
propertyValue: PropertyValue;
}The arguments for adding a digital asset property.
+creator: Account
The account that mints the digital asset.
+digital
Asset Address: AccountAddressInput The digital asset address.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` (Optional) The type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptions(Optional) Options for generating the transaction.
+property
Key: string The property key for storing on-chain properties.
+property
Type:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY"The type of property value.
+property
Value: PropertyValue The property value to be stored on-chain.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Add a digital asset property
const transaction = await aptos.addDigitalAssetPropertyTransaction({
creator: Account.generate(), // Replace with a real account
propertyKey: "newKey",
propertyType: "BOOLEAN",
propertyValue: true,
digitalAssetAddress: "0x123", // Replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
add
- add
Digital Asset Typed Property Transaction(args): Promise<SimpleTransaction> Add a typed digital asset property to the blockchain. +This function allows you to define and store a specific property for a digital asset, enabling better categorization and +management of digital assets.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
propertyKey: string;
propertyType:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY";
propertyValue: PropertyValue;
}The parameters for adding the typed property.
+creator: Account
The account that mints the digital asset.
+digital
Asset Address: AccountAddressInput The digital asset address.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` The optional type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional transaction generation options.
+property
Key: string The property key for storing on-chain properties.
+property
Type:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY"The type of property value.
+property
Value: PropertyValue The property value to be stored on-chain.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Adding a typed digital asset property
const transaction = await aptos.addDigitalAssetTypedPropertyTransaction({
creator: Account.generate(), // replace with a real account
propertyKey: "typedKey",
propertyType: "STRING",
propertyValue: "hello",
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
burn
- burn
Digital Asset Transaction(args): Promise<SimpleTransaction> Burn a digital asset by its creator, allowing for the removal of a specified digital asset from the blockchain.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
}The arguments for burning the digital asset.
+creator: Account
The creator account that is burning the digital asset.
+digital
Asset Address: AccountAddressInput The address of the digital asset to be burned.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset being burned.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const creator = Account.generate(); // Replace with a real creator account
const transaction = await aptos.burnDigitalAssetTransaction({
creator: creator,
digitalAssetAddress: "0x123", // Replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
create
- create
Collection Transaction(args): Promise<SimpleTransaction> Creates a new collection within the specified account.
+Parameters
- args: {
creator: Account;
description: string;
name: string;
options?: InputGenerateTransactionOptions;
uri: string;
} & CreateCollectionOptions
Returns Promise<SimpleTransaction>
A SimpleTransaction that when submitted will create the collection.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Creating a new collection transaction
const transaction = await aptos.createCollectionTransaction({
creator: Account.generate(), // Replace with a real account
description: "A unique collection of digital assets.",
name: "My Digital Collection",
uri: "https://mycollection.com",
});
console.log("Transaction created:", transaction);
}
runExample().catch(console.error); +- args: {
freeze
- freeze
Digital Asset Transafer Transaction(args): Promise<SimpleTransaction> Freeze the ability to transfer a specified digital asset. +This function allows the creator to restrict the transfer capability of a digital asset.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
}The arguments for freezing the digital asset transfer.
+creator: Account
The creator account initiating the freeze.
+digital
Asset Address: AccountAddressInput The address of the digital asset to be frozen.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset being frozen.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Freeze the digital asset transfer
const transaction = await aptos.freezeDigitalAssetTransaferTransaction({
creator: Account.generate(), // Replace with a real account if needed
digitalAssetAddress: "0x123", // Replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
get
- get
Collection Data(args): Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}> Queries data of a specific collection by the collection creator address and the collection name. +This function is deprecated; use
+getCollectionDataByCreatorAddressAndCollectionNameinstead.If a creator account has two collections with the same name in v1 and v2, you can pass an optional
+tokenStandardparameter +to query a specific standard.Parameters
- args: {
collectionName: string;
creatorAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg;
}The arguments for querying the collection data.
+collection
Name: string The name of the collection.
+creator
Address: AccountAddressInput The address of the collection's creator.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArgOptional parameters for the query.
+
Returns Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}>GetCollectionDataResponse - The response type containing the collection data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Querying collection data by creator address and collection name
const collection = await aptos.getCollectionData({
creatorAddress: "0x1", // replace with a real creator address
collectionName: "myCollection", // specify your collection name
});
console.log(collection);
}
runExample().catch(console.error); +- args: {
get
- get
Collection Data By Collection Id(args): Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}> Queries data of a specific collection by the collection ID.
+Parameters
- args: {
collectionId: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg & PaginationArgs;
}collection
Id: AccountAddressInput The ID of the collection, which is the same as the address of the collection object.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArg & PaginationArgsOptional parameters for token standard and pagination.
+
Returns Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}>GetCollectionDataResponse - The response type containing the collection data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching collection data by collection ID
const collection = await aptos.getCollectionDataByCollectionId({
collectionId: "0x123", // replace with a real collection ID
});
console.log(collection);
}
runExample().catch(console.error); +- args: {
get
- get
Collection Data By Creator Address(args): Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}> Retrieves data for a specific collection created by a given creator address. +This function allows you to query collection data while optionally specifying a minimum ledger version and pagination options.
+Parameters
- args: {
creatorAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg & PaginationArgs;
}creator
Address: AccountAddressInput The address of the collection's creator.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArg & PaginationArgs
Returns Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}>GetCollectionDataResponse - The response type containing collection data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve collection data by creator address
const collectionData = await aptos.getCollectionDataByCreatorAddress({
creatorAddress: "0x1", // replace with a real creator address
minimumLedgerVersion: 1, // specify the minimum ledger version if needed
options: {
tokenStandard: "v2", // specify the token standard if needed
pagination: { limit: 10, offset: 0 } // specify pagination options if needed
}
});
console.log(collectionData);
}
runExample().catch(console.error); +- args: {
get
- get
Collection Data By Creator Address And Collection Name(args): Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}> Queries data of a specific collection by the collection creator address and the collection name. +If a creator account has multiple collections with the same name across different versions, +specify the
+tokenStandardparameter to query a specific standard.Parameters
- args: {
collectionName: string;
creatorAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg & PaginationArgs;
}collection
Name: string The name of the collection.
+creator
Address: AccountAddressInput The address of the collection's creator.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArg & PaginationArgs
Returns Promise<{
cdn_asset_uris?: null | {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: null | string;
cdn_image_uri?: null | string;
cdn_json_uri?: null | string;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: null | string;
raw_image_uri?: null | string;
};
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
}>GetCollectionDataResponse - The response type containing collection data.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching collection data by creator address and collection name
const collection = await aptos.getCollectionDataByCreatorAddressAndCollectionName({
creatorAddress: "0x1", // replace with a real creator address
collectionName: "myCollection",
minimumLedgerVersion: 1, // optional, specify if needed
options: { tokenStandard: "v2" } // optional, specify if needed
});
console.log(collection);
}
runExample().catch(console.error); +- args: {
get
- get
Collection Id(args): Promise<string> Queries the ID of a specified collection. +This ID corresponds to the collection's object address in V2, while V1 does not utilize objects and lacks an address.
+Parameters
- args: {
collectionName: string;
creatorAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: TokenStandardArg;
}collection
Name: string The name of the collection.
+creator
Address: AccountAddressInput The address of the collection's creator.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: TokenStandardArg
Returns Promise<string>
The collection ID.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching the collection ID for a specific creator and collection name
const collectionId = await aptos.getCollectionId({
creatorAddress: "0x1", // replace with a real creator address
collectionName: "myCollection"
});
console.log("Collection ID:", collectionId);
}
runExample().catch(console.error); +- args: {
get
- get
Current Digital Asset Ownership(args): Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}> Retrieves the current ownership data of a specified digital asset using its address.
+Parameters
- args: {
digitalAssetAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for the request.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>GetCurrentTokenOwnershipResponse containing relevant ownership data of the digital asset.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Getting the current ownership of a digital asset
const digitalAssetOwner = await aptos.getCurrentDigitalAssetOwnership({
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(digitalAssetOwner);
}
runExample().catch(console.error); +- args: {
get
- get
Digital Asset Activity(args): Promise<{
after_value?: null | string;
before_value?: null | string;
entry_function_id_str?: null | string;
event_account_address: string;
event_index: any;
from_address?: null | string;
is_fungible_v2?: null | boolean;
property_version_v1: any;
to_address?: null | string;
token_amount: any;
token_data_id: string;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}[]> Retrieves the activity data for a specified digital asset using its address.
+Parameters
- args: {
digitalAssetAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
after_value?: null | string;
before_value?: null | string;
entry_function_id_str?: null | string;
event_account_address: string;
event_index: any;
from_address?: null | string;
is_fungible_v2?: null | boolean;
property_version_v1: any;
to_address?: null | string;
token_amount: any;
token_data_id: string;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}>;
}The parameters for the request.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionalminimumLedger Version?: AnyNumber Optional minimum ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
after_value?: null | string;
before_value?: null | string;
entry_function_id_str?: null | string;
event_account_address: string;
event_index: any;
from_address?: null | string;
is_fungible_v2?: null | boolean;
property_version_v1: any;
to_address?: null | string;
token_amount: any;
token_data_id: string;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}>Optional pagination and ordering parameters.
+
Returns Promise<{
after_value?: null | string;
before_value?: null | string;
entry_function_id_str?: null | string;
event_account_address: string;
event_index: any;
from_address?: null | string;
is_fungible_v2?: null | boolean;
property_version_v1: any;
to_address?: null | string;
token_amount: any;
token_data_id: string;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}[]>A promise that resolves to the activity data related to the digital asset.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the activity data for a digital asset
const digitalAssetActivity = await aptos.getDigitalAssetActivity({
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(digitalAssetActivity);
}
runExample().catch(console.error); +- args: {
get
- get
Digital Asset Data(args): Promise<{
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
}> Retrieves digital asset data using the address of a digital asset.
+Parameters
- args: {
digitalAssetAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for the request.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<{
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
}>GetTokenDataResponse containing relevant data for the digital asset.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching digital asset data for a specific address
const digitalAsset = await aptos.getDigitalAssetData({
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(digitalAsset);
}
runExample().catch(console.error); +- args: {
get
- get
Owned Digital Assets(args): Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}[]> Retrieves the digital assets owned by a specified address.
+Parameters
- args: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>;
ownerAddress: AccountAddressInput;
}OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}>Optional pagination and ordering parameters for the response.
+owner
Address: AccountAddressInput The address of the owner.
+
Returns Promise<{
amount: any;
current_token_data?: null | {
collection_id: string;
current_collection?: null | {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any;
mutable_description?: null | boolean;
mutable_uri?: null | boolean;
table_handle_v1?: null | string;
token_standard: string;
total_minted_v2?: any;
uri: string;
};
decimals?: any;
description: string;
is_fungible_v2?: null | boolean;
largest_property_version_v1?: any;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any;
supply?: any;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
};
is_fungible_v2?: null | boolean;
is_soulbound_v2?: null | boolean;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: null | string;
token_data_id: string;
token_properties_mutated_v1?: any;
token_standard: string;
}[]>GetOwnedTokensResponse containing ownership data of the digital assets belonging to the ownerAddress.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching the digital assets owned by the specified address
const digitalAssets = await aptos.getOwnedDigitalAssets({
ownerAddress: "0x1", // replace with a real account address
});
console.log(digitalAssets);
}
runExample().catch(console.error); +- args: {
mint
- mint
Digital Asset Transaction(args): Promise<SimpleTransaction> Create a transaction to mint a digital asset into the creator's account within an existing collection. +This function helps you generate a transaction that can be simulated or submitted to the blockchain for minting a digital asset.
+Parameters
- args: {
collection: string;
creator: Account;
description: string;
name: string;
options?: InputGenerateTransactionOptions;
propertyKeys?: string[];
propertyTypes?: (
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY")[];
propertyValues?: PropertyValue[];
uri: string;
}collection: string
The name of the collection the digital asset belongs to.
+creator: Account
The creator of the collection.
+description: string
The description of the digital asset.
+name: string
The name of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional transaction generation options.
+OptionalpropertyKeys?: string[] Optional array of property keys for the digital asset.
+OptionalpropertyTypes?: (
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY")[]Optional array of property types for the digital asset.
+OptionalpropertyValues?: PropertyValue[] Optional array of property values for the digital asset.
+uri: string
The URI to additional info about the digital asset.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Creating a transaction to mint a digital asset
const transaction = await aptos.mintDigitalAssetTransaction({
creator: Account.generate(), // replace with a real account
collection: "MyCollection",
description: "This is a digital asset.",
name: "MyDigitalAsset",
uri: "https://example.com/my-digital-asset",
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
mint
- mint
Soul Bound Transaction(args): Promise<SimpleTransaction> Mint a soul bound digital asset into a recipient's account. +This function allows you to create a unique digital asset that is bound to a specific account.
+Parameters
- args: {
account: Account;
collection: string;
description: string;
name: string;
options?: InputGenerateTransactionOptions;
propertyKeys?: string[];
propertyTypes?: (
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY")[];
propertyValues?: PropertyValue[];
recipient: AccountAddressInput;
uri: string;
}The arguments for minting the soul bound transaction.
+account: Account
The account that mints the digital asset.
+collection: string
The collection name that the digital asset belongs to.
+description: string
The digital asset description.
+name: string
The digital asset name.
+Optionaloptions?: InputGenerateTransactionOptionsAdditional options for generating the transaction.
+OptionalpropertyKeys?: string[] The property keys for storing on-chain properties.
+OptionalpropertyTypes?: (
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY")[]The type of property values.
+OptionalpropertyValues?: PropertyValue[] The property values to be stored on-chain.
+recipient: AccountAddressInput
The account address where the digital asset will be created.
+uri: string
The digital asset URL.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Mint a soul bound digital asset
const transaction = await aptos.mintSoulBoundTransaction({
account: Account.generate(), // Replace with a real account
collection: "collectionName",
description: "collectionDescription",
name: "digitalAssetName",
uri: "digital-asset-uri.com",
recipient: "0x123" // Replace with a real recipient account address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
remove
- remove
Digital Asset Property Transaction(args): Promise<SimpleTransaction> Remove a digital asset property from the blockchain. +This function allows you to delete an existing property associated with a digital asset.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
propertyKey: string;
propertyType:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY";
propertyValue: PropertyValue;
}The parameters required to remove the digital asset property.
+creator: Account
The account that mints the digital asset.
+digital
Asset Address: AccountAddressInput The digital asset address.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+property
Key: string The property key for storing on-chain properties.
+property
Type:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY"The type of property value.
+property
Value: PropertyValue The property value to be stored on-chain.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Remove a digital asset property
const transaction = await aptos.removeDigitalAssetPropertyTransaction({
creator: Account.generate(), // replace with a real account
propertyKey: "newKey",
propertyType: "BOOLEAN",
propertyValue: true,
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
set
- set
Digital Asset Description Transaction(args): Promise<SimpleTransaction> Set the digital asset description to provide additional context or information about the asset.
+Parameters
- args: {
creator: Account;
description: string;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
}The parameters for setting the digital asset description.
+creator: Account
The creator account responsible for the digital asset.
+description: string
The digital asset description to be set.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Set the digital asset description
const transaction = await aptos.setDigitalAssetDescriptionTransaction({
creator: Account.generate(), // replace with a real account
description: "This is a digital asset description.",
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
set
- set
Digital Asset Name Transaction(args): Promise<SimpleTransaction> Set the digital asset name, allowing you to define a name for a specific digital asset on the blockchain.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
name: string;
options?: InputGenerateTransactionOptions;
}The parameters for setting the digital asset name.
+creator: Account
The creator account responsible for the transaction.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset, represented as a Move struct ID.
+name: string
The desired name for the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the blockchain.
+Example
+ +import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const creator = Account.generate(); // Generate a new account for the creator
const digitalAssetAddress = "0x123"; // replace with a real digital asset address
// Set the digital asset name
const transaction = await aptos.setDigitalAssetNameTransaction({
creator: creator,
name: "digitalAssetName",
digitalAssetAddress: digitalAssetAddress,
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
set
- set
Digital AssetURITransaction(args): Promise<SimpleTransaction> Set the URI for a digital asset, allowing you to associate a unique identifier with the asset.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
uri: string;
}The parameters for the transaction.
+creator: Account
The creator account initiating the transaction.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+uri: string
The digital asset URI to be set.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Set the URI for a digital asset
const transaction = await aptos.setDigitalAssetURITransaction({
creator: Account.generate(), // Replace with a real creator account
uri: "digital-asset-uri.com",
digitalAssetAddress: "0x123", // Replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
transfer
- transfer
Digital Asset Transaction(args): Promise<SimpleTransaction> Transfer ownership of a non-fungible digital asset. +This function allows you to transfer a digital asset only if it is not frozen, meaning the ownership transfer is not disabled.
+Parameters
- args: {
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
recipient: AccountAddress;
sender: Account;
}The arguments for transferring the digital asset.
+digital
Asset Address: AccountAddressInput The address of the digital asset being transferred.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset, defaults to "0x4::token::Token".
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+recipient: AccountAddress
The account address of the recipient.
+sender: Account
The sender account of the current digital asset owner.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Transfer a digital asset
const transaction = await aptos.transferDigitalAssetTransaction({
sender: Account.generate(), // replace with a real sender account
digitalAssetAddress: "0x123", // replace with a real digital asset address
recipient: "0x456", // replace with a real recipient account address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
unfreeze
- unfreeze
Digital Asset Transafer Transaction(args): Promise<SimpleTransaction> Unfreeze the ability to transfer a digital asset. +This function allows the specified creator account to unfreeze the transfer of a digital asset identified by its address.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
}The parameters for unfreezing the digital asset transfer.
+creator: Account
The creator account that is unfreezing the digital asset transfer.
+digital
Asset Address: AccountAddressInput The address of the digital asset to unfreeze.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset being unfrozen.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Unfreeze the ability to transfer a digital asset
const transaction = await aptos.unfreezeDigitalAssetTransaferTransaction({
creator: Account.generate(), // replace with a real creator account
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
update
- update
Digital Asset Property Transaction(args): Promise<SimpleTransaction> Update a digital asset property on-chain.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
propertyKey: string;
propertyType:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY";
propertyValue: PropertyValue;
}The parameters for updating the digital asset property.
+creator: Account
The account that mints the digital asset.
+digital
Asset Address: AccountAddressInput The address of the digital asset.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` Optional. The type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptionsOptional. Additional options for generating the transaction.
+property
Key: string The property key for storing on-chain properties.
+property
Type:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY"The type of property value.
+property
Value: PropertyValue The property value to be stored on-chain.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Update a digital asset property
const transaction = await aptos.updateDigitalAssetPropertyTransaction({
creator: Account.generate(), // replace with a real account
propertyKey: "newKey",
propertyType: "BOOLEAN",
propertyValue: false,
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
update
- update
Digital Asset Typed Property Transaction(args): Promise<SimpleTransaction> Update a typed digital asset property on-chain. +This function allows you to modify the properties of a digital asset, enabling dynamic updates to its attributes.
+Parameters
- args: {
creator: Account;
digitalAssetAddress: AccountAddressInput;
digitalAssetType?: `${string}::${string}::${string}`;
options?: InputGenerateTransactionOptions;
propertyKey: string;
propertyType:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY";
propertyValue: PropertyValue;
}The arguments for updating the digital asset property.
+creator: Account
The account that mints the digital asset.
+digital
Asset Address: AccountAddressInput The digital asset address.
+OptionaldigitalAsset Type?: `${string}::${string}::${string}` (Optional) The type of the digital asset.
+Optionaloptions?: InputGenerateTransactionOptions(Optional) Additional options for generating the transaction.
+property
Key: string The property key for storing on-chain properties.
+property
Type:
| "BOOLEAN"
| "U8"
| "U16"
| "U32"
| "U64"
| "U128"
| "U256"
| "ADDRESS"
| "STRING"
| "ARRAY"The type of property value.
+property
Value: PropertyValue The property value to be stored on-chain.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Update a typed digital asset property
const transaction = await aptos.updateDigitalAssetTypedPropertyTransaction({
creator: Account.generate(), // replace with a real account
propertyKey: "typedKey",
propertyType: "U8",
propertyValue: 2,
digitalAssetAddress: "0x123", // replace with a real digital asset address
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
Class Event
A class to query all Event Aptos related queries.
Hierarchy (view full)
- Event
Index
Constructors
constructor
- new
Event(config): Event Initializes a new instance of the Aptos client with the provided configuration.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns Event
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a new Aptos client with Testnet configuration
const config = new AptosConfig({ network: Network.TESTNET }); // Specify your own network if needed
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
get
- get
Account Events By Creation Number(args): Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]> Retrieve events associated with a specific account address and creation number.
+Parameters
- args: {
accountAddress: AccountAddressInput;
creationNumber: AnyNumber;
minimumLedgerVersion?: AnyNumber;
}The parameters for retrieving account events.
+account
Address: AccountAddressInput The account address to query events for.
+creation
Number: AnyNumber The event creation number to filter the events.
+OptionalminimumLedger Version?: AnyNumber Optional minimum ledger version to sync up to before querying.
+
Returns Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]>Promise
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get events for the account at creation number 0
const events = await aptos.getAccountEventsByCreationNumber({
accountAddress: "0x1", // replace with a real account address
creationNumber: 0,
});
console.log(events);
}
runExample().catch(console.error); +- args: {
get
- get
Account Events By Event Type(args): Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]> Retrieve events associated with a specific account address and event type.
+Parameters
- args: {
accountAddress: AccountAddressInput;
eventType: `${string}::${string}::${string}`;
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}>;
}account
Address: AccountAddressInput The account address to query events for.
+event
Type: `${string}::${string}::${string}` The type of event to filter by.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}>Optional pagination and ordering parameters for the event query.
+
Returns Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]>Promise
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get events for a specific account and event type
const events = await aptos.getAccountEventsByEventType({
accountAddress: "0x1", // replace with a real account address
eventType: "0x1::transaction_fee::FeeStatement", // replace with a real event type
minimumLedgerVersion: 1, // optional, specify if needed
});
console.log(events);
}
runExample().catch(console.error); +- args: {
get
- get
Events(args?): Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]> Retrieve all events from the Aptos blockchain. +An optional
+whereclause can be provided to filter the results based on specific criteria.Parameters
Optionalargs: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}> & WhereArg<EventsBoolExp>;
}Optional parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}> & WhereArg<EventsBoolExp>Optional pagination and filtering options.
+
Returns Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]>GetEventsQuery response type containing the events.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve all events
const events = await aptos.getEvents();
// Retrieve events with filtering by account address
const whereCondition = {
account_address: { _eq: "0x123" }, // replace with a real account address
};
const filteredEvents = await aptos.getEvents({
options: { where: whereCondition },
});
console.log(events);
console.log(filteredEvents);
}
runExample().catch(console.error); +
get
- get
Module Events By Event Type(args): Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]> Retrieve module events based on a specified event type. +This function allows you to query for events that are associated with a particular module event type in the Aptos blockchain.
+Parameters
- args: {
eventType: `${string}::${string}::${string}`;
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & OrderByArg<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}>;
}The arguments for retrieving module events.
+event
Type: `${string}::${string}::${string}` The event type to filter the results.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & OrderByArg<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}>Optional pagination and ordering parameters for the event results.
+
Returns Promise<{
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[]>Promise
+- A promise that resolves to the retrieved events. Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve module events for a specific event type
const events = await aptos.getModuleEventsByEventType({
eventType: "0x1::transaction_fee::FeeStatement", // specify the event type
minimumLedgerVersion: 1, // optional: specify minimum ledger version if needed
});
console.log(events); // log the retrieved events
}
runExample().catch(console.error); +- args: {
Class EventEmitter<EventTypes, Context>
Minimal EventEmitter interface that is molded against the Node.js
+EventEmitter interface.
Type Parameters
- EventTypes extends ValidEventTypes = string | symbol
- Context extends any = any
Hierarchy (view full)
- EventEmitter
Index
Constructors
constructor
- new
Event Emitter<EventTypes, Context>(): EventEmitter<EventTypes, Context> Type Parameters
- EventTypes extends ValidEventTypes = string | symbol
- Context extends unknown = any
Returns EventEmitter<EventTypes, Context>
Methods
add
- add
Listener<T>(event, fn, context?): this Type Parameters
Parameters
- event: T
- fn: EventListener<EventTypes, T>
Optionalcontext: Context
Returns this
emit
- emit<T>(event, ...args): boolean
Calls each of the listeners registered for a given event.
+Type Parameters
Parameters
- event: T
Rest...args: Parameters<EventListener<EventTypes, T>>
Returns boolean
event
- event
Names(): EventNames<EventTypes>[] Return an array listing the events for which the emitter has registered +listeners.
+Returns EventNames<EventTypes>[]
listener
- listener
Count(event): number Return the number of listeners listening to a given event.
+Parameters
- event: EventNames<EventTypes>
Returns number
listeners
- listeners<T>(event): EventListener<EventTypes, T>[]
Return the listeners registered for a given event.
+Type Parameters
Parameters
- event: T
Returns EventListener<EventTypes, T>[]
off
- off<T>(event, fn?, context?, once?): this
Type Parameters
Parameters
- event: T
Optionalfn: EventListener<EventTypes, T>Optionalcontext: ContextOptionalonce: boolean
Returns this
on
- on<T>(event, fn, context?): this
Add a listener for a given event.
+Type Parameters
Parameters
- event: T
- fn: EventListener<EventTypes, T>
Optionalcontext: Context
Returns this
once
- once<T>(event, fn, context?): this
Add a one-time listener for a given event.
+Type Parameters
Parameters
- event: T
- fn: EventListener<EventTypes, T>
Optionalcontext: Context
Returns this
remove
- remove
All Listeners(event?): this Remove all listeners, or those of the specified event.
+Parameters
Optionalevent: EventNames<EventTypes>
Returns this
remove
- remove
Listener<T>(event, fn?, context?, once?): this Remove the listeners of a given event.
+Type Parameters
Parameters
- event: T
Optionalfn: EventListener<EventTypes, T>Optionalcontext: ContextOptionalonce: boolean
Returns this
Class Faucet
A class to query all Faucet related queries on Aptos.
Hierarchy (view full)
- Faucet
Index
Constructors
constructor
- new
Faucet(config): Faucet Initializes a new instance of the Aptos client with the specified configuration.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns Faucet
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for the Aptos client
const config = new AptosConfig({ network: Network.TESTNET }); // specify your own network if needed
// Initialize the Aptos client with the configuration
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
fund
- fund
Account(args): Promise<UserTransactionResponse> This function creates an account if it does not exist and mints the specified amount of coins into that account.
+Parameters
- args: {
accountAddress: AccountAddressInput;
amount: number;
options?: WaitForTransactionOptions;
}The arguments for funding the account.
+account
Address: AccountAddressInput The address of the account to fund.
+amount: number
The amount of tokens to fund the account with.
+Optionaloptions?: WaitForTransactionOptionsConfiguration options for waiting for the transaction.
+
Returns Promise<UserTransactionResponse>
Transaction hash of the transaction that funded the account.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fund an account with a specified amount of tokens
const transaction = await aptos.fundAccount({
accountAddress: "0x1", // replace with your account address
amount: 100,
});
console.log("Transaction hash:", transaction.hash);
}
runExample().catch(console.error); +- args: {
Class FungibleAsset
A class for querying and managing fungible asset-related operations on the Aptos blockchain.
+Hierarchy (view full)
- FungibleAsset
Index
Constructors
constructor
- new
Fungible Asset(config): FungibleAsset Initializes a new instance of the Aptos class with the provided configuration. +This allows you to interact with the Aptos blockchain using the specified network settings.
+Parameters
- config: AptosConfig
The configuration settings for connecting to the Aptos network.
+
Returns FungibleAsset
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for the Aptos client
const config = new AptosConfig({ network: Network.TESTNET }); // Specify your own network if needed
// Initialize the Aptos client with the configuration
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
get
- get
Current Fungible Asset Balances(args?): Promise<{
amount?: any;
asset_type?: null | string;
is_frozen: boolean;
is_primary?: null | boolean;
last_transaction_timestamp?: any;
last_transaction_version?: any;
owner_address: string;
storage_id: string;
token_standard?: null | string;
}[]> Queries all fungible asset balances.
+Parameters
Optionalargs: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
}Optional parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to, before querying.
+Optionaloptions?: PaginationArgs & WhereArg<CurrentFungibleAssetBalancesBoolExp>Optional configuration for pagination and filtering.
+
Returns Promise<{
amount?: any;
asset_type?: null | string;
is_frozen: boolean;
is_primary?: null | boolean;
last_transaction_timestamp?: any;
last_transaction_version?: any;
owner_address: string;
storage_id: string;
token_standard?: null | string;
}[]>A list of fungible asset metadata.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching current fungible asset balances
const fungibleAssetBalances = await aptos.getCurrentFungibleAssetBalances();
console.log(fungibleAssetBalances);
}
runExample().catch(console.error); +
get
- get
Fungible Asset Activities(args?): Promise<{
amount?: any;
asset_type?: null | string;
block_height: any;
entry_function_id_str?: null | string;
event_index: any;
gas_fee_payer_address?: null | string;
is_frozen?: null | boolean;
is_gas_fee: boolean;
is_transaction_success: boolean;
owner_address?: null | string;
storage_id: string;
storage_refund_amount: any;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}[]> Queries all fungible asset activities and returns a list of their metadata.
+Parameters
Optionalargs: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & WhereArg<FungibleAssetActivitiesBoolExp>;
}Optional parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to, before querying.
+Optionaloptions?: PaginationArgs & WhereArg<FungibleAssetActivitiesBoolExp>Optional configuration for pagination and filtering.
+
Returns Promise<{
amount?: any;
asset_type?: null | string;
block_height: any;
entry_function_id_str?: null | string;
event_index: any;
gas_fee_payer_address?: null | string;
is_frozen?: null | boolean;
is_gas_fee: boolean;
is_transaction_success: boolean;
owner_address?: null | string;
storage_id: string;
storage_refund_amount: any;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}[]>A list of fungible asset metadata.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching fungible asset activities
const fungibleAssetActivities = await aptos.getFungibleAssetActivities();
console.log(fungibleAssetActivities);
}
runExample().catch(console.error); +
get
- get
Fungible Asset Metadata(args?): Promise<{
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
supply_v2?: any;
symbol: string;
token_standard: string;
}[]> Queries all fungible asset metadata.
+Parameters
Optionalargs: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & WhereArg<FungibleAssetMetadataBoolExp>;
}Optional parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: PaginationArgs & WhereArg<FungibleAssetMetadataBoolExp>Optional configuration for pagination and filtering.
+
Returns Promise<{
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
supply_v2?: any;
symbol: string;
token_standard: string;
}[]>A list of fungible asset metadata.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching fungible asset metadata
const fungibleAssets = await aptos.getFungibleAssetMetadata();
console.log(fungibleAssets);
}
runExample().catch(console.error); +
get
- get
Fungible Asset Metadata By Asset Type(args): Promise<{
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
supply_v2?: any;
symbol: string;
token_standard: string;
}> Queries the fungible asset metadata for a specific asset type. +This function helps retrieve detailed information about a fungible asset based on its type.
+Parameters
Returns Promise<{
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
supply_v2?: any;
symbol: string;
token_standard: string;
}>A fungible asset metadata item.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve fungible asset metadata by asset type
const fungibleAsset = await aptos.getFungibleAssetMetadataByAssetType({
assetType: "0x1::aptos_coin::AptosCoin" // replace with your asset type
});
console.log(fungibleAsset);
}
runExample().catch(console.error); +
get
- get
Fungible Asset Metadata By Creator Address(args): Promise<{
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
supply_v2?: any;
symbol: string;
token_standard: string;
}[]> Retrieves fungible asset metadata based on the creator address.
+This function allows you to query metadata for a specific fungible asset created by a given address.
+Parameters
- args: {
creatorAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
}The parameters for the query.
+creator
Address: AccountAddressInput The creator address of the fungible asset.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+
Returns Promise<{
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: null | string;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any;
name: string;
project_uri?: null | string;
supply_aggregator_table_handle_v1?: null | string;
supply_aggregator_table_key_v1?: null | string;
supply_v2?: any;
symbol: string;
token_standard: string;
}[]>A fungible asset metadata item.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve fungible asset metadata by creator address
const fungibleAsset = await aptos.getFungibleAssetMetadataByCreatorAddress({
creatorAddress: "0x123", // replace with a real creator address
});
console.log(fungibleAsset);
}
runExample().catch(console.error); +- args: {
transfer
- transfer
Fungible Asset(args): Promise<SimpleTransaction> Transfer a specified amount of fungible asset from the sender's primary store to the recipient's primary store. +This method allows you to transfer any fungible asset, including fungible tokens.
+Parameters
- args: {
amount: AnyNumber;
fungibleAssetMetadataAddress: AccountAddressInput;
options?: InputGenerateTransactionOptions;
recipient: AccountAddressInput;
sender: Account;
}The arguments for the transfer operation.
+amount: AnyNumber
The number of assets to transfer.
+fungible
Asset Metadata Address: AccountAddressInput The fungible asset account address. For example, if you’re transferring USDT, +this would be the USDT address.
+Optionaloptions?: InputGenerateTransactionOptionsOptional parameters for generating the transaction.
+recipient: AccountAddressInput
The recipient account address.
+sender: Account
The sender account.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Transfer fungible asset from sender to recipient
const transaction = await aptos.transferFungibleAsset({
sender: Account.generate(), // replace with a real sender account
fungibleAssetMetadataAddress: "0x123", // replace with a real fungible asset address
recipient: "0x456", // replace with a real recipient account
amount: 5
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
Class G1Bytes
Represents a fixed-size byte array of 32 bytes, extending the Serializable class. +This class is used for handling and serializing G1 bytes in cryptographic operations.
+Hierarchy (view full)
- Serializable
- G1Bytes
Index
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): G1Bytes
Parameters
- deserializer: Deserializer
Returns G1Bytes
Class G2Bytes
Represents a 64-byte G2 element in a cryptographic context. +This class provides methods for serialization and deserialization of G2 bytes.
+Hierarchy (view full)
- Serializable
- G2Bytes
Index
Methods
bcs
bcs
serialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Staticdeserialize
- deserialize(deserializer): G2Bytes
Parameters
- deserializer: Deserializer
Returns G2Bytes
Class General
A class to query various Aptos-related information and perform operations on the Aptos blockchain.
+Hierarchy (view full)
- General
Index
Constructors
constructor
- new
General(config): General Initializes a new instance of the Aptos client with the specified configuration. +This allows users to interact with the Aptos blockchain using the provided settings.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns General
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for the Aptos client
const config = new AptosConfig({
network: Network.TESTNET, // specify the network
nodeUrl: "https://testnet.aptos.dev" // specify the node URL
});
// Initialize the Aptos client with the configuration
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
get
- get
Block By Height(args): Promise<Block> Retrieve a block by its height, allowing for the inclusion of transactions if specified.
+Parameters
- args: {
blockHeight: AnyNumber;
options?: {
withTransactions?: boolean;
};
}The parameters for the block retrieval.
+block
Height: AnyNumber The block height to look up, starting at 0.
+Optionaloptions?: {
withTransactions?: boolean;
}Optional settings for the retrieval.
+OptionalwithTransactions?: boolean
Returns Promise<Block>
The block with optional transactions included.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve the block at height 5, including transactions
const block = await aptos.getBlockByHeight({ blockHeight: 5, options: { withTransactions: true } });
console.log(block);
}
runExample().catch(console.error); +- args: {
get
- get
Block By Version(args): Promise<Block> Retrieves block information by the specified ledger version.
+Parameters
- args: {
ledgerVersion: AnyNumber;
options?: {
withTransactions?: boolean;
};
}The arguments for retrieving the block.
+ledger
Version: AnyNumber The ledger version to lookup block information for.
+Optionaloptions?: {
withTransactions?: boolean;
}Optional parameters for the request.
+OptionalwithTransactions?: boolean
Returns Promise<Block>
Block information with optional transactions.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve block information for a specific ledger version
const block = await aptos.getBlockByVersion({ ledgerVersion: 5 });
console.log(block);
}
runExample().catch(console.error); +- args: {
get
- get
Chain Id(): Promise<number> Retrieves the chain ID of the Aptos blockchain.
+Returns Promise<number>
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching the chain ID
const chainId = await aptos.getChainId();
console.log("Chain ID:", chainId);
}
runExample().catch(console.error);
@returns The chain ID of the Aptos blockchain. +
get
- get
Chain Top User Transactions(args): Promise<{
version: any;
}[]> Queries the top user transactions based on the specified limit.
+Parameters
- args: {
limit: number;
}The arguments for querying top user transactions.
+limit: number
The number of transactions to return.
+
Returns Promise<{
version: any;
}[]>GetChainTopUserTransactionsResponse
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetch the top user transactions with a limit of 5
const topUserTransactions = await aptos.getChainTopUserTransactions({ limit: 5 });
console.log(topUserTransactions);
}
runExample().catch(console.error); +- args: {
get
- get
Indexer Last Success Version(): Promise<bigint> Queries for the last successful indexer version, providing insight into the ledger version the indexer is updated to, which +may lag behind the full nodes.
+Returns Promise<bigint>
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the last successful indexer version
const version = await aptos.getIndexerLastSuccessVersion();
console.log(`Last successful indexer version: ${version}`);
}
runExample().catch(console.error); +
get
- get
Ledger Info(): Promise<LedgerInfo> Queries for the Aptos ledger information.
+Returns Promise<LedgerInfo>
The Aptos Ledger Info, which includes details such as chain ID, epoch, and ledger version.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching the ledger information
const ledgerInfo = await aptos.getLedgerInfo();
console.log(ledgerInfo);
}
runExample().catch(console.error); +
get
- get
Processor Status(processorType): Promise<{
last_success_version: any;
last_updated: any;
processor: string;
}> Query the processor status for a specific processor type.
+Parameters
- processorType: ProcessorType
The processor type to query.
+
Returns Promise<{
last_success_version: any;
last_updated: any;
processor: string;
}>The status of the specified processor type.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the processor status for the account transactions processor
const status = await aptos.getProcessorStatus("account_transactions_processor");
console.log(status);
}
runExample().catch(console.error); +- processorType: ProcessorType
query
- query
Indexer<T>(args): Promise<T> Retrieves data from the Aptos Indexer using a GraphQL query. +This function allows you to execute complex queries to fetch specific data from the Aptos blockchain.
+Type Parameters
Parameters
- args: {
query: GraphqlQuery;
}query: GraphqlQuery
Returns Promise<T>
The provided T type.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Querying the Aptos Indexer for ledger information
const topUserTransactions = await aptos.queryIndexer({
query: `query MyQuery {
ledger_infos {
chain_id
}
}`
});
console.log(topUserTransactions);
}
runExample().catch(console.error); +- args: {
view
- view<T>(args): Promise<T>
Queries for a Move view function
+Type Parameters
- T extends MoveValue[]
Parameters
- args: {
options?: LedgerVersionArg;
payload: InputViewFunctionData;
}Optionaloptions?: LedgerVersionArgpayload: InputViewFunctionData
Payload for the view function
+
Returns Promise<T>
an array of Move values
+
view
- view
Json<T>(args): Promise<T> Queries for a Move view function with JSON, this provides compatability with the old
+aptospackageType Parameters
- T extends MoveValue[]
Parameters
- args: {
options?: LedgerVersionArg;
payload: InputViewFunctionJsonData;
}Optionaloptions?: LedgerVersionArgpayload: InputViewFunctionJsonData
Payload for the view function
+
Returns Promise<T>
an array of Move values
+
Class Keyless
A class to query all Keyless related queries on Aptos.
More documentation on how to integrate Keyless Accounts see the below +Aptos Keyless Integration Guide.
+Hierarchy (view full)
- Keyless
Index
Constructors
constructor
- new
Keyless(config): Keyless Initializes a new instance of the Aptos class with the provided configuration. +This allows you to interact with the Aptos blockchain using the specified network settings.
+Parameters
- config: AptosConfig
The configuration settings for connecting to the Aptos network.
+
Returns Keyless
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a new configuration for the Aptos client
const config = new AptosConfig({ network: Network.TESTNET }); // Specify your desired network
// Initialize the Aptos client with the configuration
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
derive
- derive
Keyless Account(args): Promise<KeylessAccount> Parameters
- args: {
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
pepper?: HexInput;
proofFetchCallback?: ProofFetchCallback;
uidKey?: string;
}ephemeral
Key Pair: EphemeralKeyPair jwt: string
Optionalpepper?: HexInputOptionalproofFetch Callback?: ProofFetchCallback OptionaluidKey?: string
Returns Promise<KeylessAccount>
- args: {
- derive
Keyless Account(args): Promise<FederatedKeylessAccount> Parameters
- args: {
ephemeralKeyPair: EphemeralKeyPair;
jwkAddress: AccountAddressInput;
jwt: string;
pepper?: HexInput;
proofFetchCallback?: ProofFetchCallback;
uidKey?: string;
}ephemeral
Key Pair: EphemeralKeyPair jwk
Address: AccountAddressInput jwt: string
Optionalpepper?: HexInputOptionalproofFetch Callback?: ProofFetchCallback OptionaluidKey?: string
Returns Promise<FederatedKeylessAccount>
- args: {
get
- get
Pepper(args): Promise<Uint8Array> Fetches the pepper from the Aptos pepper service API.
+Parameters
- args: {
derivationPath?: string;
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
}The arguments for fetching the pepper.
+OptionalderivationPath?: string A derivation path used for creating multiple accounts per user via the BIP-44 standard. Defaults +to "m/44'/637'/0'/0'/0".
+ephemeral
Key Pair: EphemeralKeyPair The EphemeralKeyPair used to generate the nonce in the JWT token.
+jwt: string
JWT token.
+
Returns Promise<Uint8Array>
The pepper which is a Uint8Array of length 31.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const ephemeralKeyPair = new EphemeralKeyPair(); // create a new ephemeral key pair
const jwt = "your_jwt_token"; // replace with a real JWT token
// Fetching the pepper using the provided JWT and ephemeral key pair
const pepper = await aptos.getPepper({
jwt,
ephemeralKeyPair,
// derivationPath: "m/44'/637'/0'/0'/0" // specify your own if needed
});
console.log("Fetched pepper:", pepper);
}
runExample().catch(console.error); +- args: {
get
- get
Proof(args): Promise<ZeroKnowledgeSig> Fetches a proof from the Aptos prover service API.
+Parameters
- args: {
ephemeralKeyPair: EphemeralKeyPair;
jwt: string;
pepper?: HexInput;
uidKey?: string;
}The arguments for fetching the proof.
+ephemeral
Key Pair: EphemeralKeyPair The EphemeralKeyPair used to generate the nonce in the JWT token.
+jwt: string
JWT token.
+Optionalpepper?: HexInputThe pepper used for the account. If not provided, it will be fetched from the Aptos pepper service.
+OptionaluidKey?: string A key in the JWT token to use to set the uidVal in the IdCommitment.
+
Returns Promise<ZeroKnowledgeSig>
The proof which is represented by a ZeroKnowledgeSig.
+Example
+ +import { Aptos, AptosConfig, Network, EphemeralKeyPair, getPepper } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const jwt = "your_jwt_token"; // replace with a real JWT token
const ephemeralKeyPair = new EphemeralKeyPair(); // create a new ephemeral key pair
// Fetch the proof using the getProof function
const proof = await aptos.getProof({
jwt,
ephemeralKeyPair,
pepper: await getPepper({}), // fetch the pepper if not provided
uidKey: "sub", // specify the uid key
});
console.log("Fetched proof:", proof);
}
runExample().catch(console.error); +- args: {
update
- update
Federated Keyless Jwk Set Transaction(args): Promise<SimpleTransaction> This installs a set of FederatedJWKs at an address for a given iss.
+It will fetch the JSON Web Keyset (JWK) set from the well-known endpoint and update the FederatedJWKs at the sender's address +to reflect it.
+Parameters
- args: {
iss: string;
jwksUrl?: string;
options?: InputGenerateTransactionOptions;
sender: Account;
}iss: string
the iss claim of the federated OIDC provider.
+OptionaljwksUrl?: string the URL to find the corresponding JWKs. For supported IDP providers this parameter in not necessary.
+Optionaloptions?: InputGenerateTransactionOptionssender: Account
The account that will install the JWKs
+
Returns Promise<SimpleTransaction>
The pending transaction that results from submission.
+- args: {
Class ProofAbstract
An abstract representation of a cryptographic proof associated with specific +zero-knowledge proof schemes, such as Groth16 and PLONK.
+Hierarchy (view full)
Index
Constructors
Methods
Methods
bcs
bcs
Abstractserialize
- serialize(serializer): void
Parameters
- serializer: Serializer
Returns void
to
to
Class Simulate
A class to handle all Simulate transaction operations.
Index
Constructors
constructor
- new
Simulate(config): Simulate Initializes a new instance of the Aptos client with the specified configuration. +This allows you to interact with the Aptos blockchain using the provided settings.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns Simulate
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for the Aptos client
const config = new AptosConfig({ network: Network.TESTNET }); // Specify your desired network
// Initialize the Aptos client with the configuration
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
multi
- multi
Agent(args): Promise<UserTransactionResponse[]> Simulates a multi-agent transaction by generating a signed transaction and posting it to the Aptos full node. +This function helps in understanding the outcome of a transaction involving multiple signers before it is executed.
+Parameters
- args: {
feePayerPublicKey?: PublicKey;
options?: InputSimulateTransactionOptions;
secondarySignersPublicKeys: PublicKey[];
signerPublicKey: PublicKey;
transaction: AnyRawTransaction;
}The parameters for simulating the transaction.
+OptionalfeePayer Public Key?: PublicKey (Optional) The public key of the fee payer.
+Optionaloptions?: InputSimulateTransactionOptions(Optional) Options for simulating the transaction.
+secondary
Signers Public Keys: PublicKey[] An array of public keys for secondary signers.
+signer
Public Key: PublicKey The public key of the primary signer.
+transaction: AnyRawTransaction
The raw transaction to be simulated.
+
Returns Promise<UserTransactionResponse[]>
Example
+ +import {
Account,
Aptos,
AptosConfig,
Network,
} from "@aptos-labs/ts-sdk";
async function example() {
let sender1 = Account.generate();
let sender2 = Account.generate();
let receiver = Account.generate();
// 0. Set up the client and test accounts
const config = new AptosConfig({ network: Network.DEVNET });
const aptos = new Aptos(config);
await aptos.fundAccount({
accountAddress: sender.accountAddress,
amount: 100_000_000,
});
// 1. Build
console.log("\n=== 1. Building the transaction ===\n");
const transaction = await aptos.transaction.build.multiAgent({
sender: sender1.accountAddress,
secondarySignerAddresses: [sender2.accountAddress],
data: {
// REPLACE WITH YOUR MULTI-AGENT FUNCTION HERE
function:
"<REPLACE WITH YOUR MULTI AGENT MOVE ENTRY FUNCTION> (Syntax {address}::{module}::{function})",
functionArguments: [],
},
});
console.log("Transaction:", transaction);
// 2. Simulate (Optional)
console.log("\n === 2. Simulating Response (Optional) === \n");
const [userTransactionResponse] = await aptos.transaction.simulate.multiAgent(
{
signerPublicKey: sender1.publicKey,
secondarySignersPublicKeys: [sender2.publicKey],
transaction,
},
);
console.log(userTransactionResponse);
// If the fee looks ok, continue to signing!
// ...
}
example(); +- args: {
simple
- simple(args): Promise<UserTransactionResponse[]>
Simulates a transaction based on the provided parameters and returns the result. +This function helps you understand the outcome of a transaction before executing it on the blockchain.
+Parameters
- args: {
feePayerPublicKey?: PublicKey;
options?: InputSimulateTransactionOptions;
signerPublicKey: PublicKey;
transaction: AnyRawTransaction;
}The parameters for simulating the transaction.
+OptionalfeePayer Public Key?: PublicKey The public key of the fee payer (optional).
+Optionaloptions?: InputSimulateTransactionOptionsAdditional options for simulating the transaction (optional).
+signer
Public Key: PublicKey The public key of the signer for the transaction.
+transaction: AnyRawTransaction
The raw transaction data to simulate.
+
Returns Promise<UserTransactionResponse[]>
Example
+ +import {
Account,
Aptos,
AptosConfig,
Network,
} from "@aptos-labs/ts-sdk";
async function example() {
let sender = Account.generate();
let receiver = Account.generate();
// 0. Set up the client and test accounts
const config = new AptosConfig({ network: Network.DEVNET });
const aptos = new Aptos(config);
await aptos.fundAccount({
accountAddress: sender.accountAddress,
amount: 100_000_000,
});
// 1. Build the transaction to preview the impact of it
const transaction = await aptos.transaction.build.simple({
sender: sender.accountAddress,
data: {
// All transactions on Aptos are implemented via smart contracts.
function: "0x1::aptos_account::transfer",
functionArguments: [receiver.accountAddress, 100],
},
});
// 2. Simulate to see what would happen if we execute this transaction
const [userTransactionResponse] = await aptos.transaction.simulate.simple({
signerPublicKey: sender.publicKey,
transaction,
});
console.log(userTransactionResponse);
// If the fee looks ok, continue to signing!
// ...
}
example(); +- args: {
Class Staking
A class to query all Staking related queries on Aptos.
Hierarchy (view full)
- Staking
Index
Constructors
constructor
- new
Staking(config): Staking Creates an instance of the Aptos client with the specified configuration. +This allows you to interact with the Aptos blockchain using the provided settings.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns Staking
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for the Aptos client
const config = new AptosConfig({ network: Network.TESTNET }); // Specify your network
// Initialize the Aptos client with the configuration
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
get
- get
Delegated Staking Activities(args): Promise<{
amount: any;
delegator_address: string;
event_index: any;
event_type: string;
pool_address: string;
transaction_version: any;
}[]> Queries delegated staking activities for a specific delegator and pool.
+Parameters
- args: {
delegatorAddress: AccountAddressInput;
minimumLedgerVersion?: AnyNumber;
poolAddress: AccountAddressInput;
}The arguments for querying delegated staking activities.
+delegator
Address: AccountAddressInput The address of the delegator.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+pool
Address: AccountAddressInput The address of the staking pool.
+
Returns Promise<{
amount: any;
delegator_address: string;
event_index: any;
event_type: string;
pool_address: string;
transaction_version: any;
}[]>The response containing delegated staking activities.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get delegated staking activities for a specific delegator and pool
const activities = await aptos.getDelegatedStakingActivities({
delegatorAddress: "0x1", // replace with a real delegator address
poolAddress: "0x2", // replace with a real pool address
minimumLedgerVersion: 1, // specify your own if needed
});
console.log(activities);
}
runExample().catch(console.error); +- args: {
get
- get
Number Of Delegators(args): Promise<number> Queries the current number of delegators in a specified pool. Throws an error if the pool is not found.
+Parameters
- args: {
minimumLedgerVersion?: AnyNumber;
poolAddress: AccountAddressInput;
}The parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+pool
Address: AccountAddressInput The address of the pool to query.
+
Returns Promise<number>
The number of delegators for the given pool.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Get the number of delegators for a specific pool
const delegators = await aptos.getNumberOfDelegators({ poolAddress: "0x1" }); // replace with a real pool address
console.log(`Number of delegators: ${delegators}`);
}
runExample().catch(console.error); +- args: {
get
- get
Number Of Delegators For All Pools(args?): Promise<{
num_active_delegator?: any;
pool_address?: null | string;
}[]> Retrieves the current number of delegators across all pools.
+Parameters
Optionalargs: {
minimumLedgerVersion?: AnyNumber;
options?: OrderByArg<{
num_active_delegator?: any;
pool_address?: null | string;
}>;
}Optional parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional ledger version to sync up to before querying.
+Optionaloptions?: OrderByArg<{
num_active_delegator?: any;
pool_address?: null | string;
}>Optional ordering options for the response.
+
Returns Promise<{
num_active_delegator?: any;
pool_address?: null | string;
}[]>GetNumberOfDelegatorsForAllPoolsResponse response type containing the number of delegators per pool.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve the number of delegators for all pools
const delegators = await aptos.getNumberOfDelegatorsForAllPools();
console.log(delegators);
}
runExample().catch(console.error); +
Class Submit
A class to handle all Submit transaction operations.
Index
Constructors
constructor
- new
Submit(config): Submit Initializes a new instance of the Aptos client with the specified configuration. +This allows you to interact with the Aptos blockchain using the provided settings.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns Submit
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for the Aptos client
const config = new AptosConfig({
network: Network.TESTNET, // Use the TESTNET for testing
nodeUrl: "https://testnet.aptos.dev", // Specify the node URL
faucetUrl: "https://faucet.testnet.aptos.dev" // Specify the faucet URL
});
// Initialize the Aptos client with the configuration
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
multi
- multi
Agent(args): Promise<PendingTransactionResponse> Submits a multi-agent transaction to the Aptos network, allowing multiple signers to authorize the transaction. +This function is useful for scenarios where a transaction requires approval from multiple accounts.
+Parameters
- args: {
additionalSignersAuthenticators: AccountAuthenticator[];
feePayerAuthenticator?: AccountAuthenticator;
senderAuthenticator: AccountAuthenticator;
transaction: AnyRawTransaction;
}The parameters for the multi-agent transaction.
+additional
Signers Authenticators: AccountAuthenticator[] An array of authenticators for additional signers.
+OptionalfeePayer Authenticator?: AccountAuthenticator An optional authenticator for the fee payer account.
+sender
Authenticator: AccountAuthenticator The authenticator for the sender account.
+transaction: AnyRawTransaction
The raw transaction to be submitted.
+
Returns Promise<PendingTransactionResponse>
Example
+ +import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const sender = Account.generate(); // Generate a new sender account
const additionalSigner1 = Account.generate(); // Generate an additional signer account
const additionalSigner2 = Account.generate(); // Generate another additional signer account
const transaction = await aptos.transaction.build.simple({
sender: sender.accountAddress,
data: {
function: "0x1::aptos_account::transfer",
functionArguments: [additionalSigner1.accountAddress, 100],
},
});
const response = await aptos.multiAgent({
transaction,
senderAuthenticator: sender.getAuthenticator(), // Use the sender's authenticator
additionalSignersAuthenticators: [
additionalSigner1.getAuthenticator(), // Use the first additional signer's authenticator
additionalSigner2.getAuthenticator(), // Use the second additional signer's authenticator
],
});
console.log(response); // Log the response from the transaction submission
}
runExample().catch(console.error); +- args: {
simple
- simple(args): Promise<PendingTransactionResponse>
Submits a transaction to the Aptos blockchain using the provided transaction details and authenticators. +This function allows you to execute transactions securely by specifying the sender and optional fee payer authenticators.
+Parameters
- args: {
feePayerAuthenticator?: AccountAuthenticator;
senderAuthenticator: AccountAuthenticator;
transaction: AnyRawTransaction;
}The arguments for submitting the transaction.
+OptionalfeePayer Authenticator?: AccountAuthenticator The optional authenticator for the fee payer's account.
+sender
Authenticator: AccountAuthenticator The authenticator for the sender's account.
+transaction: AnyRawTransaction
The raw transaction data to be submitted.
+
Returns Promise<PendingTransactionResponse>
Example
+ +import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const sender = Account.generate(); // Generate a new sender account
const transaction = await aptos.transaction.build.simple({
sender: sender.accountAddress,
data: {
function: "0x1::aptos_account::transfer",
functionArguments: [Account.generate().accountAddress, 100], // Replace with a real destination account
},
});
// Submit the transaction
const response = await aptos.simple({
transaction,
senderAuthenticator: sender.getAuthenticator(), // Use the sender's authenticator
});
console.log("Transaction submitted:", response);
}
runExample().catch(console.error); +- args: {
Class Table
A class to query all Table Aptos related queries.
Hierarchy (view full)
- Table
Index
Constructors
constructor
- new
Table(config): Table Initializes a new instance of the Aptos client with the specified configuration. +This allows you to interact with the Aptos blockchain using the provided settings.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns Table
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a new Aptos client with testnet configuration
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
console.log("Aptos client initialized:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
get
- get
Table Item<T>(args): Promise<T> Queries for a specific item in a table identified by the handle and the key for the item. +This function allows you to retrieve structured data from a table in the Aptos blockchain.
+Type Parameters
Parameters
- args: {
data: TableItemRequest;
handle: string;
options?: LedgerVersionArg;
}data: TableItemRequest
Object that describes the table item, including key and value types.
+handle: string
A pointer to where that table is stored.
+Optionaloptions?: LedgerVersionArg
Returns Promise<T>
Table item value rendered in JSON.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve a table item from the Aptos blockchain
const tableItem = await aptos.getTableItem({
handle: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca",
data: {
key_type: "address", // Move type of table key
value_type: "u128", // Move type of table value
key: "0x619dc29a0aac8fa146714058e8dd6d2d0f3bdf5f6331907bf91f3acd81e6935" // Value of table key
},
});
console.log(tableItem);
}
runExample().catch(console.error); +- args: {
get
- get
Table Items Data(args): Promise<{
decoded_key: any;
decoded_value?: any;
key: string;
table_handle: string;
transaction_version: any;
write_set_change_index: any;
}[]> Queries for table items data with optional filtering and pagination. +This function allows you to retrieve specific data from a table based on provided criteria.
+Parameters
- args: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & WhereArg<TableItemsBoolExp> & OrderByArg<{
decoded_key: any;
decoded_value?: any;
key: string;
table_handle: string;
transaction_version: any;
write_set_change_index: any;
}>;
}The arguments for querying table items data.
+OptionalminimumLedger Version?: AnyNumber Optional minimum ledger version to wait for before querying.
+Optionaloptions?: PaginationArgs & WhereArg<TableItemsBoolExp> & OrderByArg<{
decoded_key: any;
decoded_value?: any;
key: string;
table_handle: string;
transaction_version: any;
write_set_change_index: any;
}>Optional parameters for pagination and filtering.
+
Returns Promise<{
decoded_key: any;
decoded_value?: any;
key: string;
table_handle: string;
transaction_version: any;
write_set_change_index: any;
}[]>GetTableItemsDataResponse
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Retrieve table items data with specific filtering options
const data = await aptos.getTableItemsData({
minimumLedgerVersion: 1, // specify your own minimum ledger version if needed
options: {
where: {
table_handle: { _eq: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca" },
transaction_version: { _eq: "0" }
},
limit: 10, // specify your own limit if needed
},
});
console.log(data);
}
runExample().catch(console.error); +- args: {
get
- get
Table Items Metadata(args): Promise<{
handle: string;
key_type: string;
value_type: string;
}[]> Queries for the metadata of table items, allowing for filtering and pagination.
+Parameters
- args: {
minimumLedgerVersion?: AnyNumber;
options?: PaginationArgs & WhereArg<TableMetadatasBoolExp> & OrderByArg<{
handle: string;
key_type: string;
value_type: string;
}>;
}The parameters for the query.
+OptionalminimumLedger Version?: AnyNumber Optional minimum ledger version to wait for before querying.
+Optionaloptions?: PaginationArgs & WhereArg<TableMetadatasBoolExp> & OrderByArg<{
handle: string;
key_type: string;
value_type: string;
}>Optional parameters for pagination and filtering.
+
Returns Promise<{
handle: string;
key_type: string;
value_type: string;
}[]>GetTableItemsMetadataResponse
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching table items metadata with a filter condition
const data = await aptos.getTableItemsMetadata({
minimumLedgerVersion: 1, // specify your own minimum ledger version if needed
options: {
where: { handle: { _eq: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca" } },
limit: 10, // specify your own limit if needed
},
});
console.log(data);
}
runExample().catch(console.error); +- args: {
Class Transaction
Represents a transaction in the Aptos blockchain, +providing methods to build, simulate, submit, and manage transactions. +This class encapsulates functionalities for querying transaction details, +estimating gas prices, signing transactions, and handling transaction states.
+This class is used as part of the Aptos object, so should be called like so:
+Example
import { Account, Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const APTOS_COIN = "0x1::aptos_coin::AptosCoin";
const COIN_STORE = `0x1::coin::CoinStore<${APTOS_COIN}>`;
const ALICE_INITIAL_BALANCE = 100_000_000;
const TRANSFER_AMOUNT = 100;
async function example() {
console.log(
"This example will create two accounts (Alice and Bob), fund them, and transfer between them.",
);
// Set up the client
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
// Generate two account credentials
// Each account has a private key, a public key, and an address
const alice = Account.generate();
const bob = Account.generate();
console.log("=== Addresses ===\n");
console.log(`Alice's address is: ${alice.accountAddress}`);
console.log(`Bob's address is: ${bob.accountAddress}`);
// Fund the accounts using a faucet
console.log("\n=== Funding accounts ===\n");
await aptos.fundAccount({
accountAddress: alice.accountAddress,
amount: ALICE_INITIAL_BALANCE,
});
// Send a transaction from Alice's account to Bob's account
const txn = await aptos.transaction.build.simple({
sender: alice.accountAddress,
data: {
// All transactions on Aptos are implemented via smart contracts.
function: "0x1::aptos_account::transfer",
functionArguments: [bob.accountAddress, 100],
},
});
console.log("\n=== Transfer transaction ===\n");
// Both signs and submits
const committedTxn = await aptos.signAndSubmitTransaction({
signer: alice,
transaction: txn,
});
// Waits for Aptos to verify and execute the transaction
const executedTransaction = await aptos.waitForTransaction({
transactionHash: committedTxn.hash,
});
console.log("Transaction hash:", executedTransaction.hash);
console.log("\n=== Balances after transfer ===\n");
const newAliceAccountBalance = await aptos.getAccountResource({
accountAddress: alice.accountAddress,
resourceType: COIN_STORE,
});
const newAliceBalance = Number(newAliceAccountBalance.coin.value);
console.log(`Alice's balance is: ${newAliceBalance}`);
const newBobAccountBalance = await aptos.getAccountResource({
accountAddress: bob.accountAddress,
resourceType: COIN_STORE,
});
const newBobBalance = Number(newBobAccountBalance.coin.value);
console.log(`Bob's balance is: ${newBobBalance}`);
}
example();
+ Index
Constructors
Methods
Properties
Constructors
constructor
- new
Transaction(config): Transaction Creates an instance of the Aptos client with the specified configuration. +This allows you to interact with the Aptos blockchain using the provided settings.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns Transaction
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a new Aptos client instance
const config = new AptosConfig({ network: Network.TESTNET }); // Specify the network
const aptos = new Aptos(config);
console.log("Aptos client created successfully:", aptos);
}
runExample().catch(console.error); +- config: AptosConfig
Methods
batch
- batch
Transactions For Single Account(args): Promise<void> Parameters
- args: {
data: InputGenerateTransactionPayloadData[];
options?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">;
sender: Account;
}The arguments for batching transactions.
+data: InputGenerateTransactionPayloadData[]
An array of transaction payloads to be processed.
+Optionaloptions?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">Optional. Transaction generation configurations (excluding accountSequenceNumber).
+sender: Account
The sender account to sign and submit the transactions.
+
Returns Promise<void>
Deprecated
Prefer to use
+aptos.transaction.batch.forSingleAccount()Batch transactions for a single account by submitting multiple transaction payloads. +This function is useful for efficiently processing and submitting transactions that do not depend on each other, such as +batch funding or batch token minting.
+Example
+ +import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
const sender = Account.generate(); // Generate a new account for sending transactions
async function runExample() {
const transactions = [
{ }, // Build your first transaction payload
{ }, // Build your second transaction payload
];
// Batch transactions for the single account
await aptos.batchTransactionsForSingleAccount({
sender,
data: transactions,
});
console.log("Batch transactions submitted successfully.");
}
runExample().catch(console.error); +- args: {
get
- get
Gas Price Estimation(): Promise<GasEstimation> Estimates the gas unit price required to process a transaction on the Aptos blockchain in a timely manner. +This helps users to understand the cost associated with their transactions. +https://api.mainnet.aptoslabs.com/v1/spec#/operations/estimate_gas_price
+Returns Promise<GasEstimation>
An object containing the estimated gas price.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET }); // Specify your network
const aptos = new Aptos(config);
async function runExample() {
// Getting the gas price estimation
const gasPriceEstimation = await aptos.getGasPriceEstimation();
console.log("Estimated Gas Price:", gasPriceEstimation);
}
runExample().catch(console.error); +
get
- get
Signing Message(args): Uint8Array Returns a signing message for a transaction, allowing a user to sign it using their preferred method before submission to the network.
+Parameters
- args: {
transaction: AnyRawTransaction;
}The arguments for obtaining the signing message.
+transaction: AnyRawTransaction
A raw transaction for signing elsewhere.
+
Returns Uint8Array
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const transaction = await aptos.transaction.build.simple({
sender: "0x1", // replace with a real sender address
data: {
function: "0x1::aptos_account::transfer",
functionArguments: ["0x2", 100], // replace with a real destination address
},
});
const message = await aptos.getSigningMessage({ transaction });
console.log(message);
}
runExample().catch(console.error); +- args: {
get
- get
Transaction By Hash(args): Promise<TransactionResponse> Queries on-chain transactions by their transaction hash, returning both pending and committed transactions.
+Parameters
Returns Promise<TransactionResponse>
The transaction from the mempool (pending) or the on-chain (committed) transaction.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetch a transaction by its hash
const transaction = await aptos.getTransactionByHash({ transactionHash: "0x123" }); // replace with a real transaction hash
console.log(transaction);
}
runExample().catch(console.error); +
get
- get
Transaction By Version(args): Promise<TransactionResponse> Queries on-chain transaction by version. This function will not return pending transactions.
+Parameters
Returns Promise<TransactionResponse>
On-chain transaction. Only on-chain transactions have versions, so this +function cannot be used to query pending transactions.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetching a transaction by its version
const transaction = await aptos.getTransactionByVersion({ ledgerVersion: 1 }); // replace 1 with a real version
console.log(transaction);
}
runExample().catch(console.error); +
get
- get
Transactions(args?): Promise<TransactionResponse[]> Queries on-chain transactions, excluding pending transactions. +Use this function to retrieve historical transactions from the blockchain.
+Parameters
Optionalargs: {
options?: PaginationArgs;
}Optional parameters for pagination.
+Optionaloptions?: PaginationArgsOptional pagination options.
+
Returns Promise<TransactionResponse[]>
An array of on-chain transactions.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Fetch transactions with pagination
const transactions = await aptos.getTransactions({
options: {
offset: 0, // Start from the first transaction
limit: 10, // Limit to 10 results
},
});
console.log(transactions);
}
runExample().catch(console.error); +
is
- is
Pending Transaction(args): Promise<boolean> Defines if the specified transaction is currently in a pending state. +This function helps you determine the status of a transaction using its hash.
+Parameters
Returns Promise<boolean>
+trueif the transaction is in a pending state andfalseotherwise.Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Check if the transaction is pending using its hash
const isPendingTransaction = await aptos.isPendingTransaction({ transactionHash: "0x123" }); // replace with a real transaction hash
console.log("Is the transaction pending?", isPendingTransaction);
}
runExample().catch(console.error); +
publish
- publish
Package Transaction(args): Promise<SimpleTransaction> Generates a transaction to publish a Move package to the blockchain. +This function helps you create a transaction that can be simulated or submitted to the chain for publishing a package.
+To get the
+metadataBytesandbyteCode, can compile using Aptos CLI with command +aptos move compile --save-metadata ...,https://aptos.dev/tutorials/your-first-dapp/#step-4-publish-a-move-module
+Parameters
- args: {
account: AccountAddressInput;
metadataBytes: HexInput;
moduleBytecode: HexInput[];
options?: InputGenerateTransactionOptions;
}The arguments for publishing the package.
+account: AccountAddressInput
The publisher account.
+metadata
Bytes: HexInput The package metadata bytes.
+module
Bytecode: HexInput[] An array of the bytecode of each module in the package in compiler output order.
+Optionaloptions?: InputGenerateTransactionOptionsOptional settings for generating the transaction.
+
Returns Promise<SimpleTransaction>
A SimpleTransaction that can be simulated or submitted to the chain.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Replace with a real account address
const account = "0x1";
const metadataBytes = "0x..."; // replace with real metadata bytes
const byteCode = "0x..."; // replace with real module bytecode
const transaction = await aptos.publishPackageTransaction({
account,
metadataBytes,
moduleBytecode: [byteCode],
});
console.log(transaction);
}
runExample().catch(console.error); +- args: {
rotate
- rotate
Auth Key(args): Promise<TransactionResponse> Rotate an account's authentication key. After rotation, only the new private key can be used to sign transactions for the account. +Note: Only legacy Ed25519 scheme is supported for now. +More info: https://aptos.dev/guides/account-management/key-rotation/
+Parameters
- args: {
fromAccount: Account;
toNewPrivateKey: PrivateKey;
}The arguments for rotating the auth key.
+from
Account: Account The account to rotate the auth key for.
+to
New Private Key: PrivateKey The new private key to rotate to.
+
Returns Promise<TransactionResponse>
PendingTransactionResponse
+Example
+ +import { Aptos, AptosConfig, Network, Account, PrivateKey } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Rotate the authentication key for an account
const response = await aptos.rotateAuthKey({
// replace with a real account
fromAccount: Account.generate(),
// replace with a real private key
toNewPrivateKey: new PrivateKey("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"),
});
console.log(response);
}
runExample().catch(console.error); +- args: {
sign
- sign(args): AccountAuthenticator
Sign a transaction that can later be submitted to the chain. +This function is essential for ensuring the authenticity of the transaction by using the provided account's signing capabilities.
+Parameters
- args: {
signer: Account;
transaction: AnyRawTransaction;
}The arguments for signing the transaction.
+signer: Account
The account that will sign the transaction.
+transaction: AnyRawTransaction
A raw transaction to sign.
+
Returns AccountAuthenticator
AccountAuthenticator - The authenticator for the signed transaction.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const sender = Account.generate(); // Generate a new account for signing
const transaction = await aptos.transaction.build.simple({
sender: sender.accountAddress,
data: {
function: "0x1::aptos_account::transfer",
functionArguments: [ "0x1", 100 ], // replace with a real account address and amount
},
});
const signedTransaction = await aptos.transaction.sign({
signer: sender,
transaction,
}); // Sign the transaction
console.log("Signed Transaction:", signedTransaction);
}
runExample().catch(console.error); +- args: {
sign
- sign
And Submit As Fee Payer(args): Promise<PendingTransactionResponse> Sign and submit a single signer transaction as the fee payer to chain given an authenticator by the sender of the transaction.
+Parameters
- args: {
feePayer: Account;
senderAuthenticator: AccountAuthenticator;
transaction: AnyRawTransaction;
}fee
Payer: Account The fee payer account to sign the transaction
+sender
Authenticator: AccountAuthenticator The AccountAuthenticator signed by the sender of the transaction
+transaction: AnyRawTransaction
An instance of a RawTransaction, plus optional secondary/fee payer addresses
+
Returns Promise<PendingTransactionResponse>
PendingTransactionResponse
+Example
+ +const transaction = await aptos.transaction.build.simple({sender: alice.accountAddress, feePayer: true ...})
const senderAuthenticator = alice.signTransactionWithAuthenticator(transaction)
const pendingTransaction = await aptos.signAndSubmitAsFeePayer({
senderAuthenticator,
feePayer: bob,
transaction,
}) +- args: {
sign
- sign
And Submit Transaction(args): Promise<PendingTransactionResponse> Sign and submit a single signer transaction to the blockchain. +This function allows you to execute a transaction after signing it with the specified account.
+Parameters
- args: FeePayerOrFeePayerAuthenticatorOrNeither & {
signer: Account;
transaction: AnyRawTransaction;
}The arguments for signing and submitting the transaction.
+
Returns Promise<PendingTransactionResponse>
PendingTransactionResponse
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const sender = Account.generate(); // Generate a new account for sending the transaction
const transaction = await aptos.transaction.build.simple({
sender: sender.accountAddress,
data: {
function: "0x1::aptos_account::transfer",
functionArguments: [ "0x1", 100 ], // replace with a real account address
},
});
// Sign and submit the transaction
const pendingTransaction = await aptos.signAndSubmitTransaction({
signer: sender,
transaction,
});
console.log(pendingTransaction);
}
runExample().catch(console.error); +- args: FeePayerOrFeePayerAuthenticatorOrNeither & {
sign
- sign
As Fee Payer(args): AccountAuthenticator Sign a transaction as a fee payer that can later be submitted to the chain. +This function ensures that the transaction is marked with the fee payer's address, allowing it to be processed correctly.
+Parameters
- args: {
signer: Account;
transaction: AnyRawTransaction;
}The arguments for signing the transaction.
+signer: Account
The fee payer signer account.
+transaction: AnyRawTransaction
A raw transaction to sign on. This transaction must include a
+feePayerAddressproperty.
Returns AccountAuthenticator
AccountAuthenticator - The authenticator for the signed transaction.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
const sender = Account.generate(); // Generate a new account for the fee payer
const transaction = await aptos.transaction.build.simple({
// All transactions on Aptos are implemented via smart contracts.
function: "0x1::aptos_account::transfer",
functionArguments: [sender.accountAddress, 100],
feePayerAddress: sender.accountAddress, // Set the fee payer address
});
const signedTransaction = await aptos.transaction.signAsFeePayer({
signer: sender,
transaction,
});
console.log("Signed transaction as fee payer:", signedTransaction);
}
runExample().catch(console.error); +- args: {
wait
- wait
For Transaction(args): Promise<CommittedTransactionResponse> Waits for a transaction to move past the pending state and provides the transaction response. +There are 4 cases.
+-
+
- Transaction is successfully processed and committed to the chain.
+
-
+
- The function will resolve with the transaction response from the API. +
+ - Transaction is rejected for some reason, and is therefore not committed to the blockchain.
+
-
+
- The function will throw an AptosApiError with an HTTP status code indicating some problem with the request. +
+ - Transaction is committed but execution failed, meaning no changes were
+written to the blockchain state.
+
-
+
- If
checkSuccessis true, the function will throw a FailedTransactionError +IfcheckSuccessis false, the function will resolve with the transaction response where thesuccessfield is false.
+
+ - If
- Transaction does not move past the pending state within
args.options.timeoutSecsseconds. +-
+
- The function will throw a WaitForTransactionError +
+
Parameters
- args: {
options?: WaitForTransactionOptions;
transactionHash: HexInput;
}Optionaloptions?: WaitForTransactionOptionsOptional parameters for waiting behavior.
+transaction
Hash: HexInput The hash of a transaction previously submitted to the blockchain.
+
Returns Promise<CommittedTransactionResponse>
The transaction on-chain response.
+Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
async function runExample() {
// Wait for a transaction to complete using its hash
const transactionHash = "0x123"; // replace with a real transaction hash
const transactionResponse = await aptos.waitForTransaction({
transactionHash,
options: {
timeoutSecs: 30, // specify your own timeout if needed
checkSuccess: true,
},
});
console.log(transactionResponse);
}
runExample().catch(console.error); +- Transaction is successfully processed and committed to the chain.
+
Class TransactionManagement
Minimal EventEmitter interface that is molded against the Node.js
+EventEmitter interface.
Hierarchy (view full)
- EventEmitter<TransactionWorkerEvents>
- TransactionManagement
Index
Constructors
Methods
Properties
Constructors
constructor
- new
Transaction Management(config): TransactionManagement Initializes a new instance of the Aptos client with the provided configuration settings. +This allows you to interact with the Aptos blockchain using the specified network and options.
+Parameters
- config: AptosConfig
The configuration settings for the Aptos client.
+
Returns TransactionManagement
Example
+ +import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
async function runExample() {
// Create a configuration for the Aptos client
const config = new AptosConfig({
network: Network.TESTNET, // specify the network to use
nodeUrl: "https://testnet.aptos.dev" // replace with your node URL
});
// Initialize the Aptos client with the configuration
const aptos = new Aptos(config);
console.log("Aptos client initialized successfully.");
}
runExample().catch(console.error); +- config: AptosConfig
Methods
add
- add
Listener<T>(event, fn, context?): this Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
- fn: ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)
- (...args): void
Parameters
Rest...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]
Returns void
Optionalcontext: any
Returns this
emit
- emit<T>(event, ...args): boolean
Calls each of the listeners registered for a given event.
+Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
Rest...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]
Returns boolean
event
- event
Names(): (keyof TransactionWorkerEvents)[] Return an array listing the events for which the emitter has registered +listeners.
+Returns (keyof TransactionWorkerEvents)[]
for
- for
Single Account(args): void Send batch transactions for a single account.
+This function uses a transaction worker that receives payloads to be processed +and submitted to chain. +Note that this process is best for submitting multiple transactions that +don't rely on each other, i.e. batch funds, batch token mints, etc.
+If any worker failure, the functions throws an error.
+Parameters
- args: {
data: InputGenerateTransactionPayloadData[];
options?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">;
sender: Account;
}data: InputGenerateTransactionPayloadData[]
An array of transaction payloads
+Optionaloptions?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">optional. Transaction generation configurations (excluding accountSequenceNumber)
+sender: Account
The sender account to sign and submit the transaction
+
Returns void
void. Throws if any error
+- args: {
listener
- listener
Count(event): number Return the number of listeners listening to a given event.
+Parameters
- event: keyof TransactionWorkerEvents
Returns number
listeners
- listeners<T>(event): ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)[]
Return the listeners registered for a given event.
+Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
Returns ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)[]
off
- off<T>(event, fn?, context?, once?): this
Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
Optionalfn: ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)- (...args): void
Parameters
Rest...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]
Returns void
Optionalcontext: anyOptionalonce: boolean
Returns this
on
- on<T>(event, fn, context?): this
Add a listener for a given event.
+Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
- fn: ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)
- (...args): void
Parameters
Rest...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]
Returns void
Optionalcontext: any
Returns this
once
- once<T>(event, fn, context?): this
Add a one-time listener for a given event.
+Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
- fn: ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)
- (...args): void
Parameters
Rest...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]
Returns void
Optionalcontext: any
Returns this
remove
remove
- remove
Listener<T>(event, fn?, context?, once?): this Remove the listeners of a given event.
+Type Parameters
- T extends keyof TransactionWorkerEvents
Parameters
- event: T
Optionalfn: ((...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]) => void)- (...args): void
Parameters
Rest...args: ArgumentMap<TransactionWorkerEvents>[Extract<T, keyof TransactionWorkerEvents>]
Returns void
Optionalcontext: anyOptionalonce: boolean
Returns this
Enumeration AccountAuthenticatorVariant
Variants of account authenticators used in transactions. +https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs#L414
+ Index
Enumeration Members
Enumeration AddressInvalidReason
Provides reasons for an address was invalid.
+ Enumeration Members
INCORRECT_
INVALID_
INVALID_
INVALID_
LEADING_
LONG_
TOO_
TOO_
Enumeration AnyPublicKeyVariant
Variants of public keys used in cryptographic operations.
+ Index
Enumeration Members
Enumeration DeriveScheme
Specifies the schemes for deriving account addresses from various data sources.
+ Index
Enumeration Members
Derive
Derives an address using an AUID, used for objects
+Derive
Derives an address from a GUID, used for objects
+Derive
Derives an address from another object address
+Derive
Derives an address from seed bytes, used for named objects
+Derive
Derives an address from seed bytes, used for resource accounts
+Enumeration EphemeralCertificateVariant
Variants of ephemeral certificates used in secure transactions.
+ Index
Enumeration Members
Enumeration EphemeralPublicKeyVariant
Variants of ephemeral public keys used in cryptographic operations.
+ Index
Enumeration Members
Enumeration EphemeralSignatureVariant
Variants of ephemeral signatures used for secure communication.
+ Index
Enumeration Members
Enumeration HexInvalidReason
Provides reasons for parsing failures related to hexadecimal values.
+ Index
Enumeration Members
Enumeration KeyType
Supported key types and their associated seeds.
+ Index
Enumeration Members
Enumeration KeylessErrorCategory
Index
Enumeration Members
Enumeration KeylessErrorResolutionTip
Index
Enumeration Members
Enumeration KeylessErrorType
Index
Enumeration Members
Enumeration Members
ASYNC_
EPHEMERAL_
FULL_
FULL_
FULL_
FULL_
INVALID_
INVALID_
INVALID_
INVALID_
INVALID_
INVALID_
INVALID_
INVALID_
INVALID_
JWK_
JWK_
JWT_
PEPPER_
PEPPER_
PEPPER_
PROOF_
PROVER_
PROVER_
PROVER_
RATE_
UNKNOWN
Enumeration MimeType
Different MIME types used for data interchange in transactions and responses.
+ Index
Enumeration Members
Enumeration Members
BCS
BCS representation, used for accept type BCS output
+BCS_
BCS representation, used for transaction submission in BCS input
+BCS_
JSON
JSON representation, used for transaction submission and accept type JSON output
+Enumeration PrivateKeyVariants
Variants of private keys that can comply with the AIP-80 standard. +https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md
+Enumeration ProcessorType
Supported processor types for the indexer API, sourced from the processor_status table in the indexer database. +https://cloud.hasura.io/public/graphiql?endpoint=https://api.mainnet.aptoslabs.com/v1/graphql
+ Index
Enumeration Members
ACCOUNT_
DEFAULT
EVENTS_
FUNGIBLE_
OBJECT_
STAKE_
TOKEN_
USER_
Enumeration ScriptTransactionArgumentVariants
Variants of script transaction arguments used in Rust, encompassing various data types for transaction processing. +https://github.com/aptos-labs/aptos-core/blob/main/third_party/move/move-core/types/src/transaction_argument.rs#L11
+Enumeration SigningScheme
Different schemes for signing keys used in cryptographic operations.
+ Index
Enumeration Members
Enumeration SigningSchemeInput
Specifies the signing schemes available for cryptographic operations.
+ Index
Enumeration Members
Enumeration TransactionAuthenticatorVariant
Variants of transaction authenticators used in the system. +https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs#L44
+ Index
Enumeration Members
Enumeration TransactionPayloadVariants
The payload for various transaction types in the system. +https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L478
+ Index
Enumeration Members
Enumeration TransactionResponseType
Different types of transaction responses that can occur in the system.
+ Index
Enumeration Members
Enumeration TransactionVariants
Variants of transactions used in the system. +https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L440
+ Index
Enumeration Members
Enumeration TransactionWorkerEventsEnum
Events emitted by the transaction worker during its operation, allowing the dapp to respond to various transaction states.
+ Index
Enumeration Members
Enumeration TypeTagParserErrorType
Error types related to parsing type tags, indicating various issues encountered during the parsing process.
+ Index
Enumeration Members
Enumeration Members
Invalid
Invalid
Invalid
Invalid
Missing
Missing
Type
Unexpected
Unexpected
Unexpected
Unexpected
Unexpected
Unexpected
Unexpected
Enumeration TypeTagVariants
Variants of type tags used in the system, encompassing various data types and structures. +https://github.com/aptos-labs/aptos-core/blob/main/third_party/move/move-core/types/src/language_storage.rs#L27
+Enumeration ZkpVariant
Variants of zero-knowledge proofs used in cryptographic operations.
+ Index
Enumeration Members
Enumeration CurrentAptosNamesSelectColumn
select columns of table "current_aptos_names"
+ Index
Enumeration Members
Domain
column name
+Domain
column name
+Domain
column name
+Expiration
column name
+Is
column name
+Is
column name
+Last
column name
+Owner
column name
+Registered
column name
+Subdomain
column name
+Subdomain
column name
+Token
column name
+Token
column name
+Enumeration CurrentAptosNamesSelectColumnCurrentAptosNamesAggregateBoolExpBoolAndArgumentsColumns
select "current_aptos_names_aggregate_bool_exp_bool_and_arguments_columns" columns of table "current_aptos_names"
+Enumeration CurrentAptosNamesSelectColumnCurrentAptosNamesAggregateBoolExpBoolOrArgumentsColumns
select "current_aptos_names_aggregate_bool_exp_bool_or_arguments_columns" columns of table "current_aptos_names"
+Function CKDPriv
Derive a child key from the private key
+- CKDPriv(__namedParameters, index): DerivedKeys
Parameters
- __namedParameters: DerivedKeys
- index: number
Returns DerivedKeys
Function aptosRequest
- aptos
Request<Req, Res>(aptosRequestOpts, aptosConfig, apiType): Promise<AptosResponse<Req, Res>> The main function to use when making an API request, returning the response or throwing an AptosApiError on failure.
+Type Parameters
Parameters
- aptosRequestOpts: AptosRequest
Options for the Aptos request, including the URL and path.
+ - aptosConfig: AptosConfig
The configuration information for the SDK client instance.
+ - apiType: AptosApiType
The type of API being accessed, which determines how the response is handled.
+
Returns Promise<AptosResponse<Req, Res>>
The response from the API request or throws an AptosApiError if the request fails.
+- aptosRequestOpts: AptosRequest
Function base64UrlDecode
Function bigIntToBytesLE
- big
Int To BytesLE(value, length): Uint8Array Converts a bigint value into a little-endian byte array of a specified length. +This function is useful for representing large integers in a byte format, which is often required for cryptographic operations +or binary data manipulation.
+Parameters
- value: number | bigint
The number to convert into bytes.
+ - length: number
The desired length of the resulting byte array.
+
Returns Uint8Array
A Uint8Array containing the little-endian representation of the bigint value.
+- value: number | bigint
Function buildTransaction
Generates a transaction based on the provided arguments
+Note: we can start with one function to support all different payload/transaction types, +and if to complex to use, we could have function for each type
+- build
Transaction(args): Promise<SimpleTransaction> Generates a transaction based on the provided arguments. +This function can create both simple and multi-agent transactions, allowing for flexible transaction handling.
+Parameters
- args: InputGenerateSingleSignerRawTransactionArgs
The input arguments for generating the transaction.
+
Returns Promise<SimpleTransaction>
An instance of a transaction, which may include secondary signer addresses and a fee payer address.
+- args: InputGenerateSingleSignerRawTransactionArgs
- build
Transaction(args): Promise<MultiAgentTransaction> Parameters
Returns Promise<MultiAgentTransaction>
Function bytesToBigIntLE
- bytes
To Big IntLE(bytes): bigint Converts a little-endian byte array into a BigInt. +This function is useful for interpreting byte data as a numerical value in a way that respects the little-endian format.
+Parameters
- bytes: Uint8Array
The byte array to convert.
+
Returns bigint
The resulting BigInt representation of the byte array.
+- bytes: Uint8Array
Function checkOrConvertArgument
- check
Or Convert Argument(arg, param, position, genericTypeParams): EntryFunctionArgumentTypes Checks if the provided argument is BCS encoded and converts it if necessary, ensuring type compatibility with the ABI. +This function helps in validating and converting arguments for entry functions based on their expected types.
+Parameters
- arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes
The argument to check or convert, which can be either a simple or entry function argument type.
+ - param: TypeTag
The expected type tag for the argument.
+ - position: number
The position of the argument in the function call.
+ - genericTypeParams: TypeTag[]
An array of generic type parameters that may be used for conversion.
+
Returns EntryFunctionArgumentTypes
- arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes
Function convertAmountFromHumanReadableToOnChain
Amount is represented in the smallest unit format on chain, this function converts +a human-readable amount format to the smallest unit format
+Function convertAmountFromOnChainToHumanReadable
Amount is represented in the smallest unit format on chain, this function converts +the smallest unit format to a human-readable amount format
+Function convertArgument
- convert
Argument(functionName, functionAbi, arg, position, genericTypeParams): EntryFunctionArgumentTypes Converts a non-BCS encoded argument into BCS encoded, if necessary. +This function checks the provided argument against the expected parameter type and converts it accordingly.
+Parameters
- functionName: string
The name of the function for which the argument is being converted.
+ - functionAbi: FunctionABI
The ABI (Application Binary Interface) of the function, which defines its parameters.
+ - arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes
The argument to be converted, which can be of various types.
+ - position: number
The index of the argument in the function's parameter list.
+ - genericTypeParams: TypeTag[]
An array of type tags for any generic type parameters.
+
Returns EntryFunctionArgumentTypes
- functionName: string
Function convertNumber
- convert
Number(arg): number | undefined Converts a number or a string representation of a number into a number type. +This function is useful for ensuring that the input is in a consistent numeric format, +which can help prevent type mismatches in further processing.
+Parameters
- arg: SimpleEntryFunctionArgumentTypes
The input value to be converted. This can be a number, a string representing a number, or any other type.
+
Returns number | undefined
Returns the converted number if the input is valid; otherwise, it returns undefined.
+- arg: SimpleEntryFunctionArgumentTypes
Function createObjectAddress
Creates an object address from creator address and seed
+- create
Object Address(creatorAddress, seed): AccountAddress Parameters
- creatorAddress: AccountAddress
The object creator account address
+ - seed: string | Uint8Array
The seed in either Uint8Array | string type
+
Returns AccountAddress
The object account address
+- creatorAddress: AccountAddress
Function createResourceAddress
Creates a resource address from creator address and seed
+- create
Resource Address(creatorAddress, seed): AccountAddress Parameters
- creatorAddress: AccountAddress
The creator account address
+ - seed: string | Uint8Array
The seed in either Uint8Array | string type
+
Returns AccountAddress
The resource account address
+- creatorAddress: AccountAddress
Function createTokenAddress
Creates a token object address from creator address, collection name and token name
+- create
Token Address(creatorAddress, collectionName, tokenName): AccountAddress Parameters
- creatorAddress: AccountAddress
The token creator account address
+ - collectionName: string
The collection name
+ - tokenName: string
The token name
+
Returns AccountAddress
The token account address
+- creatorAddress: AccountAddress
Function deriveKey
- derive
Key(hashSeed, data): DerivedKeys Parameters
- hashSeed: string | Uint8Array
- data: string | Uint8Array
Returns DerivedKeys
Function deriveTransactionType
- derive
Transaction Type(transaction): AnyRawTransactionInstance Derives the appropriate raw transaction type based on the provided transaction details. +This function helps in identifying whether the transaction is a FeePayerRawTransaction, +MultiAgentRawTransaction, or a standard RawTransaction.
+Parameters
- transaction: AnyRawTransaction
An object representing an Aptos transaction, which may include:
+-
+
- feePayerAddress - The address of the fee payer (optional). +
- secondarySignerAddresses - An array of secondary signer addresses (optional). +
- rawTransaction - The raw transaction data. +
Returns AnyRawTransactionInstance
FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
+- transaction: AnyRawTransaction
Function deserializeFromScriptArgument
- deserialize
From Script Argument(deserializer): TransactionArgument Deserialize a Script Transaction Argument. +This function retrieves and deserializes various types of script transaction arguments based on the provided deserializer.
+Parameters
- deserializer: Deserializer
The deserializer used to read the script transaction argument.
+
Returns TransactionArgument
The deserialized script transaction argument.
+- deserializer: Deserializer
Function fetchEntryFunctionAbi
- fetch
Entry Function Abi(moduleAddress, moduleName, functionName, aptosConfig): Promise<EntryFunctionABI> Fetches the ABI for an entry function from the specified module address. +This function validates if the ABI corresponds to an entry function and retrieves its parameters.
+Parameters
- moduleAddress: string
The address of the module containing the entry function.
+ - moduleName: string
The name of the module containing the entry function.
+ - functionName: string
The name of the entry function to fetch the ABI for.
+ - aptosConfig: AptosConfig
The configuration settings for Aptos.
+
Returns Promise<EntryFunctionABI>
An object containing the number of signers, type parameters, and function parameters.
+- moduleAddress: string
Function fetchFunctionAbi
- fetch
Function Abi(moduleAddress, moduleName, functionName, aptosConfig): Promise<MoveFunction | undefined> Fetches the ABI of a specified function from the on-chain module ABI. This function allows you to access the details of a +specific function within a module.
+Parameters
- moduleAddress: string
The address of the module from which to fetch the function ABI.
+ - moduleName: string
The name of the module containing the function.
+ - functionName: string
The name of the function whose ABI is to be fetched.
+ - aptosConfig: AptosConfig
The configuration settings for Aptos.
+
Returns Promise<MoveFunction | undefined>
- moduleAddress: string
Function fetchViewFunctionAbi
- fetch
View Function Abi(moduleAddress, moduleName, functionName, aptosConfig): Promise<ViewFunctionABI> Fetches the ABI for a view function from the specified module address. +This function ensures that the ABI is valid and retrieves the type parameters, parameters, and return types for the view function.
+Parameters
- moduleAddress: string
The address of the module containing the view function.
+ - moduleName: string
The name of the module containing the view function.
+ - functionName: string
The name of the view function for which to fetch the ABI.
+ - aptosConfig: AptosConfig
The configuration settings for Aptos.
+
Returns Promise<ViewFunctionABI>
An object containing the type parameters, parameters, and return types of the view function.
+- moduleAddress: string
Function findFirstNonSignerArg
- find
First Non Signer Arg(functionAbi): number Finds the index of the first non-signer argument in the function ABI parameters.
+A function is often defined with a
+signeror&signerarguments at the start, which are filled in +by signatures and not by the caller. This function helps identify the position of the first argument that +can be provided by the caller, allowing for easier handling of function parameters.Parameters
- functionAbi: MoveFunction
The ABI of the function to analyze.
+
Returns number
The index of the first non-signer argument, or the length of the parameters array if none are found.
+- functionAbi: MoveFunction
Function generateRawTransaction
- generate
Raw Transaction(args): Promise<RawTransaction> Generates a raw transaction that can be sent to the Aptos network.
+Parameters
- args: {
aptosConfig: AptosConfig;
feePayerAddress?: AccountAddressInput;
options?: InputGenerateTransactionOptions;
payload: AnyTransactionPayloadInstance;
sender: AccountAddressInput;
}The arguments for generating the raw transaction.
+aptos
Config: AptosConfig The configuration for the Aptos network.
+OptionalfeePayer Address?: AccountAddressInput The address of the fee payer for sponsored transactions.
+Optionaloptions?: InputGenerateTransactionOptionsOptional parameters for transaction generation.
+payload: AnyTransactionPayloadInstance
The transaction payload, which can be created using generateTransactionPayload().
+sender: AccountAddressInput
The transaction's sender account address as a hex input.
+
Returns Promise<RawTransaction>
RawTransaction - The generated raw transaction.
+- args: {
Function generateSignedTransaction
- generate
Signed Transaction(args): Uint8Array Generate a signed transaction ready for submission to the blockchain. +This function prepares the transaction by authenticating the sender and any additional signers based on the provided arguments.
+Parameters
- args: InputSubmitTransactionData
The input data required to generate the signed transaction.
+
Returns Uint8Array
A Uint8Array representing the signed transaction in bytes.
+- args: InputSubmitTransactionData
Function generateSignedTransactionForSimulation
- generate
Signed Transaction For Simulation(args): Uint8Array Generate a signed transaction for simulation before submitting it to the chain. +This function helps in preparing a transaction that can be simulated, allowing users to verify its validity and expected behavior.
+Parameters
- args: InputSimulateTransactionData
The input data required to generate the signed transaction for simulation.
+
Returns Uint8Array
A signed serialized transaction that can be simulated.
+- args: InputSimulateTransactionData
Function generateSigningMessage
- generate
Signing Message(bytes, domainSeparator): Uint8Array Generates the 'signing message' form of a message to be signed. +This function combines a domain separator with the byte representation of the message to create a signing message.
+Parameters
- bytes: Uint8Array
The byte representation of the message to be signed and sent to the chain.
+ - domainSeparator: string
A domain separator that starts with 'APTOS::'.
+
Returns Uint8Array
The Uint8Array of the signing message.
+- bytes: Uint8Array
Function generateSigningMessageForSerializable
- generate
Signing Message For Serializable(serializable): Uint8Array Parameters
- serializable: Serializable
An object that has a BCS serialized form.
+
Returns Uint8Array
The Uint8Array of the signing message.
+- serializable: Serializable
Function generateSigningMessageForTransaction
- generate
Signing Message For Transaction(transaction): Uint8Array Generates the 'signing message' form of a transaction by deriving the type of transaction and applying the appropriate domain +separator based on the presence of a fee payer or secondary signers.
+Parameters
- transaction: AnyRawTransaction
A transaction that is to be signed, which can include a fee payer address or secondary signer addresses.
+
Returns Uint8Array
The Uint8Array of the signing message.
+- transaction: AnyRawTransaction
Function generateTransactionPayload
Builds a transaction payload based on the data argument and returns +a transaction payload - TransactionPayloadScript | TransactionPayloadMultiSig | TransactionPayloadEntryFunction
+This uses the RemoteABI by default, and the remote ABI can be skipped by using generateTransactionPayloadWithABI
+- generate
Transaction Payload(args): Promise<TransactionPayloadScript> Builds a transaction payload based on the provided arguments and returns a transaction payload. +This function uses the RemoteABI by default, but can also utilize a specified ABI. +When we call our
+generateTransactionPayloadfunction with the relevant type properties, +Typescript can infer the return type based on the appropriate function overload.Parameters
- args: InputScriptData
The input data for generating the transaction payload.
+
Returns Promise<TransactionPayloadScript>
TransactionPayload - The generated transaction payload, which can be of type TransactionPayloadScript, +TransactionPayloadMultiSig, or TransactionPayloadEntryFunction.
+- args: InputScriptData
- generate
Transaction Payload(args): Promise<TransactionPayloadEntryFunction> Parameters
Returns Promise<TransactionPayloadEntryFunction>
- generate
Transaction Payload(args): Promise<TransactionPayloadMultiSig> Parameters
Returns Promise<TransactionPayloadMultiSig>
Function generateTransactionPayloadWithABI
- generate
Transaction Payload WithABI(args): TransactionPayloadEntryFunction Generates a transaction payload using the provided ABI and function details. +This function helps create a properly structured transaction payload for executing a specific function on a module.
+Parameters
- args: InputEntryFunctionDataWithABI
The input data required to generate the transaction payload.
+
Returns TransactionPayloadEntryFunction
- args: InputEntryFunctionDataWithABI
- generate
Transaction Payload WithABI(args): TransactionPayloadMultiSig Parameters
- args: InputMultiSigDataWithABI
Returns TransactionPayloadMultiSig
Function generateUserTransactionHash
- generate
User Transaction Hash(args): string Generates a user transaction hash for the provided transaction payload, which must already have an authenticator. +This function helps ensure the integrity and uniqueness of the transaction by producing a hash based on the signed transaction data.
+Parameters
- args: InputSubmitTransactionData
The input data required to submit the transaction.
+
Returns string
- args: InputSubmitTransactionData
Function generateViewFunctionPayload
- generate
View Function Payload(args): Promise<EntryFunction> Generates the payload for a view function call using the provided arguments. +This function helps in preparing the necessary data to interact with a specific view function on the blockchain.
+Parameters
- args: InputViewFunctionDataWithRemoteABI
The input data required to generate the view function payload.
+
Returns Promise<EntryFunction>
The generated payload for the view function call.
+- args: InputViewFunctionDataWithRemoteABI
Function generateViewFunctionPayloadWithABI
- generate
View Function Payload WithABI(args): EntryFunction Generates a payload for a view function call using the provided ABI and arguments. +This function ensures that the type arguments and function arguments are correctly formatted +and match the expected counts as defined in the ABI.
+Parameters
- args: InputViewFunctionDataWithABI
The input data for generating the view function payload.
+
Returns EntryFunction
- args: InputViewFunctionDataWithABI
Function get
- get<Req, Res>(options): Promise<AptosResponse<Req, Res>>
Executes a GET request to retrieve data based on the provided options.
+Type Parameters
Parameters
- options: GetRequestOptions
The options for the GET request.
+
Returns Promise<AptosResponse<Req, Res>>
The response from the GET request.
+- options: GetRequestOptions
Function getAptosFullNode
- get
Aptos Full Node<Req, Res>(options): Promise<AptosResponse<Req, Res>> Retrieves data from the Aptos full node using the provided options.
+Type Parameters
Parameters
- options: GetAptosRequestOptions
The options for the request to the Aptos full node.
+
Returns Promise<AptosResponse<Req, Res>>
A promise that resolves with the response from the Aptos full node.
+- options: GetAptosRequestOptions
Function getAptosPepperService
- get
Aptos Pepper Service<Req, Res>(options): Promise<AptosResponse<Req, Res>> Makes a GET request to the Aptos Pepper service to retrieve data.
+Type Parameters
Parameters
- options: GetAptosRequestOptions
The options for the request.
+
Returns Promise<AptosResponse<Req, Res>>
AptosResponse - The response from the Aptos Pepper service.
+- options: GetAptosRequestOptions
Function getAuthenticatorForSimulation
- get
Authenticator For Simulation(publicKey): AccountAuthenticatorEd25519 | AccountAuthenticatorSingleKey | AccountAuthenticatorMultiKey Parameters
- publicKey: PublicKey
Returns AccountAuthenticatorEd25519 | AccountAuthenticatorSingleKey | AccountAuthenticatorMultiKey
Function getFunctionParts
- get
Function Parts(functionArg): {
functionName: string;
moduleAddress: string;
moduleName: string;
} Splits a function identifier into its constituent parts: module address, module name, and function name. +This function helps in validating and extracting details from a function identifier string.
+Parameters
- functionArg: `${string}::${string}::${string}`
The function identifier string in the format "moduleAddress::moduleName::functionName".
+
Returns {
functionName: string;
moduleAddress: string;
moduleName: string;
}An object containing the module address, module name, and function name.
+function
Name: string module
Address: string module
Name: string
- functionArg: `${string}::${string}::${string}`
Function getIssAudAndUidVal
- get
Iss Aud And Uid Val(args): {
aud: string;
iss: string;
uidVal: string;
} Parses a JWT and returns the 'iss', 'aud', and 'uid' values.
+Parameters
- args: {
jwt: string;
uidKey?: string;
}The arguments for parsing the JWT.
+jwt: string
The JWT to parse.
+OptionaluidKey?: string The key to use for the 'uid' value; defaults to 'sub'.
+
Returns {
aud: string;
iss: string;
uidVal: string;
}The 'iss', 'aud', and 'uid' values from the JWT.
+aud: string
iss: string
uid
Val: string
- args: {
Function getKeylessConfig
- get
Keyless Config(args): Promise<KeylessConfiguration> Retrieves the configuration parameters for Keyless Accounts on the blockchain, including the verifying key and the maximum +expiry horizon.
+Parameters
- args: {
aptosConfig: AptosConfig;
options?: LedgerVersionArg;
}The arguments for retrieving the keyless configuration.
+aptos
Config: AptosConfig The Aptos configuration object containing network details.
+Optionaloptions?: LedgerVersionArgOptional parameters for the request.
+
Returns Promise<KeylessConfiguration>
KeylessConfiguration - The configuration object containing the verifying key and maximum expiry horizon.
+- args: {
Function getKeylessJWKs
- get
KeylessJWKs(args): Promise<Map<string, MoveJWK[]>> Parameters
- args: {
aptosConfig: AptosConfig;
jwkAddr?: AccountAddressInput;
options?: LedgerVersionArg;
}aptos
Config: AptosConfig OptionaljwkAddr?: AccountAddressInput Optionaloptions?: LedgerVersionArg
Returns Promise<Map<string, MoveJWK[]>>
- args: {
Function hashStrToField
- hash
Str To Field(str, maxSizeBytes): bigint Hashes a string to a field element via Poseidon hashing. +This function is useful for converting a string into a fixed-size hash that can be used in cryptographic applications.
+Parameters
- str: string
The string to be hashed.
+ - maxSizeBytes: number
The maximum size in bytes for the resulting hash.
+
Returns bigint
bigint - The result of the hash.
+- str: string
Function isBcsAddress
- is
Bcs Address(arg): arg is AccountAddress Parameters
Returns arg is AccountAddress
Function isBcsFixedBytes
- is
Bcs Fixed Bytes(arg): arg is FixedBytes Parameters
Returns arg is FixedBytes
Function isBcsString
- is
Bcs String(arg): arg is MoveString Parameters
Returns arg is MoveString
Function isBlockEpilogueTransactionResponse
- is
Block Epilogue Transaction Response(response): response is BlockEpilogueTransactionResponse Determines if the given transaction response is of the type Block Epilogue.
+Parameters
- response: TransactionResponse
The transaction response to evaluate.
+
Returns response is BlockEpilogueTransactionResponse
A boolean indicating whether the response is a Block Epilogue transaction.
+- response: TransactionResponse
Function isBlockMetadataTransactionResponse
- is
Block Metadata Transaction Response(response): response is BlockMetadataTransactionResponse Determine if the given transaction response is of type BlockMetadata.
+Parameters
- response: TransactionResponse
The transaction response to evaluate.
+
Returns response is BlockMetadataTransactionResponse
A boolean indicating whether the response is a BlockMetadata transaction.
+- response: TransactionResponse
Function isBool
- is
Bool(arg): arg is boolean Determines if the provided argument is of type boolean. +This can help in validating input types before processing them further.
+Parameters
- arg: SimpleEntryFunctionArgumentTypes
The argument to check, which can be of various types.
+
Returns arg is boolean
A boolean indicating whether the argument is a boolean.
+- arg: SimpleEntryFunctionArgumentTypes
Function isCanonicalEd25519Signature
- is
Canonical Ed25519 Signature(signature): boolean Checks if an ED25519 signature is non-canonical. +This function helps determine the validity of a signature by verifying its canonical form.
+Parameters
- signature: Signature
The signature to be checked for canonicality.
+
Returns boolean
A boolean indicating whether the signature is non-canonical.
+Comes from Aptos Core +https://github.com/aptos-labs/aptos-core/blob/main/crates/aptos-crypto/src/ed25519/ed25519_sigs.rs#L47-L85
+- signature: Signature
Function isEd25519Signature
- is
Ed25519 Signature(signature): signature is TransactionFeePayerSignature Determine if the provided signature is an Ed25519 signature. +This function checks for the presence of the "signature" property +and verifies that its value is "ed25519_signature".
+Parameters
- signature: TransactionSignature
The transaction signature to be checked.
+
Returns signature is TransactionFeePayerSignature
A boolean indicating whether the signature is an Ed25519 signature.
+- signature: TransactionSignature
Function isEmptyOption
- is
Empty Option(arg): arg is undefined | null Checks if the provided argument is empty, meaning it is either null or undefined.
+Parameters
- arg: SimpleEntryFunctionArgumentTypes
The argument to check for emptiness.
+
Returns arg is undefined | null
A boolean indicating whether the argument is empty.
+- arg: SimpleEntryFunctionArgumentTypes
Function isEncodedEntryFunctionArgument
- is
Encoded Entry Function Argument(arg): arg is EntryFunctionArgumentTypes Determines if the provided argument is a valid encoded entry function argument type. +This function helps validate that the argument conforms to the expected types for entry function parameters.
+Parameters
- arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes
The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+
Returns arg is EntryFunctionArgumentTypes
- arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes
Function isEncodedStruct
Determines whether the given object is an encoded struct type with the following properties:
+-
+
- account_address: string +
- module_name: string +
- struct_name: string +
Function isFeePayerSignature
- is
Fee Payer Signature(signature): signature is TransactionFeePayerSignature Determine if the provided signature is a fee payer signature.
+Parameters
- signature: TransactionSignature
The transaction signature to evaluate.
+
Returns signature is TransactionFeePayerSignature
A boolean indicating whether the signature is a fee payer signature.
+- signature: TransactionSignature
Function isGenesisTransactionResponse
- is
Genesis Transaction Response(response): response is GenesisTransactionResponse Determines if the given transaction response is a Genesis transaction.
+Parameters
- response: TransactionResponse
The transaction response to evaluate.
+
Returns response is GenesisTransactionResponse
A boolean indicating whether the transaction is a Genesis transaction.
+- response: TransactionResponse
Function isKeylessSigner
- is
Keyless Signer(obj): obj is KeylessSigner Parameters
- obj: any
Returns obj is KeylessSigner
Function isLargeNumber
- is
Large Number(arg): arg is string | number | bigint Determines if the provided argument is a large number, which can be a number, bigint, or string representation of a number.
+Parameters
- arg: SimpleEntryFunctionArgumentTypes
The argument to check, which can be of type number, bigint, or string.
+
Returns arg is string | number | bigint
- arg: SimpleEntryFunctionArgumentTypes
Function isMultiAgentSignature
- is
Multi Agent Signature(signature): signature is TransactionMultiAgentSignature Determine if the provided transaction signature is a multi-agent signature.
+Parameters
- signature: TransactionSignature
The transaction signature to evaluate.
+
Returns signature is TransactionMultiAgentSignature
A boolean indicating whether the signature is a multi-agent signature.
+- signature: TransactionSignature
Function isMultiEd25519Signature
- is
Multi Ed25519 Signature(signature): signature is TransactionMultiEd25519Signature Determine if the provided signature is of type "multi_ed25519_signature".
+Parameters
- signature: TransactionSignature
The transaction signature to check.
+
Returns signature is TransactionMultiEd25519Signature
A boolean indicating whether the signature is a multi-ed25519 signature.
+- signature: TransactionSignature
Function isNumber
- is
Number(arg): arg is number Determines if the provided argument is of type number.
+Parameters
- arg: SimpleEntryFunctionArgumentTypes
The argument to check, which can be of various types.
+
Returns arg is number
A boolean indicating whether the argument is a number.
+- arg: SimpleEntryFunctionArgumentTypes
Function isPendingTransactionResponse
- is
Pending Transaction Response(response): response is PendingTransactionResponse Determine if the given transaction response is currently pending.
+Parameters
- response: TransactionResponse
The transaction response to evaluate.
+
Returns response is PendingTransactionResponse
A boolean indicating whether the transaction is pending.
+- response: TransactionResponse
Function isScriptDataInput
- is
Script Data Input(arg): arg is InputScriptData Determines if the provided argument contains script data input by checking for the presence of bytecode.
+Parameters
- arg:
| InputEntryFunctionData
| InputScriptData
| InputMultiSigData
| InputEntryFunctionDataWithRemoteABI
| InputMultiSigDataWithRemoteABIThe input data to be checked, which can either be a payload with remote ABI or a standard payload.
+
Returns arg is InputScriptData
- arg:
Function isSecp256k1Signature
- is
Secp256k1 Signature(signature): signature is TransactionFeePayerSignature Determine if the provided signature is a valid secp256k1 ECDSA signature.
+Parameters
- signature: TransactionSignature
The transaction signature to validate.
+
Returns signature is TransactionFeePayerSignature
A boolean indicating whether the signature is a secp256k1 ECDSA signature.
+- signature: TransactionSignature
Function isStateCheckpointTransactionResponse
- is
State Checkpoint Transaction Response(response): response is StateCheckpointTransactionResponse Determines if the provided transaction response is a state checkpoint transaction.
+Parameters
- response: TransactionResponse
The transaction response to evaluate.
+
Returns response is StateCheckpointTransactionResponse
A boolean indicating whether the transaction response is of type StateCheckpoint.
+- response: TransactionResponse
Function isUserTransactionResponse
- is
User Transaction Response(response): response is UserTransactionResponse Determines if the given transaction response is a user transaction.
+Parameters
- response: TransactionResponse
The transaction response to evaluate.
+
Returns response is UserTransactionResponse
A boolean indicating whether the transaction is of type User.
+- response: TransactionResponse
Function isValidBIP44Path
- is
ValidBIP44 Path(path): boolean Validate a BIP-44 derivation path string to ensure it meets the required format. +This function checks if the provided path adheres to the BIP-44 standard for Secp256k1. +Parse and validate a path that is compliant to BIP-44 in form m/44'/637'/{account_index}'/{change_index}/{address_index} +for Secp256k1
+Note that for Secp256k1, the last two components must be non-hardened.
+Parameters
- path: string
The path string to validate (e.g.
+m/44'/637'/0'/0/0).
Returns boolean
- path: string
Function isValidHardenedPath
- is
Valid Hardened Path(path): boolean Aptos derive path is 637
+Parse and validate a path that is compliant to SLIP-0010 and BIP-44 +in form m/44'/637'/{account_index}'/{change_index}'/{address_index}'. +See SLIP-0010 https://github.com/satoshilabs/slips/blob/master/slip-0044.md +See BIP-44 https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki
+Note that for Ed25519, all components must be hardened. +This is because non-hardened [PK] derivation would not work due to Ed25519's lack of a key homomorphism. +Specifically, you cannot derive the PK associated with derivation path a/b/c given the PK of a/b. +This is because the PK in Ed25519 is, more or less, computed as 𝑔𝐻(𝑠𝑘), +with the hash function breaking the homomorphism.
+Parameters
- path: string
The derivation path string to validate (e.g.
+m/44'/637'/0'/0'/0').
Returns boolean
- path: string
Function isValidatorTransactionResponse
- is
Validator Transaction Response(response): response is ValidatorTransactionResponse Determine if the given transaction response is of type Validator.
+Parameters
- response: TransactionResponse
The transaction response to evaluate.
+
Returns response is ValidatorTransactionResponse
A boolean indicating whether the transaction response is a Validator type.
+- response: TransactionResponse
Function normalizeBundle
- normalize
Bundle<T>(cls, value): T Normalizes an instance of a class by deserializing it from its byte representation. +This function allows the
+instanceofoperator to work correctly when the input objects originate from a different bundle.Type Parameters
- T extends Serializable
Parameters
- cls: DeserializableClass<T>
The class of the object to normalize.
+ - value: T
The instance to normalize.
+
Returns T
Function objectStructTag
- object
Struct Tag(typeArg): StructTag Creates a new StructTag for the Object type with the specified type argument. +This function helps in defining a structured representation of an Object with a specific type.
+Parameters
- typeArg: TypeTag
The type tag that specifies the type of the Object.
+
Returns StructTag
- typeArg: TypeTag
Function optionStructTag
- option
Struct Tag(typeArg): StructTag Creates a new StructTag for the Option type with the specified type argument. +This can help in defining a specific instance of an Option type in your application.
+Parameters
- typeArg: TypeTag
The type tag that specifies the type of the value contained in the Option.
+
Returns StructTag
- typeArg: TypeTag
Function padAndPackBytesWithLen
- pad
And Pack Bytes With Len(bytes, maxSizeBytes): bigint[] Pads and packs the given byte array to a specified maximum size and appends its length. +This function ensures that the byte array does not exceed the maximum size, throwing an error if it does. +It is useful for preparing byte data for further processing or transmission by ensuring a consistent format.
+Parameters
- bytes: Uint8Array
The byte array to be padded and packed.
+ - maxSizeBytes: number
The maximum allowed size for the byte array.
+
Returns bigint[]
A new Uint8Array that contains the padded and packed bytes along with the length of the original byte array.
+- bytes: Uint8Array
Function parseEncodedStruct
Convert an encoded struct to a MoveStructId.
+- parse
Encoded Struct(structObj): `${string}::${string}::${string}` Parameters
- structObj: {
account_address: string;
module_name: string;
struct_name: string;
}The struct with account_address, module_name, and struct_name properties
+account_
address: string module_
name: string struct_
name: string
Returns `${string}::${string}::${string}`
The MoveStructId
+- structObj: {
Function parseTypeTag
- parse
Type Tag(typeStr, options?): TypeTag Parses a type string into a structured representation of type tags, accommodating various formats including generics and +nested types.
+This function can help you accurately interpret type strings, which can include simple types, standalone structs, and complex +nested generics. +It supports multiple generics, spacing within generics, and nested generics of varying depths. +All types are made of a few parts they're either:
+-
+
- A simple type e.g. u8 +
- A standalone struct e.g. 0x1::account::Account +
- A nested struct e.g. 0x1::coin::Coin<0x1234::coin::MyCoin> +
There are a few more special cases that need to be handled, however.
+-
+
- Multiple generics e.g. 0x1::pair::Pair<u8, u16> +
- Spacing in the generics e.g. 0x1::pair::Pair< u8 , u16> +
- Nested generics of different depths e.g. 0x1::pair::Pair<0x1::coin::Coin<0x1234::coin::MyCoin>, u8> +
- Generics for types in ABIs are filled in with placeholders e.g. T1, T2, T3 +
Parameters
- typeStr: string
The string representation of the type to be parsed.
+ Optionaloptions: {
allowGenerics?: boolean;
}Optional settings for parsing behavior.
+OptionalallowGenerics?: boolean A flag indicating whether to allow generics in the parsing process.
+
Returns TypeTag
The parsed type tag representation.
+
Function poseidonHash
- poseidon
Hash(inputs): bigint Hashes up to 16 scalar elements via the Poseidon hashing algorithm. +Each element must be scalar fields of the BN254 elliptic curve group.
+Parameters
- inputs: (string | number | bigint)[]
An array of elements to be hashed, which can be of type number, bigint, or string.
+
Returns bigint
bigint - The result of the hash.
+- inputs: (string | number | bigint)[]
Function post
- post<Req, Res>(options): Promise<AptosResponse<Req, Res>>
Executes a POST request to the specified URL with the provided options.
+Type Parameters
Parameters
- options: PostRequestOptions
The options for the POST request.
+
Returns Promise<AptosResponse<Req, Res>>
The response from the POST request.
+- options: PostRequestOptions
Function postAptosFaucet
- post
Aptos Faucet<Req, Res>(options): Promise<AptosResponse<Req, Res>> Sends a request to the Aptos faucet to obtain test tokens. +This function modifies the provided configuration to ensure that the API_KEY is not included in the request.
+Type Parameters
Parameters
- options: PostAptosRequestOptions
The options for the request.
+
Returns Promise<AptosResponse<Req, Res>>
- options: PostAptosRequestOptions
Function postAptosFullNode
- post
Aptos Full Node<Req, Res>(options): Promise<AptosResponse<Req, Res>> Sends a request to the Aptos full node using the specified options. +This function allows you to interact with the Aptos blockchain by sending requests to the full node.
+Type Parameters
Parameters
- options: PostAptosRequestOptions
The options for the request.
+
Returns Promise<AptosResponse<Req, Res>>
- options: PostAptosRequestOptions
Function postAptosIndexer
- post
Aptos Indexer<Req, Res>(options): Promise<AptosResponse<Req, Res>> Sends a request to the Aptos indexer with the specified options. +This function allows you to interact with the Aptos indexer and customize the request using various configurations.
+Type Parameters
Parameters
- options: PostAptosRequestOptions
The options for the request to the Aptos indexer.
+
Returns Promise<AptosResponse<Req, Res>>
- options: PostAptosRequestOptions
Function postAptosPepperService
- post
Aptos Pepper Service<Req, Res>(options): Promise<AptosResponse<Req, Res>> Makes a post request to the pepper service.
+Type Parameters
Parameters
- options: PostAptosRequestOptions
The options for the request.
+
Returns Promise<AptosResponse<Req, Res>>
A promise that resolves to the response from the pepper service.
+- options: PostAptosRequestOptions
Function postAptosProvingService
- post
Aptos Proving Service<Req, Res>(options): Promise<AptosResponse<Req, Res>> Sends a request to the Aptos proving service with the specified options.
+Type Parameters
Parameters
- options: PostAptosRequestOptions
The options for the request to the Aptos proving service.
+
Returns Promise<AptosResponse<Req, Res>>
- options: PostAptosRequestOptions
Function request
- request<Req, Res>(options, client): Promise<ClientResponse<Res>>
Sends a request using the specified options and returns the response.
+Type Parameters
Parameters
- options: ClientRequest<Req>
The options for the request.
+ - client: Client
The client used to make the request.
+
Returns Promise<ClientResponse<Res>>
The response from the request.
+- options: ClientRequest<Req>
Function standardizeTypeTags
- standardize
Type Tags(typeArguments?): TypeTag[] Convert type arguments to only type tags, allowing for string representations of type tags.
+Parameters
OptionaltypeArguments: TypeArgument[]An optional array of type arguments that may include string representations.
+
Returns TypeTag[]
An array of TypeTag objects derived from the provided type arguments.
+
Function throwTypeMismatch
- throw
Type Mismatch(expectedType, position): void Throws an error indicating a type mismatch for a specified argument position. +This function helps in debugging by providing clear feedback on expected types.
+Parameters
- expectedType: string
The type that was expected for the argument.
+ - position: number
The position of the argument that caused the type mismatch.
+
Returns void
- expectedType: string
@aptos-labs/ts-sdk - v1.32.1
Class Hierarchy
- Serializable
- EphemeralKeyPair
- AbstractKeylessAccount
- TransactionAndProof
- EntryFunctionBytes
- FixedBytes
- Bool
- U8
- U16
- U32
- U64
- U128
- U256
- MoveVector
- Serialized
- MoveString
- MoveOption
- AccountAddress
- AuthenticationKey
- Ed25519PrivateKey
- ZkProof
- MoveJWK
- PublicKey
- Secp256k1PrivateKey
- Signature
- AccountAuthenticator
- TransactionAuthenticator
- ChainId
- Identifier
- ModuleId
- RawTransaction
- RawTransactionWithData
- RotationProofChallenge
- SignedTransaction
- TransactionPayload
- MultiSigTransactionPayload
- SimpleTransaction
- MultiAgentTransaction
- TypeTag
- StructTag
- Proof
- G1Bytes
- G2Bytes
- EphemeralKeyPair
@aptos-labs/ts-sdk - v1.32.1
Typescript SDK for Aptos
+
The TypeScript SDK allows you to connect, explore, and interact on the Aptos blockchain. You can use it to request data, send transactions, set up test environments, and more!
+Learn How To Use The TypeScript SDK
Quickstart
Tutorials
Examples
Reference Docs (For looking up specific functions)
Installation
For use in Node.js or a web application
Install with your favorite package manager such as npm, yarn, or pnpm:
+pnpm install @aptos-labs/ts-sdk
+For use in a browser (<= 1.9.1 version only)
You can add the SDK to your web application using a script tag:
+<script src="https://unpkg.com/@aptos-labs/ts-sdk/dist/browser/index.global.js" />
+Then, the SDK can be accessed through window.aptosSDK.
Usage
Create an Aptos client in order to access the SDK's functionality.
import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk"
// You can use AptosConfig to choose which network to connect to
const config = new AptosConfig({ network: Network.TESTNET });
// Aptos is the main entrypoint for all functions
const aptos = new Aptos(config);
+Reading Data From Onchain (Guide)
+
const fund = await aptos.getAccountInfo({ accountAddress: "0x123" });
const modules = await aptos.getAccountModules({ accountAddress: "0x123" });
const tokens = await aptos.getAccountOwnedTokens({ accountAddress: "0x123" });
+Account management (default to Ed25519)
++Note: We introduce a Single Sender authentication (as introduced in AIP-55). Generating an account defaults to Legacy Ed25519 authentication with the option to use the Single Sender unified authentication.
+
+
Generate new keys
const account = Account.generate(); // defaults to Legacy Ed25519
const account = Account.generate({ scheme: SigningSchemeInput.Secp256k1Ecdsa }); // Single Sender Secp256k1
const account = Account.generate({ scheme: SigningSchemeInput.Ed25519, legacy: false }); // Single Sender Ed25519
+Derive from private key
// Create a private key instance for Ed25519 scheme
const privateKey = new Ed25519PrivateKey("myEd25519privatekeystring");
// Or for Secp256k1 scheme
const privateKey = new Secp256k1PrivateKey("mySecp256k1privatekeystring");
// Derive an account from private key
// This is used as a local calculation and therefore is used to instantiate an `Account`
// that has not had its authentication key rotated
const account = await Account.fromPrivateKey({ privateKey });
// Also, can use this function that resolves the provided private key type and derives the public key from it
// to support key rotation and differentiation between Legacy Ed25519 and Unified authentications
// Read more https://github.com/aptos-labs/aptos-ts-sdk/blob/main/src/api/account.ts#L364
const aptos = new Aptos();
const account = await aptos.deriveAccountFromPrivateKey({ privateKey });
+Derive from private key and address
// Create a private key instance for Ed25519 scheme
const privateKey = new Ed25519PrivateKey("myEd25519privatekeystring");
// Or for Secp256k1 scheme
const privateKey = new Secp256k1PrivateKey("mySecp256k1privatekeystring");
// Derive an account from private key and address
// create an AccountAddress instance from the account address string
const address = AccountAddress.from("myaccountaddressstring");
// Derieve an account from private key and address
const account = await Account.fromPrivateKeyAndAddress({ privateKey, address });
+Derive from path
const path = "m/44'/637'/0'/0'/1";
const mnemonic = "various float stumble...";
const account = Account.fromDerivationPath({ path, mnemonic });
+Submit transaction (Tutorial)
+
/**
* This example shows how to use the Aptos SDK to send a transaction.
* Don't forget to install @aptos-labs/ts-sdk before running this example!
*/
import {
Account,
Aptos,
AptosConfig,
Network,
} from "@aptos-labs/ts-sdk";
async function example() {
console.log("This example will create two accounts (Alice and Bob) and send a transaction transfering APT to Bob's account.");
// 0. Setup the client and test accounts
const config = new AptosConfig({ network: Network.TESTNET });
const aptos = new Aptos(config);
let alice = Account.generate();
let bob = Account.generate();
console.log("=== Addresses ===\n");
console.log(`Alice's address is: ${alice.accountAddress}`);
console.log(`Bob's address is: ${bob.accountAddress}`);
console.log("\n=== Funding accounts ===\n");
await aptos.fundAccount({
accountAddress: alice.accountAddress,
amount: 100_000_000,
});
await aptos.fundAccount({
accountAddress: bob.accountAddress,
amount: 100,
});
console.log("Funded Alice and Bob's accounts!")
// 1. Build
console.log("\n=== 1. Building the transaction ===\n");
const transaction = await aptos.transaction.build.simple({
sender: alice.accountAddress,
data: {
// All transactions on Aptos are implemented via smart contracts.
function: "0x1::aptos_account::transfer",
functionArguments: [bob.accountAddress, 100],
},
});
console.log("Built the transaction!")
// 2. Simulate (Optional)
console.log("\n === 2. Simulating Response (Optional) === \n")
const [userTransactionResponse] = await aptos.transaction.simulate.simple({
signerPublicKey: alice.publicKey,
transaction,
});
console.log(userTransactionResponse)
// 3. Sign
console.log("\n=== 3. Signing transaction ===\n");
const senderAuthenticator = aptos.transaction.sign({
signer: alice,
transaction,
});
console.log("Signed the transaction!")
// 4. Submit
console.log("\n=== 4. Submitting transaction ===\n");
const submittedTransaction = await aptos.transaction.submit.simple({
transaction,
senderAuthenticator,
});
console.log(`Submitted transaction hash: ${submittedTransaction.hash}`);
// 5. Wait for results
console.log("\n=== 5. Waiting for result of transaction ===\n");
const executedTransaction = await aptos.waitForTransaction({ transactionHash: submittedTransaction.hash });
console.log(executedTransaction)
};
example();
+Troubleshooting
If you see import error when you do this
+import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+It could be your tsconfig.json is not using node. Make sure your moduleResolution in the tsconfig.json is set to node instead of bundler.
Contributing
If you found a bug or would like to request a feature, please file an issue. +If, based on the discussion on an issue you would like to offer a code change, please make a pull request. +If neither of these describes what you would like to contribute, checkout out the contributing guide.
+Interface Client
provider<Req, Res>(requestOptions: ClientRequest<Req>): Promise<ClientResponse<Res>>;
}
Index
Methods
Methods
provider
- provider<Req, Res>(requestOptions): Promise<ClientResponse<Res>>
Sends a request to the specified URL with the given options.
+Type Parameters
Parameters
- requestOptions: ClientRequest<Req>
The options for the request.
+
Returns Promise<ClientResponse<Res>>
- requestOptions: ClientRequest<Req>
Interface ClientRequest<Req>
Represents a client for making requests to a service provider.
+body?: Req;
contentType?: string;
headers?: Record<string, any>;
method: "GET" | "POST";
originMethod?: string;
overrides?: ClientHeadersType & {
API_KEY?: string;
WITH_CREDENTIALS?: boolean;
} & {
AUTH_TOKEN?: string;
};
params?: any;
url: string;
}
Type Parameters
Index
Properties
Properties
Optionalbody
Optionalcontent
Optionalheaders
method
Optionalorigin
Optionaloverrides
API_KEY?: string;
WITH_CREDENTIALS?: boolean;
} & {
AUTH_TOKEN?: string;
}
Optionalparams
url
Interface ClientResponse<Res>
config?: any;
data: Res;
headers?: any;
request?: any;
response?: any;
status: number;
statusText: string;
}
Type Parameters
Interface CreateAccountFromPrivateKeyArgs
Arguments for creating an Account from a private key when the key type is unknown at compile time.
address?: AccountAddressInput;
legacy?: boolean;
privateKey: PrivateKey;
}
Index
Properties
Interface CreateEd25519AccountFromPrivateKeyArgs
Arguments for creating an Ed25519Account from an Ed25519PrivateKey.
+To use the SingleKey authentication scheme, set legacy to false.
address?: AccountAddressInput;
legacy?: true;
privateKey: Ed25519PrivateKey;
}
Index
Properties
Interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs
Arguments for creating a SingleKeyAccount using an Ed25519PrivateKey.
+The legacy property must be set to false to utilize the SingleKey authentication scheme.
address?: AccountAddressInput;
legacy: false;
privateKey: Ed25519PrivateKey;
}
Index
Properties
Interface CreateSingleKeyAccountFromPrivateKeyArgs
Arguments for creating a SingleKeyAccount from a supported private key, excluding Ed25519PrivateKey.
+The legacy argument is always false and cannot be set to true.
address?: AccountAddressInput;
legacy?: false;
privateKey: PrivateKey;
}
Index
Properties
Interface Deserializable<T>
This interface exists to define Deserializable
Type Parameters
Index
Methods
Methods
deserialize
- deserialize(deserializer): T
Deserializes the buffered bytes into an instance of the specified class type. +This function provides an alternative syntax for deserialization, allowing users to call +
+deserializer.deserialize(MyClass)instead ofMyClass.deserialize(deserializer).Parameters
- deserializer: Deserializer
The deserializer instance with the buffered bytes.
+
Returns T
The deserialized value of class type T.
+- deserializer: Deserializer
Interface Ed25519SignerConstructorArgs
Arguments required to create an instance of an Ed25519 signer.
+address?: AccountAddressInput;
privateKey: Ed25519PrivateKey;
}
Index
Properties
Interface Ed25519SignerFromDerivationPathArgs
Arguments for creating an Ed25519 signer from a derivation path.
+Interface EntryFunctionArgument
Represents an argument for entry functions, providing methods to serialize the argument +to BCS-serialized bytes and convert it to different formats.
+bcsToBytes(): Uint8Array;
bcsToHex(): Hex;
serialize(serializer: Serializer): void;
serializeForEntryFunction(serializer: Serializer): void;
}
Hierarchy (view full)
- EntryFunctionArgument
Implemented by
Index
Methods
Methods
bcs
bcs
- bcs
To Hex(): Hex Converts the BCS-serialized bytes of an argument into a hexadecimal representation. +This function is useful for obtaining a Hex instance that encapsulates the BCS-serialized bytes, +allowing for easier manipulation and representation of the data.
+Returns Hex
A Hex instance containing the BCS-serialized bytes.
+
serialize
- serialize(serializer): void
Serialize an argument to BCS-serialized bytes.
+Parameters
- serializer: Serializer
The serializer instance used for serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serialize an argument to BCS-serialized bytes. +Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains +the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+Parameters
- serializer: Serializer
The serializer used to convert the argument.
+
Returns void
- serializer: Serializer
Interface InputGenerateMultiAgentRawTransactionArgs
Arguments for generating a multi-agent transaction, used in the generateTransaction() method of the transaction builder flow.
aptosConfig: AptosConfig;
feePayerAddress?: AccountAddressInput;
options?: InputGenerateTransactionOptions;
payload: AnyTransactionPayloadInstance;
secondarySignerAddresses: AccountAddressInput[];
sender: AccountAddressInput;
}
Index
Properties
Interface InputGenerateMultiAgentRawTransactionData
Holds user data input for generating a multi-agent transaction.
+data: InputGenerateTransactionPayloadData;
options?: InputGenerateTransactionOptions;
secondarySignerAddresses: AccountAddressInput[];
sender: AccountAddressInput;
withFeePayer?: boolean;
}
Index
Properties
Interface InputGenerateSingleSignerRawTransactionArgs
Arguments for generating a single signer raw transaction, used in the transaction builder flow.
+aptosConfig: AptosConfig;
feePayerAddress?: AccountAddressInput;
options?: InputGenerateTransactionOptions;
payload: AnyTransactionPayloadInstance;
sender: AccountAddressInput;
}
Index
Properties
Interface InputGenerateSingleSignerRawTransactionData
Holds user input data for generating a single signer transaction.
+data: InputGenerateTransactionPayloadData;
options?: InputGenerateTransactionOptions;
secondarySignerAddresses?: undefined;
sender: AccountAddressInput;
withFeePayer?: boolean;
}
Index
Properties
Interface InputSubmitTransactionData
Holds user data input for submitting a transaction.
+additionalSignersAuthenticators?: AccountAuthenticator[];
feePayerAuthenticator?: AccountAuthenticator;
senderAuthenticator: AccountAuthenticator;
transaction: AnyRawTransaction;
}
Index
Interface KeylessSigner
An interface which defines if an Account utilizes Keyless signing.
+accountAddress: AccountAddress;
publicKey: AccountPublicKey;
signingScheme: SigningScheme;
checkKeylessAccountValidity(aptosConfig: AptosConfig): Promise<void>;
sign(message: HexInput): Signature;
signTransaction(transaction: AnyRawTransaction): Signature;
signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticator;
signWithAuthenticator(message: HexInput): AccountAuthenticator;
verifySignature(args: VerifySignatureArgs): boolean;
}
Hierarchy (view full)
- Account
- KeylessSigner
Implemented by
Index
Methods
check
- check
Keyless Account Validity(aptosConfig): Promise<void> Parameters
- aptosConfig: AptosConfig
Returns Promise<void>
Abstractsign
Abstractsign
- sign
Transaction(transaction): Signature Sign the given transaction using the available signing capabilities.
+Parameters
- transaction: AnyRawTransaction
the transaction to be signed
+
Returns Signature
Signature
+- transaction: AnyRawTransaction
Abstractsign
- sign
Transaction With Authenticator(transaction): AccountAuthenticator Sign a transaction using the available signing capabilities.
+Parameters
- transaction: AnyRawTransaction
the raw transaction
+
Returns AccountAuthenticator
the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+- transaction: AnyRawTransaction
Abstractsign
- sign
With Authenticator(message): AccountAuthenticator Sign a message using the available signing capabilities.
+Parameters
- message: HexInput
the signing message, as binary input
+
Returns AccountAuthenticator
the AccountAuthenticator containing the signature, together with the account's public key
+- message: HexInput
verify
- verify
Signature(args): boolean Verify the given message and signature with the public key. +This function helps ensure the integrity and authenticity of a message by validating its signature.
+Parameters
- args: VerifySignatureArgs
The arguments for verifying the signature.
+
Returns boolean
A boolean indicating whether the signature is valid.
+- args: VerifySignatureArgs
Interface PrivateKeyFromDerivationPathArgs
Arguments for deriving a private key using a mnemonic phrase and a specified BIP44 path.
+Interface ScriptFunctionArgument
Represents an argument for script functions, providing methods to serialize and convert to bytes.
+bcsToBytes(): Uint8Array;
bcsToHex(): Hex;
serialize(serializer: Serializer): void;
serializeForScriptFunction(serializer: Serializer): void;
}
Hierarchy (view full)
- ScriptFunctionArgument
Index
Methods
Methods
bcs
bcs
serialize
- serialize(serializer): void
Serialize an argument to BCS-serialized bytes.
+Parameters
- serializer: Serializer
Returns void
serialize
- serialize
For Script Function(serializer): void Serialize an argument to BCS-serialized bytes as a type aware byte sequence. +The byte sequence contains an enum variant index followed by the BCS-serialized +bytes for a typed argument.
+Parameters
- serializer: Serializer
Returns void
Interface SingleKeySignerGenerateArgs
Arguments for generating a single key signer.
+ Index
Properties
Interface TransactionArgument
Represents an argument for entry functions, providing methods to serialize the argument +to BCS-serialized bytes and convert it to different formats.
+bcsToBytes(): Uint8Array;
bcsToHex(): Hex;
serialize(serializer: Serializer): void;
serializeForEntryFunction(serializer: Serializer): void;
serializeForScriptFunction(serializer: Serializer): void;
}
Hierarchy (view full)
- EntryFunctionArgument
- ScriptFunctionArgument
- TransactionArgument
Implemented by
Index
Methods
bcs
bcs
- bcs
To Hex(): Hex Converts the BCS-serialized bytes of an argument into a hexadecimal representation. +This function is useful for obtaining a Hex instance that encapsulates the BCS-serialized bytes, +allowing for easier manipulation and representation of the data.
+Returns Hex
A Hex instance containing the BCS-serialized bytes.
+
serialize
- serialize(serializer): void
Serialize an argument to BCS-serialized bytes.
+Parameters
- serializer: Serializer
The serializer instance used for serialization.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Entry Function(serializer): void Serialize an argument to BCS-serialized bytes. +Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains +the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+Parameters
- serializer: Serializer
The serializer used to convert the argument.
+
Returns void
- serializer: Serializer
serialize
- serialize
For Script Function(serializer): void Serialize an argument to BCS-serialized bytes as a type aware byte sequence. +The byte sequence contains an enum variant index followed by the BCS-serialized +bytes for a typed argument.
+Parameters
- serializer: Serializer
Returns void
Interface TransactionWorkerEvents
Defines the events emitted by the transaction worker during various stages of transaction processing. * +transactionSent - Emitted when a transaction is successfully sent. +transactionSendFailed - Emitted when sending a transaction fails. +transactionExecuted - Emitted when a transaction is successfully executed. +transactionExecutionFailed - Emitted when executing a transaction fails. +executionFinish - Emitted when the execution process is finished.
+executionFinish: ((data: ExecutionFinishEventData) => void);
transactionExecuted: ((data: SuccessEventData) => void);
transactionExecutionFailed: ((data: FailureEventData) => void);
transactionSendFailed: ((data: FailureEventData) => void);
transactionSent: ((data: SuccessEventData) => void);
}
Index
Interface VerifySignatureArgs
Represents the arguments required to verify a digital signature.
+Interface CallSite
getColumnNumber(): null | number;
getEnclosingColumnNumber(): number;
getEnclosingLineNumber(): number;
getEvalOrigin(): undefined | string;
getFileName(): undefined | string;
getFunction(): undefined | Function;
getFunctionName(): null | string;
getLineNumber(): null | number;
getMethodName(): null | string;
getPosition(): number;
getPromiseIndex(): null | number;
getScriptHash(): string;
getScriptNameOrSourceURL(): string;
getThis(): unknown;
getTypeName(): null | string;
isAsync(): boolean;
isConstructor(): boolean;
isEval(): boolean;
isNative(): boolean;
isPromiseAll(): boolean;
isToplevel(): boolean;
toString(): string;
}
Index
Methods
Interface CreateCollectionOptions
Options for creating a collection, allowing customization of various attributes such as supply limits, mutability of metadata, +and royalty settings.
+maxSupply?: AnyNumber;
mutableDescription?: boolean;
mutableRoyalty?: boolean;
mutableTokenDescription?: boolean;
mutableTokenName?: boolean;
mutableTokenProperties?: boolean;
mutableTokenURI?: boolean;
mutableURI?: boolean;
royaltyDenominator?: number;
royaltyNumerator?: number;
tokensBurnableByCreator?: boolean;
tokensFreezableByCreator?: boolean;
}
Properties
Optionalmax
Optionalmutable
Optionalmutable
Optionalmutable
Optionalmutable
Optionalmutable
Optionalmutable
OptionalmutableURI
Optionalroyalty
Optionalroyalty
Optionaltokens
Optionaltokens
Interface EventEmitterStatic
new EventEmitterStaticnew <EventTypes, Context>(): EventEmitter<EventTypes, Context>;
}
Index
Constructors
Constructors
constructor
- new
Event Emitter Static<EventTypes, Context>(): EventEmitter<EventTypes, Context> Type Parameters
- EventTypes extends ValidEventTypes = string | symbol
- Context = any
Returns EventEmitter<EventTypes, Context>
Interface ListenerFn<Args>
Type Parameters
- Listener
Fn(...args): void Parameters
Rest...args: Args
Returns void
Interface GetAccountDomainsArgs
Arguments for retrieving the domains associated with a specific account.
+accountAddress: AccountAddressInput;
options?: PaginationArgs & OrderByArg<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}> & WhereArg<CurrentAptosNamesBoolExp>;
}
Hierarchy (view full)
- QueryNamesOptions
- GetAccountDomainsArgs
Index
Properties
Properties
account
Optionaloptions
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}> & WhereArg<CurrentAptosNamesBoolExp>
Interface GetAccountNamesArgs
Arguments for retrieving account names based on the specified account address.
+accountAddress: AccountAddressInput;
options?: PaginationArgs & OrderByArg<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}> & WhereArg<CurrentAptosNamesBoolExp>;
}
Hierarchy (view full)
- QueryNamesOptions
- GetAccountNamesArgs
Index
Properties
Properties
account
Optionaloptions
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}> & WhereArg<CurrentAptosNamesBoolExp>
Interface GetAccountSubdomainsArgs
Arguments for retrieving subdomains associated with a specific account.
+accountAddress: AccountAddressInput;
options?: PaginationArgs & OrderByArg<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}> & WhereArg<CurrentAptosNamesBoolExp>;
}
Hierarchy (view full)
- QueryNamesOptions
- GetAccountSubdomainsArgs
Index
Properties
Properties
account
Optionaloptions
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}> & WhereArg<CurrentAptosNamesBoolExp>
Interface GetDomainSubdomainsArgs
Arguments for retrieving subdomains associated with a specific domain.
+domain: string;
options?: PaginationArgs & OrderByArg<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}> & WhereArg<CurrentAptosNamesBoolExp>;
}
Hierarchy (view full)
- QueryNamesOptions
- GetDomainSubdomainsArgs
Properties
domain
Optionaloptions
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}> & WhereArg<CurrentAptosNamesBoolExp>
Interface PendingDequeue<T>
The AsyncQueue class is an async-aware data structure that provides a queue-like +behavior for managing asynchronous tasks or operations. +It allows to enqueue items and dequeue them asynchronously. +This is not thread-safe, but it is async concurrency safe, and +it does not guarantee ordering for those that call into and await on enqueue.
+reject: ((reason?: AsyncQueueCancelledError) => void);
resolve: ((value: T) => void);
}
Type Parameters
Interface QueryNamesOptions
Options for querying names, including pagination, ordering, and filtering criteria.
+options?: PaginationArgs & OrderByArg<{
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}> & WhereArg<CurrentAptosNamesBoolExp>;
}
Hierarchy (view full)
Index
Properties
Properties
Optionaloptions
domain?: null | string;
domain_expiration_timestamp?: any;
expiration_timestamp?: any;
is_primary?: null | boolean;
owner_address?: null | string;
registered_address?: null | string;
subdomain?: null | string;
subdomain_expiration_policy?: any;
token_standard?: null | string;
}> & WhereArg<CurrentAptosNamesBoolExp>
Interface RegisterNameParameters
Parameters for registering a name in the Aptos network.
+aptosConfig: AptosConfig;
expiration: {
policy: "domain";
years?: 1;
} | {
policy: "subdomain:follow-domain";
} | {
expirationDate: number;
policy: "subdomain:independent";
};
name: string;
options?: InputGenerateTransactionOptions;
sender: Account;
targetAddress?: AccountAddressInput;
toAddress?: AccountAddressInput;
transferable?: boolean;
}
Index
Properties
@aptos-labs/ts-sdk - v1.32.1
Index
Classes
Enumerations
Events
Functions
Interfaces
Modules
Type Aliases
Variables
Namespace EventEmitter
Index
Interfaces
Type Aliases
Variables
Module <internal>
Index
Classes
Enumerations
Interfaces
Namespaces
References
Type Aliases
Variables
References
Argument
Re-exports ArgumentMapType Alias AccountAddressInput
The input for an account address, which can be either a hexadecimal string or a standard account address.
+Type Alias AccountData
authentication_key: string;
sequence_number: string;
}
The data associated with an account, including its sequence number.
+Type Alias AccountSignature
The union of all single account signatures, including Ed25519, Secp256k1, and MultiEd25519 signatures.
+Type Alias AnyNumber
A number or a bigint value.
+Type Alias AnyRawTransaction
Unified type that holds all the return interfaces when generating different transaction types
+Type Alias AnyRawTransactionInstance
Holds all return interfaces for generating different transaction types.
+Type Alias AnyTransactionPayloadInstance
The transaction payload type generated from the generateTransactionPayload() function, which can be an entry function,
+script, or multi-signature payload.
Type Alias AptosRequest
acceptType?: string;
body?: any;
contentType?: string;
method: "GET" | "POST";
originMethod?: string;
overrides?: ClientConfig & FullNodeConfig & IndexerConfig & FaucetConfig;
params?: Record<string,
| string
| AnyNumber
| boolean
| undefined>;
path?: string;
url: string;
}
The API request type
+Param: url
the url to make the request to, i.e. https://fullnode.devnet.aptoslabs.com/v1
+Type Alias AptosSettings
client?: Client;
clientConfig?: ClientConfig;
faucet?: string;
faucetConfig?: FaucetConfig;
fullnode?: string;
fullnodeConfig?: FullNodeConfig;
indexer?: string;
indexerConfig?: IndexerConfig;
network?: Network;
pepper?: string;
prover?: string;
}
Configuration options for initializing the SDK, allowing customization of its behavior and interaction with the Aptos network.
+Type Alias AuthenticationKeyScheme
A list of supported Authentication Key schemes in Aptos, consisting of combinations of signing schemes and derive schemes.
+Type Alias Block
block_hash: string;
block_height: string;
block_timestamp: string;
first_version: string;
last_version: string;
transactions?: TransactionResponse[];
}
A Block type
+Type declaration
block_
hash: string block_
height: string block_
timestamp: string first_
version: string last_
version: string Optionaltransactions?: TransactionResponse[]The transactions in the block in sequential order
+
Type Alias BlockEndInfo
block_approx_output_size: number;
block_effective_block_gas_units: number;
block_gas_limit_reached: boolean;
block_output_limit_reached: boolean;
}
Describes the gas state of the block, indicating whether the block gas limit has been reached.
+Type Alias BlockEpilogueTransactionResponse
accumulator_root_hash: string;
block_end_info: BlockEndInfo | null;
changes: WriteSetChange[];
event_root_hash: string;
gas_used: string;
hash: string;
state_change_hash: string;
state_checkpoint_hash: string | null;
success: boolean;
timestamp: string;
type: BlockEpilogue;
version: string;
vm_status: string;
}
A transaction executed at the end of a block that tracks data from the entire block.
+Type declaration
accumulator_
root_ hash: string block_
end_ info: BlockEndInfo | null changes: WriteSetChange[]
Final state of resources changed by the transaction
+event_
root_ hash: string gas_
used: string hash: string
state_
change_ hash: string state_
checkpoint_ hash: string | null success: boolean
Whether the transaction was successful
+timestamp: string
type: BlockEpilogue
version: string
vm_
status: string The VM status of the transaction, can tell useful information in a failure
+
Type Alias BlockMetadataTransactionResponse
accumulator_root_hash: string;
changes: WriteSetChange[];
epoch: string;
event_root_hash: string;
events: Event[];
failed_proposer_indices: number[];
gas_used: string;
hash: string;
id: string;
previous_block_votes_bitvec: number[];
proposer: string;
round: string;
state_change_hash: string;
state_checkpoint_hash: string | null;
success: boolean;
timestamp: string;
type: BlockMetadata;
version: string;
vm_status: string;
}
The structure representing a blockchain block with its height.
+Type declaration
accumulator_
root_ hash: string changes: WriteSetChange[]
Final state of resources changed by the transaction
+epoch: string
event_
root_ hash: string events: Event[]
The events emitted at the block creation
+failed_
proposer_ indices: number[] The indices of the proposers who failed to propose
+gas_
used: string hash: string
id: string
previous_
block_ votes_ bitvec: number[] Previous block votes
+proposer: string
round: string
state_
change_ hash: string state_
checkpoint_ hash: string | null success: boolean
Whether the transaction was successful
+timestamp: string
type: BlockMetadata
version: string
vm_
status: string The VM status of the transaction, can tell useful information in a failure
+
Type Alias ClientConfig
A configuration object for requests to the server, including API key, extra headers, and cookie handling options.
+Type Alias ClientHeadersType
General type definition for client headers.
+Type Alias CommittedTransactionResponse
| UserTransactionResponse
| GenesisTransactionResponse
| BlockMetadataTransactionResponse
| StateCheckpointTransactionResponse
| ValidatorTransactionResponse
| BlockEpilogueTransactionResponse
The response for a committed transaction, which can be one of several transaction types.
+Type Alias DecodedTableData
key: any;
key_type: string;
value: any;
value_type: string;
}
The decoded data for a table, including its key in JSON format.
+Type declaration
key: any
Key of table in JSON
+key_
type: string Type of key
+value: any
Value of table in JSON
+value_
type: string Type of value
+
Type Alias DeletedTableData
key: any;
key_type: string;
}
Data for a deleted table entry.
+Type declaration
key: any
Deleted key
+key_
type: string Deleted key type
+
Type Alias DerivedKeys
chainCode: Uint8Array;
key: Uint8Array;
}
Contains the derived cryptographic key as a Uint8Array.
+Type Alias DeserializableClass<T>
Type Parameters
- T extends Serializable
Type declaration
deserialize:function
- deserialize(deserializer): T
Deserializes a serialized object using the provided deserializer. +This function allows you to reconstruct an object from its serialized form.
+Parameters
- deserializer: Deserializer
An instance of the Deserializer used to read the serialized data.
+
Returns T
- deserializer: Deserializer
Type Alias DirectWriteSet
The set of direct write operations, identified by a type string.
+Type Alias EntryFunctionABI
Interface for an Entry function's ABI, enabling type checking and input conversion for ABI-based transaction submissions.
+Type Alias EntryFunctionArgumentTypes
| Bool
| U8
| U16
| U32
| U64
| U128
| U256
| AccountAddress
| MoveVector<EntryFunctionArgumentTypes>
| MoveOption<EntryFunctionArgumentTypes>
| MoveString
| FixedBytes
Entry function arguments for building a raw transaction using BCS serialized arguments.
+Type Alias EntryFunctionPayloadResponse
arguments: any[];
function: MoveFunctionId;
type: string;
type_arguments: string[];
}
The response payload for an entry function, containing the type of the entry.
+Type declaration
arguments: any[]
Arguments of the function
+function: MoveFunctionId
type: string
type_
arguments: string[] Type arguments of the function
+
Type Alias EventGuid
account_address: string;
creation_number: string;
}
The structure for an event, identified by a unique GUID.
+Type Alias ExecutionFinishEventData
message: string;
}
The payload for when the worker has finished its job.
+Type Alias FailureEventData
error: string;
message: string;
}
The payload for a failure event.
+Type Alias FaucetConfig
A configuration object for a faucet, including optional authentication and headers for requests.
+Type Alias FullNodeConfig
A configuration object for a Fullnode, allowing for the inclusion of extra headers in requests.
+Type Alias FunctionABI
Data needed for a generic function ABI, applicable to both view and entry functions.
+Type Alias GasEstimation
deprioritized_gas_estimate?: number;
gas_estimate: number;
prioritized_gas_estimate?: number;
}
The output of the estimate gas API, including the deprioritized estimate for the gas unit price.
+Type declaration
Optionaldeprioritized_gas_ estimate?: number The deprioritized estimate for the gas unit price
+gas_
estimate: number The current estimate for the gas unit price
+Optionalprioritized_gas_ estimate?: number The prioritized estimate for the gas unit price
+
Type Alias GenerateAccount
Type Alias GenerateAccountWithEd25519
Input type to generate an account using the Ed25519 signing scheme.
+Type Alias GenerateAccountWithSingleSignerSecp256k1Key
Input type to generate an account with a Single Signer using Secp256k1.
+Type Alias GenesisPayload
The payload for the genesis block containing the type of the payload.
+Type Alias GenesisTransactionResponse
accumulator_root_hash: string;
changes: WriteSetChange[];
event_root_hash: string;
events: Event[];
gas_used: string;
hash: string;
payload: GenesisPayload;
state_change_hash: string;
state_checkpoint_hash?: string;
success: boolean;
type: Genesis;
version: string;
vm_status: string;
}
The response for a genesis transaction, indicating the type of transaction.
+Type declaration
accumulator_
root_ hash: string changes: WriteSetChange[]
Final state of resources changed by the transaction
+event_
root_ hash: string events: Event[]
Events emitted during genesis
+gas_
used: string hash: string
payload: GenesisPayload
state_
change_ hash: string Optionalstate_checkpoint_ hash?: string success: boolean
Whether the transaction was successful
+type: Genesis
version: string
vm_
status: string The VM status of the transaction, can tell useful information in a failure
+
Type Alias GetANSNameResponse
The response containing the current Aptos names from the GetNamesQuery.
+Type Alias GetAccountCoinsDataResponse
The current balances of fungible assets for an account.
+Type Alias GetAccountCollectionsWithOwnedTokenResponse
The response structure for retrieving account collections associated with owned tokens.
+Type Alias GetAccountOwnedTokensFromCollectionResponse
The response containing the current token ownerships for an account from a specific collection.
+Type Alias GetAccountOwnedTokensQueryResponse
The response structure for querying tokens owned by an account.
+Type Alias GetAptosRequestOptions
Options for making a request to the Aptos API, excluding the "type" field.
+Type Alias GetChainTopUserTransactionsResponse
The response structure for retrieving user transactions from the top of the blockchain.
+Type Alias GetCollectionDataResponse
The response structure for retrieving data from the current collections.
+Type Alias GetCurrentFungibleAssetBalancesResponse
The current balances of fungible assets for a specific query.
+Type Alias GetCurrentTokenOwnershipResponse
The response structure for retrieving the current token ownership details.
+Type Alias GetDelegatedStakingActivitiesResponse
The response containing the delegated staking activities from the query.
+Type Alias GetEventsResponse
The response containing the events from the GetEventsQuery.
+Type Alias GetFungibleAssetActivitiesResponse
The response containing the activities related to fungible assets.
+Type Alias GetFungibleAssetMetadataResponse
The response containing metadata for a fungible asset.
+Type Alias GetNumberOfDelegatorsResponse
The number of active delegators per pool in response to a query.
+Type Alias GetObjectDataQueryResponse
CUSTOM RESPONSE TYPES FOR THE END USER
+To provide a good dev exp, we build custom types derived from the +query types to be the response type the end developer/user will +work with.
+These types are used as the return type when calling a sdk api function +that calls the function that queries the server (usually under the /api/ folder)
+Type Alias GetOwnedTokensResponse
The response containing the current token ownerships for a user.
+Type Alias GetProcessorStatusResponse
The status of the processor as returned by the GetProcessorStatusQuery.
+Type Alias GetRequestOptions
acceptType?: MimeType;
aptosConfig: AptosConfig;
contentType?: MimeType;
originMethod: string;
overrides?: ClientConfig;
params?: Record<string,
| string
| AnyNumber
| boolean
| undefined>;
path: string;
type: AptosApiType;
}
Options for making a GET request, including configuration for the API client.
+Type declaration
OptionalacceptType?: MimeType The accepted content type of the response of the API
+aptos
Config: AptosConfig The config for the API client
+OptionalcontentType?: MimeType The content type of the request body
+origin
Method: string The name of the API method
+Optionaloverrides?: ClientConfigSpecific client overrides for this request to override aptosConfig
+Optionalparams?: Record<string,
| string
| AnyNumber
| boolean
| undefined>The query parameters for the request
+path: string
The URL path to the API method
+type: AptosApiType
The type of API endpoint to call e.g. fullnode, indexer, etc
+
Type Alias GetTableItemsDataResponse
The response structure for retrieving items from a table.
+Type Alias GetTableItemsMetadataResponse
The metadata for table items retrieved from a query.
+Type Alias GetTokenActivityResponse
The response structure for retrieving token activity data.
+Type Alias GetTokenDataResponse
The response structure for retrieving token data, containing the current token information.
+Type Alias GraphqlQuery
query: string;
variables?: {};
}
The GraphQL query to pass into the queryIndexer function.
Type Alias HexInput
Hexadecimal data input for functions, supporting both string and Uint8Array formats.
+Type Alias IndexerConfig
An Indexer configuration object for sending requests with additional headers.
+Type Alias InputEntryFunctionData
abi?: EntryFunctionABI;
function: MoveFunctionId;
functionArguments: (EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes)[];
typeArguments?: TypeArgument[];
}
The data needed to generate an Entry Function payload.
+Type Alias InputEntryFunctionDataWithABI
The input data for an entry function, including its associated ABI.
+Type Alias InputEntryFunctionDataWithRemoteABI
Combines input function data with Aptos configuration for remote ABI interactions.
+Type Alias InputGenerateRawTransactionArgs
A unified type for generating various transaction types.
+Type Alias InputGenerateTransactionData
Unified type holding user data input interfaces for generating various transaction types.
+Type Alias InputGenerateTransactionOptions
accountSequenceNumber?: AnyNumber;
expireTimestamp?: number;
gasUnitPrice?: number;
maxGasAmount?: number;
}
Optional options to set when generating a transaction, including a maximum gas amount.
+Type Alias InputGenerateTransactionPayloadData
The data needed to generate a transaction payload for Entry Function, Script, or Multi Sig types.
+Type Alias InputGenerateTransactionPayloadDataWithABI
The payload for generating a transaction, which can be either an entry function or a multi-signature transaction.
+Type Alias InputGenerateTransactionPayloadDataWithRemoteABI
The payload for generating a transaction, which can be either script data, entry function data with remote ABI, or +multi-signature data.
+Type Alias InputMultiSigData
The data needed to generate a Multi Sig payload
+Type Alias InputMultiSigDataWithABI
The data needed to generate a Multi Sig payload, including the multisig address.
+Type Alias InputMultiSigDataWithRemoteABI
multisigAddress: AccountAddressInput;
} & InputEntryFunctionDataWithRemoteABI
The data needed to generate a Multi Sig payload, including the multisig address.
+Type Alias InputScriptData
bytecode: HexInput;
functionArguments: ScriptFunctionArgumentTypes[];
typeArguments?: TypeArgument[];
}
The data needed to generate a Script payload.
+Type Alias InputSimulateTransactionData
feePayerPublicKey?: PublicKey;
options?: InputSimulateTransactionOptions;
secondarySignersPublicKeys?: PublicKey[];
signerPublicKey: PublicKey;
transaction: AnyRawTransaction;
}
The data required to simulate a transaction, typically generated by generateTransaction().
Type declaration
OptionalfeePayer Public Key?: PublicKey For a fee payer transaction (aka Sponsored Transaction)
+Optionaloptions?: InputSimulateTransactionOptionsOptionalsecondarySigners Public Keys?: PublicKey[] For a fee payer or multi-agent transaction that requires additional signers in
+signer
Public Key: PublicKey For a single signer transaction
+transaction: AnyRawTransaction
The transaction to simulate, probably generated by
+generateTransaction()
Type Alias InputSimulateTransactionOptions
estimateGasUnitPrice?: boolean;
estimateMaxGasAmount?: boolean;
estimatePrioritizedGasUnitPrice?: boolean;
}
Options for simulating a transaction input, including whether to estimate the gas unit price.
+Type Alias InputViewFunctionData
abi?: ViewFunctionABI;
function: MoveFunctionId;
functionArguments?: (EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes)[];
typeArguments?: TypeArgument[];
}
The data needed to generate a View Function payload.
+Type Alias InputViewFunctionDataWithABI
Data needed to generate a view function, including the fetched ABI.
+Type Alias InputViewFunctionDataWithRemoteABI
Data required to create a view function payload and retrieve the remote ABI, including Aptos configuration.
+Type Alias InputViewFunctionJsonData
function: MoveFunctionId;
functionArguments?: MoveValue[];
typeArguments?: MoveStructId[];
}
The data needed to generate a View Function payload in JSON format.
+Type Alias LedgerInfo
block_height: string;
chain_id: number;
epoch: string;
git_hash?: string;
ledger_timestamp: string;
ledger_version: string;
node_role: RoleType;
oldest_block_height: string;
oldest_ledger_version: string;
}
Information about the current blockchain ledger, including its chain ID.
+Type declaration
block_
height: string chain_
id: number Chain ID of the current chain
+epoch: string
Optionalgit_hash?: string Git hash of the build of the API endpoint. Can be used to determine the exact +software version used by the API endpoint.
+ledger_
timestamp: string ledger_
version: string node_
role: RoleType oldest_
block_ height: string oldest_
ledger_ version: string
Type Alias LedgerVersionArg
The ledger version of transactions, defaulting to the latest version if not specified.
+Type Alias MoveAddressType
A string representing a Move address.
+Type Alias MoveFunction
generic_type_params: MoveFunctionGenericTypeParam[];
is_entry: boolean;
is_view: boolean;
name: string;
params: string[];
return: string[];
visibility: MoveFunctionVisibility;
}
Move function
+Type declaration
generic_
type_ params: MoveFunctionGenericTypeParam[] Generic type params associated with the Move function
+is_
entry: boolean Whether the function can be called as an entry function directly in a transaction
+is_
view: boolean Whether the function is a view function or not
+name: string
params: string[]
Parameters associated with the move function
+return: string[]
Return type of the function
+visibility: MoveFunctionVisibility
Type Alias MoveFunctionGenericTypeParam
Move abilities associated with the generic type parameter of a function.
+Type Alias MoveFunctionId
The move function containing its name. Same as MoveStructId since it reads weird to take a StructId for a Function.
+Type Alias MoveModule
address: string;
exposed_functions: MoveFunction[];
friends: MoveModuleId[];
name: string;
structs: MoveStruct[];
}
A Move module
+Type declaration
address: string
exposed_
functions: MoveFunction[] Public functions of the module
+friends: MoveModuleId[]
Friends of the module
+name: string
structs: MoveStruct[]
Structs of the module
+
Type Alias MoveModuleBytecode
A Move module containing an address.
+Type Alias MoveModuleId
A string representation of a Move module, formatted as module_name::function_name.
+Module names are case-sensitive.
Type Alias MoveObjectType
The type for identifying objects to be moved within the system.
+Type Alias MoveOptionType
The type for move options, which can be a MoveType, null, or undefined.
+Type Alias MoveScriptBytecode
The bytecode for a Move script.
+Type Alias MoveStruct
abilities: MoveAbility[];
fields: MoveStructField[];
generic_type_params: MoveFunctionGenericTypeParam[];
is_event: boolean;
is_native: boolean;
name: string;
}
A move struct
+Type declaration
abilities: MoveAbility[]
Abilities associated with the struct
+fields: MoveStructField[]
Fields associated with the struct
+generic_
type_ params: MoveFunctionGenericTypeParam[] Generic types associated with the struct
+is_
event: boolean Whether the struct is a module event (aka v2 event). This will be false for v1 +events because the value is derived from the #[event] attribute on the struct in +the Move source code. This attribute is only relevant for v2 events.
+is_
native: boolean Whether the struct is a native struct of Move
+name: string
Type Alias MoveStructField
name: string;
type: string;
}
A field in a Move struct, identified by its name.
+Type Alias MoveStructId
A structure representing a move with a name.
+Type Alias MoveStructType
Type Alias MoveType
| boolean
| string
| MoveUint8Type
| MoveUint16Type
| MoveUint32Type
| MoveUint64Type
| MoveUint128Type
| MoveUint256Type
| MoveAddressType
| MoveObjectType
| MoveStructType
| MoveType[]
A union type that encompasses various data types used in Move, including primitive types, address types, object types, and +arrays of MoveType.
+Type Alias MoveUint128Type
A string representing a 128-bit unsigned integer in the Move programming language.
+Type Alias MoveUint16Type
A 16-bit unsigned integer used in the Move programming language.
+Type Alias MoveUint256Type
A string representation of a 256-bit unsigned integer used in Move programming.
+Type Alias MoveUint32Type
A 32-bit unsigned integer type used in Move programming.
+Type Alias MoveUint64Type
A string representation of a 64-bit unsigned integer used in Move programming.
+Type Alias MoveUint8Type
A number representing a Move uint8 type.
+Type Alias MoveValue
| boolean
| string
| MoveUint8Type
| MoveUint16Type
| MoveUint32Type
| MoveUint64Type
| MoveUint128Type
| MoveUint256Type
| MoveAddressType
| MoveObjectType
| MoveStructId
| MoveOptionType
| MoveValue[]
Possible Move values acceptable by move functions (entry, view)
+Map of a Move value to the corresponding TypeScript value
+Bool -> boolean
u8, u16, u32 -> number
u64, u128, u256 -> string
String -> string
Address -> 0x${string}
Struct - 0x${string}::${string}::${string}
Object -> 0x${string}
Vector -> Array<MoveValue>
Option -> MoveValue | null | undefined
Type Alias MultisigPayloadResponse
multisig_address: string;
transaction_payload?: EntryFunctionPayloadResponse;
type: string;
}
The response payload for a multisig transaction, containing the type of the transaction.
+Type Alias OrderBy<T>
A generic type that being passed by each function and holds an +array of properties we can sort the query by
+Type Parameters
Type Alias OrderByValue
| "asc"
| "asc_nulls_first"
| "asc_nulls_last"
| "desc"
| "desc_nulls_first"
| "desc_nulls_last"
Specifies the order direction for sorting, including options for handling null values.
+Type Alias ParsingResult<T>
Whereas ParsingError is thrown when parsing fails, e.g. in a fromString function, +this type is returned from "defensive" functions like isValid.
+Type Parameters
Type declaration
OptionalinvalidReason?: T If valid is false, this will be a code explaining why parsing failed.
+OptionalinvalidReason Message?: string If valid is false, this will be a string explaining why parsing failed.
+valid: boolean
True if valid, false otherwise.
+
Type Alias PendingTransactionResponse
expiration_timestamp_secs: string;
gas_unit_price: string;
hash: string;
max_gas_amount: string;
payload: TransactionPayloadResponse;
sender: string;
sequence_number: string;
signature?: TransactionSignature;
type: Pending;
}
The response for a pending transaction, indicating that the transaction is still being processed.
+Type Alias PostAptosRequestOptions
Options for posting a request to Aptos, excluding the type field.
+Type Alias PostRequestOptions
acceptType?: MimeType;
aptosConfig: AptosConfig;
body?: any;
contentType?: MimeType;
originMethod: string;
overrides?: ClientConfig;
params?: Record<string,
| string
| AnyNumber
| boolean
| undefined>;
path: string;
type: AptosApiType;
}
Options for making a POST request, including the API client configuration.
+Type declaration
OptionalacceptType?: MimeType The accepted content type of the response of the API
+aptos
Config: AptosConfig The config for the API client
+Optionalbody?: anyThe body of the request, should match the content type of the request
+OptionalcontentType?: MimeType The content type of the request body
+origin
Method: string The name of the API method
+Optionaloverrides?: ClientConfigSpecific client overrides for this request to override aptosConfig
+Optionalparams?: Record<string,
| string
| AnyNumber
| boolean
| undefined>The query parameters for the request
+path: string
The URL path to the API method
+type: AptosApiType
The type of API endpoint to call e.g. fullnode, indexer, etc
+
Type Alias ProofFetchCallback
Type Alias ProofFetchFailure
error: string;
status: "Failed";
}
Type Alias ProofFetchStatus
Type Alias ProofFetchSuccess
status: "Success";
}
Type Alias ScriptFunctionArgumentTypes
| Bool
| U8
| U16
| U32
| U64
| U128
| U256
| AccountAddress
| MoveVector<ScriptFunctionArgumentTypes>
| MoveString
| FixedBytes
| Serialized
Script function arguments for building raw transactions using BCS serialized arguments.
+Type Alias ScriptPayloadResponse
arguments: any[];
code: MoveScriptBytecode;
type: string;
type_arguments: string[];
}
The payload for a script response, containing the type of the script.
+Type declaration
arguments: any[]
Arguments of the function
+code: MoveScriptBytecode
type: string
type_
arguments: string[] Type arguments of the function
+
Type Alias ScriptWriteSet
The set of properties for writing scripts, including the type of script.
+Type Alias SimpleEntryFunctionArgumentTypes
| boolean
| number
| bigint
| string
| null
| undefined
| Uint8Array
| ArrayBuffer
| (SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes)[]
Entry function arguments for building a raw transaction using remote ABI, supporting various data types including primitives and arrays.
+Type Alias SingleKeySignerFromDerivationPathArgs
mnemonic: string;
path: string;
}
The arguments for generating a single key signer from a specified derivation path.
+Type Alias StateCheckpointTransactionResponse
accumulator_root_hash: string;
changes: WriteSetChange[];
event_root_hash: string;
gas_used: string;
hash: string;
state_change_hash: string;
state_checkpoint_hash: string | null;
success: boolean;
timestamp: string;
type: StateCheckpoint;
version: string;
vm_status: string;
}
The response for a state checkpoint transaction, indicating the type of transaction.
+Type declaration
accumulator_
root_ hash: string changes: WriteSetChange[]
Final state of resources changed by the transaction
+event_
root_ hash: string gas_
used: string hash: string
state_
change_ hash: string state_
checkpoint_ hash: string | null success: boolean
Whether the transaction was successful
+timestamp: string
type: StateCheckpoint
version: string
vm_
status: string The VM status of the transaction, can tell useful information in a failure
+
Type Alias SuccessEventData
message: string;
transactionHash: string;
}
The payload for a success event.
+Type Alias TokenStandard
The token standard to query for, which can be either version "v1" or "v2".
+Type Alias TransactionEd25519Signature
public_key: string;
signature: "ed25519_signature";
type: string;
}
The signature for a transaction using the Ed25519 algorithm.
+Type Alias TransactionFeePayerSignature
fee_payer_address: string;
fee_payer_signer: AccountSignature;
secondary_signer_addresses: string[];
secondary_signers: AccountSignature[];
sender: AccountSignature;
type: "fee_payer_signature";
}
The signature of the fee payer in a transaction.
+Type declaration
fee_
payer_ address: string fee_
payer_ signer: AccountSignature secondary_
signer_ addresses: string[] The other involved parties' addresses
+secondary_
signers: AccountSignature[] The associated signatures, in the same order as the secondary addresses
+sender: AccountSignature
type: "fee_payer_signature"
Type Alias TransactionMultiAgentSignature
secondary_signer_addresses: string[];
secondary_signers: AccountSignature[];
sender: AccountSignature;
type: "multi_agent_signature";
}
The structure for a multi-agent signature in a transaction.
+Type declaration
secondary_
signer_ addresses: string[] The other involved parties' addresses
+secondary_
signers: AccountSignature[] The associated signatures, in the same order as the secondary addresses
+sender: AccountSignature
type: "multi_agent_signature"
Type Alias TransactionMultiEd25519Signature
bitmap: string;
public_keys: string[];
signatures: string[];
threshold: number;
type: "multi_ed25519_signature";
}
The structure for a multi-signature transaction using Ed25519.
+Type declaration
bitmap: string
public_
keys: string[] The public keys for the Ed25519 signature
+signatures: string[]
Signature associated with the public keys in the same order
+threshold: number
The number of signatures required for a successful transaction
+type: "multi_ed25519_signature"
Type Alias TransactionPayloadResponse
The payload for a transaction response, which can be an entry function, script, or multisig payload.
+Type Alias TransactionResponse
The response for a transaction, which can be either pending or committed.
+Type Alias TransactionSecp256k1Signature
public_key: string;
signature: "secp256k1_ecdsa_signature";
type: string;
}
The structure for a Secp256k1 signature in a transaction.
+Type Alias TransactionSignature
| TransactionEd25519Signature
| TransactionSecp256k1Signature
| TransactionMultiEd25519Signature
| TransactionMultiAgentSignature
| TransactionFeePayerSignature
JSON representations of transaction signatures returned from the node API.
+Type Alias TypeArgument
Inputs for Entry functions, view functions, and scripts, which can be a string representation of various types including +primitive types, vectors, and structured types.
+-
+
+
This can be a string version of the type argument such as:
+-
+
- u8 +
- u16 +
- u32 +
- u64 +
- u128 +
- u256 +
- bool +
- address +
- signer +
- vector
- address::module::struct +
- address::module::struct<Type1, Type2> +
Type Alias Uint128
A 128-bit unsigned integer used for precise arithmetic operations.
+Type Alias Uint16
A 16-bit unsigned integer.
+Type Alias Uint256
A 256-bit unsigned integer used for precise numerical calculations.
+Type Alias Uint32
A 32-bit unsigned integer.
+Type Alias Uint64
A 64-bit unsigned integer value.
+Type Alias Uint8
BCS types
+Type Alias UserTransactionResponse
accumulator_root_hash: string;
changes: WriteSetChange[];
event_root_hash: string;
events: Event[];
expiration_timestamp_secs: string;
gas_unit_price: string;
gas_used: string;
hash: string;
max_gas_amount: string;
payload: TransactionPayloadResponse;
sender: string;
sequence_number: string;
signature?: TransactionSignature;
state_change_hash: string;
state_checkpoint_hash: string | null;
success: boolean;
timestamp: string;
type: User;
version: string;
vm_status: string;
}
The response structure for a user transaction.
+Type declaration
accumulator_
root_ hash: string changes: WriteSetChange[]
Final state of resources changed by the transaction
+event_
root_ hash: string events: Event[]
Events generated by the transaction
+expiration_
timestamp_ secs: string gas_
unit_ price: string gas_
used: string hash: string
max_
gas_ amount: string payload: TransactionPayloadResponse
sender: string
sequence_
number: string Optionalsignature?: TransactionSignaturestate_
change_ hash: string state_
checkpoint_ hash: string | null success: boolean
Whether the transaction was successful
+timestamp: string
type: User
version: string
vm_
status: string The VM status of the transaction, can tell useful information in a failure
+
Type Alias ValidatorTransactionResponse
accumulator_root_hash: string;
changes: WriteSetChange[];
event_root_hash: string;
events: Event[];
gas_used: string;
hash: string;
state_change_hash: string;
state_checkpoint_hash: string | null;
success: boolean;
timestamp: string;
type: Validator;
version: string;
vm_status: string;
}
The response for a validator transaction, indicating the type of transaction.
+Type declaration
accumulator_
root_ hash: string changes: WriteSetChange[]
Final state of resources changed by the transaction
+event_
root_ hash: string events: Event[]
The events emitted by the validator transaction
+gas_
used: string hash: string
state_
change_ hash: string state_
checkpoint_ hash: string | null success: boolean
Whether the transaction was successful
+timestamp: string
type: Validator
version: string
vm_
status: string The VM status of the transaction, can tell useful information in a failure
+
Type Alias ViewFunctionABI
Interface for a view function's ABI, providing type checking and input conversion for ABI-based transaction submissions.
+Type Alias ViewFunctionJsonPayload
function: MoveFunctionId;
functionArguments: MoveValue[];
typeArguments: MoveStructId[];
}
The payload sent to the fullnode for a JSON view request.
+Type Alias WaitForTransactionOptions
checkSuccess?: boolean;
timeoutSecs?: number;
waitForIndexer?: boolean;
}
Options for configuring the behavior of the waitForTransaction() function.
+Type Alias WriteSet
Type Alias WriteSetChange
| WriteSetChangeDeleteModule
| WriteSetChangeDeleteResource
| WriteSetChangeDeleteTableItem
| WriteSetChangeWriteModule
| WriteSetChangeWriteResource
| WriteSetChangeWriteTableItem
A union type that encompasses both script and direct write sets for data operations.
+Type Alias WriteSetChangeDeleteModule
address: string;
module: MoveModuleId;
state_key_hash: string;
type: string;
}
The structure for a module deletion change in a write set.
+Type declaration
address: string
module: MoveModuleId
state_
key_ hash: string State key hash
+type: string
Type Alias WriteSetChangeDeleteResource
address: string;
resource: string;
state_key_hash: string;
type: string;
}
The payload for a resource deletion in a write set change.
+Type Alias WriteSetChangeDeleteTableItem
data?: DeletedTableData;
handle: string;
key: string;
state_key_hash: string;
type: string;
}
The payload for a write set change that deletes a table item.
+Type Alias WriteSetChangeWriteModule
address: string;
data: MoveModuleBytecode;
state_key_hash: string;
type: string;
}
The structure for a write module change in a write set.
+Type Alias WriteSetChangeWriteResource
address: string;
data: MoveResource;
state_key_hash: string;
type: string;
}
The resource associated with a write set change, identified by its type.
+Type Alias WriteSetChangeWriteTableItem
data?: DecodedTableData;
handle: string;
key: string;
state_key_hash: string;
type: string;
value: string;
}
The structure for a write operation on a table in a write set change.
+Type Alias AptosApiErrorOpts
apiType: AptosApiType;
aptosRequest: AptosRequest;
aptosResponse: AptosResponse<any, any>;
}
Options for handling errors in the Aptos API.
+Type Alias BigintComparisonExp
_eq?: InputMaybe<Scalars["bigint"]["input"]>;
_gt?: InputMaybe<Scalars["bigint"]["input"]>;
_gte?: InputMaybe<Scalars["bigint"]["input"]>;
_in?: InputMaybe<Scalars["bigint"]["input"][]>;
_is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
_lt?: InputMaybe<Scalars["bigint"]["input"]>;
_lte?: InputMaybe<Scalars["bigint"]["input"]>;
_neq?: InputMaybe<Scalars["bigint"]["input"]>;
_nin?: InputMaybe<Scalars["bigint"]["input"][]>;
}
Boolean expression to compare columns of type "bigint". All fields are combined with logical 'AND'.
+Type Alias BooleanComparisonExp
_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
_gt?: InputMaybe<Scalars["Boolean"]["input"]>;
_gte?: InputMaybe<Scalars["Boolean"]["input"]>;
_in?: InputMaybe<Scalars["Boolean"]["input"][]>;
_is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
_lt?: InputMaybe<Scalars["Boolean"]["input"]>;
_lte?: InputMaybe<Scalars["Boolean"]["input"]>;
_neq?: InputMaybe<Scalars["Boolean"]["input"]>;
_nin?: InputMaybe<Scalars["Boolean"]["input"][]>;
}
Boolean expression to compare columns of type "Boolean". All fields are combined with logical 'AND'.
+Type Alias CurrentAptosNamesAggregateBoolExp
bool_and?: InputMaybe<CurrentAptosNamesAggregateBoolExpBoolAnd>;
bool_or?: InputMaybe<CurrentAptosNamesAggregateBoolExpBoolOr>;
count?: InputMaybe<CurrentAptosNamesAggregateBoolExpCount>;
}
Type Alias CurrentAptosNamesAggregateBoolExpBoolAnd
arguments: CurrentAptosNamesSelectColumnCurrentAptosNamesAggregateBoolExpBoolAndArgumentsColumns;
distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
filter?: InputMaybe<CurrentAptosNamesBoolExp>;
predicate: BooleanComparisonExp;
}
Type Alias CurrentAptosNamesAggregateBoolExpBoolOr
arguments: CurrentAptosNamesSelectColumnCurrentAptosNamesAggregateBoolExpBoolOrArgumentsColumns;
distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
filter?: InputMaybe<CurrentAptosNamesBoolExp>;
predicate: BooleanComparisonExp;
}
Type Alias CurrentAptosNamesAggregateBoolExpCount
arguments?: InputMaybe<CurrentAptosNamesSelectColumn[]>;
distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
filter?: InputMaybe<CurrentAptosNamesBoolExp>;
predicate: IntComparisonExp;
}
Type Alias CurrentAptosNamesBoolExp
_and?: InputMaybe<CurrentAptosNamesBoolExp[]>;
_not?: InputMaybe<CurrentAptosNamesBoolExp>;
_or?: InputMaybe<CurrentAptosNamesBoolExp[]>;
domain?: InputMaybe<StringComparisonExp>;
domain_expiration_timestamp?: InputMaybe<TimestampComparisonExp>;
domain_with_suffix?: InputMaybe<StringComparisonExp>;
expiration_timestamp?: InputMaybe<TimestampComparisonExp>;
is_active?: InputMaybe<BooleanComparisonExp>;
is_domain_owner?: InputMaybe<CurrentAptosNamesBoolExp>;
is_primary?: InputMaybe<BooleanComparisonExp>;
last_transaction_version?: InputMaybe<BigintComparisonExp>;
owner_address?: InputMaybe<StringComparisonExp>;
registered_address?: InputMaybe<StringComparisonExp>;
subdomain?: InputMaybe<StringComparisonExp>;
subdomain_expiration_policy?: InputMaybe<BigintComparisonExp>;
token_name?: InputMaybe<StringComparisonExp>;
token_standard?: InputMaybe<StringComparisonExp>;
}
Boolean expression to filter rows from the table "current_aptos_names". All fields are combined with a logical 'AND'.
+Type Alias CurrentFungibleAssetBalancesBoolExp
_and?: InputMaybe<CurrentFungibleAssetBalancesBoolExp[]>;
_not?: InputMaybe<CurrentFungibleAssetBalancesBoolExp>;
_or?: InputMaybe<CurrentFungibleAssetBalancesBoolExp[]>;
amount?: InputMaybe<NumericComparisonExp>;
asset_type?: InputMaybe<StringComparisonExp>;
is_frozen?: InputMaybe<BooleanComparisonExp>;
is_primary?: InputMaybe<BooleanComparisonExp>;
last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
last_transaction_version?: InputMaybe<BigintComparisonExp>;
metadata?: InputMaybe<FungibleAssetMetadataBoolExp>;
owner_address?: InputMaybe<StringComparisonExp>;
storage_id?: InputMaybe<StringComparisonExp>;
token_standard?: InputMaybe<StringComparisonExp>;
}
Boolean expression to filter rows from the table "current_unified_fungible_asset_balances_to_be_renamed". All fields are combined with a logical 'AND'.
+Type Alias EventArgs<T, K>
Type Parameters
- T extends ValidEventTypes
- K extends EventNames<T>
Type Alias EventListener<T, K>
? ((...args: any[]) => void)
: ((...args: ArgumentMap<Exclude<T, string | symbol>>[Extract<K, keyof T>]) => void)
Type Parameters
- T extends ValidEventTypes
- K extends EventNames<T>
Type Alias EventNames<T>
Type Parameters
- T extends ValidEventTypes
Type Alias ValidEventTypes
object should be in either of the following forms:
interface EventTypes {
'event-with-parameters': any[]
'event-with-example-handler': (...args: any[]) => void
}
+Type Alias EventsBoolExp
_and?: InputMaybe<EventsBoolExp[]>;
_not?: InputMaybe<EventsBoolExp>;
_or?: InputMaybe<EventsBoolExp[]>;
account_address?: InputMaybe<StringComparisonExp>;
creation_number?: InputMaybe<BigintComparisonExp>;
data?: InputMaybe<JsonbComparisonExp>;
event_index?: InputMaybe<BigintComparisonExp>;
indexed_type?: InputMaybe<StringComparisonExp>;
sequence_number?: InputMaybe<BigintComparisonExp>;
transaction_block_height?: InputMaybe<BigintComparisonExp>;
transaction_version?: InputMaybe<BigintComparisonExp>;
type?: InputMaybe<StringComparisonExp>;
}
Boolean expression to filter rows from the table "events". All fields are combined with a logical 'AND'.
+Type Alias FeePayerOrFeePayerAuthenticatorOrNeither
feePayer: Account;
feePayerAuthenticator?: never;
} | {
feePayer?: never;
feePayerAuthenticator: AccountAuthenticator;
} | {
feePayer?: never;
feePayerAuthenticator?: never;
}
Type Alias FungibleAssetActivitiesBoolExp
_and?: InputMaybe<FungibleAssetActivitiesBoolExp[]>;
_not?: InputMaybe<FungibleAssetActivitiesBoolExp>;
_or?: InputMaybe<FungibleAssetActivitiesBoolExp[]>;
amount?: InputMaybe<NumericComparisonExp>;
asset_type?: InputMaybe<StringComparisonExp>;
block_height?: InputMaybe<BigintComparisonExp>;
entry_function_id_str?: InputMaybe<StringComparisonExp>;
event_index?: InputMaybe<BigintComparisonExp>;
gas_fee_payer_address?: InputMaybe<StringComparisonExp>;
is_frozen?: InputMaybe<BooleanComparisonExp>;
is_gas_fee?: InputMaybe<BooleanComparisonExp>;
is_transaction_success?: InputMaybe<BooleanComparisonExp>;
metadata?: InputMaybe<FungibleAssetMetadataBoolExp>;
owner_address?: InputMaybe<StringComparisonExp>;
owner_aptos_names?: InputMaybe<CurrentAptosNamesBoolExp>;
owner_aptos_names_aggregate?: InputMaybe<CurrentAptosNamesAggregateBoolExp>;
storage_id?: InputMaybe<StringComparisonExp>;
storage_refund_amount?: InputMaybe<NumericComparisonExp>;
token_standard?: InputMaybe<StringComparisonExp>;
transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
transaction_version?: InputMaybe<BigintComparisonExp>;
type?: InputMaybe<StringComparisonExp>;
}
Boolean expression to filter rows from the table "fungible_asset_activities". All fields are combined with a logical 'AND'.
+Type Alias FungibleAssetMetadataBoolExp
_and?: InputMaybe<FungibleAssetMetadataBoolExp[]>;
_not?: InputMaybe<FungibleAssetMetadataBoolExp>;
_or?: InputMaybe<FungibleAssetMetadataBoolExp[]>;
asset_type?: InputMaybe<StringComparisonExp>;
creator_address?: InputMaybe<StringComparisonExp>;
decimals?: InputMaybe<IntComparisonExp>;
icon_uri?: InputMaybe<StringComparisonExp>;
last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
last_transaction_version?: InputMaybe<BigintComparisonExp>;
maximum_v2?: InputMaybe<NumericComparisonExp>;
name?: InputMaybe<StringComparisonExp>;
project_uri?: InputMaybe<StringComparisonExp>;
supply_aggregator_table_handle_v1?: InputMaybe<StringComparisonExp>;
supply_aggregator_table_key_v1?: InputMaybe<StringComparisonExp>;
supply_v2?: InputMaybe<NumericComparisonExp>;
symbol?: InputMaybe<StringComparisonExp>;
token_standard?: InputMaybe<StringComparisonExp>;
}
Boolean expression to filter rows from the table "fungible_asset_metadata". All fields are combined with a logical 'AND'.
+Type Alias GetAccountCoinsDataQuery
current_fungible_asset_balances: {
amount?: any | null;
asset_type?: string | null;
is_frozen: boolean;
is_primary?: boolean | null;
last_transaction_timestamp?: any | null;
last_transaction_version?: any | null;
metadata?: {
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: string | null;
last_transaction_timestamp: any;
last_transaction_version: any;
name: string;
project_uri?: string | null;
supply_aggregator_table_handle_v1?: string | null;
supply_aggregator_table_key_v1?: string | null;
symbol: string;
token_standard: string;
} | null;
owner_address: string;
storage_id: string;
token_standard?: string | null;
}[];
}
Type Alias GetAccountCollectionsWithOwnedTokensQuery
current_collection_ownership_v2_view: {
collection_id?: string | null;
collection_name?: string | null;
collection_uri?: string | null;
creator_address?: string | null;
current_collection?: {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any | null;
mutable_description?: boolean | null;
mutable_uri?: boolean | null;
table_handle_v1?: string | null;
token_standard: string;
total_minted_v2?: any | null;
uri: string;
} | null;
distinct_tokens?: any | null;
last_transaction_version?: any | null;
owner_address?: string | null;
single_token_uri?: string | null;
}[];
}
Type Alias GetAccountOwnedTokensFromCollectionQuery
current_token_ownerships_v2: {
amount: any;
current_token_data?: {
collection_id: string;
current_collection?: {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any | null;
mutable_description?: boolean | null;
mutable_uri?: boolean | null;
table_handle_v1?: string | null;
token_standard: string;
total_minted_v2?: any | null;
uri: string;
} | null;
decimals?: any | null;
description: string;
is_fungible_v2?: boolean | null;
largest_property_version_v1?: any | null;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any | null;
supply?: any | null;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
} | null;
is_fungible_v2?: boolean | null;
is_soulbound_v2?: boolean | null;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: string | null;
token_data_id: string;
token_properties_mutated_v1?: any | null;
token_standard: string;
}[];
}
Type Alias GetAccountOwnedTokensQuery
current_token_ownerships_v2: {
amount: any;
current_token_data?: {
collection_id: string;
current_collection?: {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any | null;
mutable_description?: boolean | null;
mutable_uri?: boolean | null;
table_handle_v1?: string | null;
token_standard: string;
total_minted_v2?: any | null;
uri: string;
} | null;
decimals?: any | null;
description: string;
is_fungible_v2?: boolean | null;
largest_property_version_v1?: any | null;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any | null;
supply?: any | null;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
} | null;
is_fungible_v2?: boolean | null;
is_soulbound_v2?: boolean | null;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: string | null;
token_data_id: string;
token_properties_mutated_v1?: any | null;
token_standard: string;
}[];
}
Type Alias GetChainTopUserTransactionsQuery
user_transactions: {
version: any;
}[];
}
Type Alias GetCollectionDataQuery
current_collections_v2: {
cdn_asset_uris?: {
animation_optimizer_retry_count: number;
asset_uri: string;
cdn_animation_uri?: string | null;
cdn_image_uri?: string | null;
cdn_json_uri?: string | null;
image_optimizer_retry_count: number;
json_parser_retry_count: number;
raw_animation_uri?: string | null;
raw_image_uri?: string | null;
} | null;
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any | null;
mutable_description?: boolean | null;
mutable_uri?: boolean | null;
table_handle_v1?: string | null;
token_standard: string;
total_minted_v2?: any | null;
uri: string;
}[];
}
Type Alias GetCurrentFungibleAssetBalancesQuery
current_fungible_asset_balances: {
amount?: any | null;
asset_type?: string | null;
is_frozen: boolean;
is_primary?: boolean | null;
last_transaction_timestamp?: any | null;
last_transaction_version?: any | null;
owner_address: string;
storage_id: string;
token_standard?: string | null;
}[];
}
Type Alias GetCurrentTokenOwnershipQuery
current_token_ownerships_v2: {
amount: any;
current_token_data?: {
collection_id: string;
current_collection?: {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any | null;
mutable_description?: boolean | null;
mutable_uri?: boolean | null;
table_handle_v1?: string | null;
token_standard: string;
total_minted_v2?: any | null;
uri: string;
} | null;
decimals?: any | null;
description: string;
is_fungible_v2?: boolean | null;
largest_property_version_v1?: any | null;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any | null;
supply?: any | null;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
} | null;
is_fungible_v2?: boolean | null;
is_soulbound_v2?: boolean | null;
last_transaction_timestamp: any;
last_transaction_version: any;
owner_address: string;
property_version_v1: any;
storage_id: string;
table_type_v1?: string | null;
token_data_id: string;
token_properties_mutated_v1?: any | null;
token_standard: string;
}[];
}
Type Alias GetDelegatedStakingActivitiesQuery
delegated_staking_activities: {
amount: any;
delegator_address: string;
event_index: any;
event_type: string;
pool_address: string;
transaction_version: any;
}[];
}
Type Alias GetEventsQuery
events: {
account_address: string;
creation_number: any;
data: any;
event_index: any;
indexed_type: string;
sequence_number: any;
transaction_block_height: any;
transaction_version: any;
type: string;
}[];
}
Type Alias GetFungibleAssetActivitiesQuery
fungible_asset_activities: {
amount?: any | null;
asset_type?: string | null;
block_height: any;
entry_function_id_str?: string | null;
event_index: any;
gas_fee_payer_address?: string | null;
is_frozen?: boolean | null;
is_gas_fee: boolean;
is_transaction_success: boolean;
owner_address?: string | null;
storage_id: string;
storage_refund_amount: any;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}[];
}
Type Alias GetFungibleAssetMetadataQuery
fungible_asset_metadata: {
asset_type: string;
creator_address: string;
decimals: number;
icon_uri?: string | null;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum_v2?: any | null;
name: string;
project_uri?: string | null;
supply_aggregator_table_handle_v1?: string | null;
supply_aggregator_table_key_v1?: string | null;
supply_v2?: any | null;
symbol: string;
token_standard: string;
}[];
}
Type Alias GetNamesQuery
current_aptos_names: {
domain?: string | null;
domain_expiration_timestamp?: any | null;
expiration_timestamp?: any | null;
is_primary?: boolean | null;
owner_address?: string | null;
registered_address?: string | null;
subdomain?: string | null;
subdomain_expiration_policy?: any | null;
token_standard?: string | null;
}[];
}
Type Alias GetNumberOfDelegatorsQuery
num_active_delegator_per_pool: {
num_active_delegator?: any | null;
pool_address?: string | null;
}[];
}
Type Alias GetObjectDataQuery
current_objects: {
allow_ungated_transfer: boolean;
is_deleted: boolean;
last_guid_creation_num: any;
last_transaction_version: any;
object_address: string;
owner_address: string;
state_key_hash: string;
}[];
}
Type Alias GetProcessorStatusQuery
processor_status: {
last_success_version: any;
last_updated: any;
processor: string;
}[];
}
Type Alias GetTableItemsDataQuery
table_items: {
decoded_key: any;
decoded_value?: any | null;
key: string;
table_handle: string;
transaction_version: any;
write_set_change_index: any;
}[];
}
Type Alias GetTableItemsMetadataQuery
table_metadatas: {
handle: string;
key_type: string;
value_type: string;
}[];
}
Type Alias GetTokenActivityQuery
token_activities_v2: {
after_value?: string | null;
before_value?: string | null;
entry_function_id_str?: string | null;
event_account_address: string;
event_index: any;
from_address?: string | null;
is_fungible_v2?: boolean | null;
property_version_v1: any;
to_address?: string | null;
token_amount: any;
token_data_id: string;
token_standard: string;
transaction_timestamp: any;
transaction_version: any;
type: string;
}[];
}
Type Alias GetTokenDataQuery
current_token_datas_v2: {
collection_id: string;
current_collection?: {
collection_id: string;
collection_name: string;
creator_address: string;
current_supply: any;
description: string;
last_transaction_timestamp: any;
last_transaction_version: any;
max_supply?: any | null;
mutable_description?: boolean | null;
mutable_uri?: boolean | null;
table_handle_v1?: string | null;
token_standard: string;
total_minted_v2?: any | null;
uri: string;
} | null;
decimals?: any | null;
description: string;
is_fungible_v2?: boolean | null;
largest_property_version_v1?: any | null;
last_transaction_timestamp: any;
last_transaction_version: any;
maximum?: any | null;
supply?: any | null;
token_data_id: string;
token_name: string;
token_properties: any;
token_standard: string;
token_uri: string;
}[];
}
Type Alias Groth16VerificationKeyResponse
alpha_g1: string;
beta_g2: string;
delta_g2: string;
gamma_abc_g1: [string, string];
gamma_g2: string;
}
The response containing the Groth16 verification key, including the alpha_g1 component.
+Type Alias IntComparisonExp
_eq?: InputMaybe<Scalars["Int"]["input"]>;
_gt?: InputMaybe<Scalars["Int"]["input"]>;
_gte?: InputMaybe<Scalars["Int"]["input"]>;
_in?: InputMaybe<Scalars["Int"]["input"][]>;
_is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
_lt?: InputMaybe<Scalars["Int"]["input"]>;
_lte?: InputMaybe<Scalars["Int"]["input"]>;
_neq?: InputMaybe<Scalars["Int"]["input"]>;
_nin?: InputMaybe<Scalars["Int"]["input"][]>;
}
Boolean expression to compare columns of type "Int". All fields are combined with logical 'AND'.
+Type Alias JsonbCastExp
Type Alias JsonbComparisonExp
_cast?: InputMaybe<JsonbCastExp>;
_contained_in?: InputMaybe<Scalars["jsonb"]["input"]>;
_contains?: InputMaybe<Scalars["jsonb"]["input"]>;
_eq?: InputMaybe<Scalars["jsonb"]["input"]>;
_gt?: InputMaybe<Scalars["jsonb"]["input"]>;
_gte?: InputMaybe<Scalars["jsonb"]["input"]>;
_has_key?: InputMaybe<Scalars["String"]["input"]>;
_has_keys_all?: InputMaybe<Scalars["String"]["input"][]>;
_has_keys_any?: InputMaybe<Scalars["String"]["input"][]>;
_in?: InputMaybe<Scalars["jsonb"]["input"][]>;
_is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
_lt?: InputMaybe<Scalars["jsonb"]["input"]>;
_lte?: InputMaybe<Scalars["jsonb"]["input"]>;
_neq?: InputMaybe<Scalars["jsonb"]["input"]>;
_nin?: InputMaybe<Scalars["jsonb"]["input"][]>;
}
Boolean expression to compare columns of type "jsonb". All fields are combined with logical 'AND'.
+Type declaration
Optional_cast?: InputMaybe<JsonbCastExp>Optional_contained_in?: InputMaybe<Scalars["jsonb"]["input"]> is the column contained in the given json value
+Optional_contains?: InputMaybe<Scalars["jsonb"]["input"]>does the column contain the given json value at the top level
+Optional_eq?: InputMaybe<Scalars["jsonb"]["input"]>Optional_gt?: InputMaybe<Scalars["jsonb"]["input"]>Optional_gte?: InputMaybe<Scalars["jsonb"]["input"]>Optional_has_key?: InputMaybe<Scalars["String"]["input"]> does the string exist as a top-level key in the column
+Optional_has_keys_ all?: InputMaybe<Scalars["String"]["input"][]> do all of these strings exist as top-level keys in the column
+Optional_has_keys_ any?: InputMaybe<Scalars["String"]["input"][]> do any of these strings exist as top-level keys in the column
+Optional_in?: InputMaybe<Scalars["jsonb"]["input"][]>Optional_is_null?: InputMaybe<Scalars["Boolean"]["input"]> Optional_lt?: InputMaybe<Scalars["jsonb"]["input"]>Optional_lte?: InputMaybe<Scalars["jsonb"]["input"]>Optional_neq?: InputMaybe<Scalars["jsonb"]["input"]>Optional_nin?: InputMaybe<Scalars["jsonb"]["input"][]>
Type Alias MoveAnyStruct
variant: {
data: string;
type_name: string;
};
}
Type Alias NumericComparisonExp
_eq?: InputMaybe<Scalars["numeric"]["input"]>;
_gt?: InputMaybe<Scalars["numeric"]["input"]>;
_gte?: InputMaybe<Scalars["numeric"]["input"]>;
_in?: InputMaybe<Scalars["numeric"]["input"][]>;
_is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
_lt?: InputMaybe<Scalars["numeric"]["input"]>;
_lte?: InputMaybe<Scalars["numeric"]["input"]>;
_neq?: InputMaybe<Scalars["numeric"]["input"]>;
_nin?: InputMaybe<Scalars["numeric"]["input"][]>;
}
Boolean expression to compare columns of type "numeric". All fields are combined with logical 'AND'.
+Type Alias PropertyValue
Accepted property value types for user input, including boolean, number, bigint, string, AccountAddress, and Uint8Array.
+To pass in an Array, use Uint8Array type
+for example new MoveVector([new MoveString("hello"), new MoveString("world")]).bcsToBytes()
Type Alias Scalars
bigint: {
input: any;
output: any;
};
Boolean: {
input: boolean;
output: boolean;
};
Float: {
input: number;
output: number;
};
ID: {
input: string;
output: string;
};
Int: {
input: number;
output: number;
};
jsonb: {
input: any;
output: any;
};
numeric: {
input: any;
output: any;
};
String: {
input: string;
output: string;
};
timestamp: {
input: any;
output: any;
};
timestamptz: {
input: any;
output: any;
};
}
All built-in and custom scalars, mapped to their actual values
+Type Alias StringComparisonExp
_eq?: InputMaybe<Scalars["String"]["input"]>;
_gt?: InputMaybe<Scalars["String"]["input"]>;
_gte?: InputMaybe<Scalars["String"]["input"]>;
_ilike?: InputMaybe<Scalars["String"]["input"]>;
_in?: InputMaybe<Scalars["String"]["input"][]>;
_iregex?: InputMaybe<Scalars["String"]["input"]>;
_is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
_like?: InputMaybe<Scalars["String"]["input"]>;
_lt?: InputMaybe<Scalars["String"]["input"]>;
_lte?: InputMaybe<Scalars["String"]["input"]>;
_neq?: InputMaybe<Scalars["String"]["input"]>;
_nilike?: InputMaybe<Scalars["String"]["input"]>;
_nin?: InputMaybe<Scalars["String"]["input"][]>;
_niregex?: InputMaybe<Scalars["String"]["input"]>;
_nlike?: InputMaybe<Scalars["String"]["input"]>;
_nregex?: InputMaybe<Scalars["String"]["input"]>;
_nsimilar?: InputMaybe<Scalars["String"]["input"]>;
_regex?: InputMaybe<Scalars["String"]["input"]>;
_similar?: InputMaybe<Scalars["String"]["input"]>;
}
Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'.
+Type declaration
Optional_eq?: InputMaybe<Scalars["String"]["input"]>Optional_gt?: InputMaybe<Scalars["String"]["input"]>Optional_gte?: InputMaybe<Scalars["String"]["input"]>Optional_ilike?: InputMaybe<Scalars["String"]["input"]>does the column match the given case-insensitive pattern
+Optional_in?: InputMaybe<Scalars["String"]["input"][]>Optional_iregex?: InputMaybe<Scalars["String"]["input"]>does the column match the given POSIX regular expression, case insensitive
+Optional_is_null?: InputMaybe<Scalars["Boolean"]["input"]> Optional_like?: InputMaybe<Scalars["String"]["input"]>does the column match the given pattern
+Optional_lt?: InputMaybe<Scalars["String"]["input"]>Optional_lte?: InputMaybe<Scalars["String"]["input"]>Optional_neq?: InputMaybe<Scalars["String"]["input"]>Optional_nilike?: InputMaybe<Scalars["String"]["input"]>does the column NOT match the given case-insensitive pattern
+Optional_nin?: InputMaybe<Scalars["String"]["input"][]>Optional_niregex?: InputMaybe<Scalars["String"]["input"]>does the column NOT match the given POSIX regular expression, case insensitive
+Optional_nlike?: InputMaybe<Scalars["String"]["input"]>does the column NOT match the given pattern
+Optional_nregex?: InputMaybe<Scalars["String"]["input"]>does the column NOT match the given POSIX regular expression, case sensitive
+Optional_nsimilar?: InputMaybe<Scalars["String"]["input"]>does the column NOT match the given SQL regular expression
+Optional_regex?: InputMaybe<Scalars["String"]["input"]>does the column match the given POSIX regular expression, case sensitive
+Optional_similar?: InputMaybe<Scalars["String"]["input"]>does the column match the given SQL regular expression
+
Type Alias TableItemsBoolExp
_and?: InputMaybe<TableItemsBoolExp[]>;
_not?: InputMaybe<TableItemsBoolExp>;
_or?: InputMaybe<TableItemsBoolExp[]>;
decoded_key?: InputMaybe<JsonbComparisonExp>;
decoded_value?: InputMaybe<JsonbComparisonExp>;
key?: InputMaybe<StringComparisonExp>;
table_handle?: InputMaybe<StringComparisonExp>;
transaction_version?: InputMaybe<BigintComparisonExp>;
write_set_change_index?: InputMaybe<BigintComparisonExp>;
}
Boolean expression to filter rows from the table "table_items". All fields are combined with a logical 'AND'.
+Type Alias TableMetadatasBoolExp
_and?: InputMaybe<TableMetadatasBoolExp[]>;
_not?: InputMaybe<TableMetadatasBoolExp>;
_or?: InputMaybe<TableMetadatasBoolExp[]>;
handle?: InputMaybe<StringComparisonExp>;
key_type?: InputMaybe<StringComparisonExp>;
value_type?: InputMaybe<StringComparisonExp>;
}
Boolean expression to filter rows from the table "table_metadatas". All fields are combined with a logical 'AND'.
+Type Alias TimestampComparisonExp
_eq?: InputMaybe<Scalars["timestamp"]["input"]>;
_gt?: InputMaybe<Scalars["timestamp"]["input"]>;
_gte?: InputMaybe<Scalars["timestamp"]["input"]>;
_in?: InputMaybe<Scalars["timestamp"]["input"][]>;
_is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
_lt?: InputMaybe<Scalars["timestamp"]["input"]>;
_lte?: InputMaybe<Scalars["timestamp"]["input"]>;
_neq?: InputMaybe<Scalars["timestamp"]["input"]>;
_nin?: InputMaybe<Scalars["timestamp"]["input"][]>;
}
Boolean expression to compare columns of type "timestamp". All fields are combined with logical 'AND'.
+Variable APTOS_BIP44_REGEXConst
Variable APTOS_COINConst
The default gas currency for the network.
+Variable APTOS_FAConst
Variable APTOS_HARDENED_REGEXConst
Aptos derive path is 637
+Variable DEFAULT_MAX_GAS_AMOUNTConst
The default max gas amount when none is given.
+This is the maximum number of gas units that will be used by a transaction before being rejected.
+Note that max gas amount varies based on the transaction. A larger transaction will go over this +default gas amount, and the value will need to be changed for the specific transaction.
+Variable DEFAULT_TXN_EXP_SEC_FROM_NOWConst
The default transaction expiration seconds from now.
+This time is how long until the blockchain nodes will reject the transaction.
+Note that the transaction expiration time varies based on network connection and network load. It may need to be +increased for the transaction to be processed.
+Variable DEFAULT_TXN_TIMEOUT_SECConst
The default number of seconds to wait for a transaction to be processed.
+This time is the amount of time that the SDK will wait for a transaction to be processed when waiting for +the results of the transaction. It may take longer based on network connection and network load.
+Variable EPK_HORIZON_SECSConst
Variable FIREBASE_AUTH_ISS_PATTERNConst
Regular expression pattern for Firebase Auth issuer URLs +Matches URLs in the format: https://securetoken.google.com/[project-id] +where project-id can contain letters, numbers, hyphens, and underscores
+
Account implementation for the Keyless authentication scheme. This abstract class is used for standard Keyless Accounts +and Federated Keyless Accounts.
+