Serializes a Serializable value to its BCS representation.
This function is the TypeScript SDK equivalent of bcs::to_bytes in Move.
the BCS representation of the Serializable instance as a byte buffer.
Converts the BCS-serialized bytes of a value into a Hex instance. This function provides a Hex representation of the BCS-serialized data for easier handling and manipulation.
A Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array.
Constructs an instance with the specified parameters for cryptographic operations.
ReadonlyidA value representing a cryptographic commitment to a user identity.
It is calculated from the aud, uidKey, uidVal, pepper.
ReadonlyissThe value of the 'iss' claim on the JWT which identifies the OIDC provider.
Static ReadonlyID_The number of bytes that idCommitment should be
Get the authentication key for the keyless public key.
AuthenticationKey - The authentication key derived from the keyless public key.
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.
The serializer instance used to perform the serialization.
Get the public key as a hex string with a 0x prefix.
The public key in hex format.
Get the raw public key bytes
Verifies the validity of a signature for a given message.
The arguments for signature verification.
The JWK to use for verification.
The keyless configuration to use for verification.
The message that was signed.
The signature to verify against the message.
true if the signature is valid; otherwise, false.
StaticcreateCreates a KeylessPublicKey from the JWT components plus pepper
the client ID of the application
the iss of the identity
The pepper used to maintain privacy of the account
the key to use to get the uidVal in the JWT token
the value of the uidKey in the JWT token
KeylessPublicKey
StaticdeserializeDeserializes a ZeroKnowledgeSig object from the provided deserializer. This function allows you to reconstruct a ZeroKnowledgeSig instance from its serialized form.
The deserializer instance used to read the serialized data.
A new instance of ZeroKnowledgeSig.
StaticfromCreates 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.
The arguments for creating the KeylessPublicKey.
The JSON Web Token to decode.
The pepper value used in the key creation process.
OptionaluidKey?: stringAn optional key to retrieve the unique identifier from the JWT payload, defaults to "sub".
A KeylessPublicKey instance created from the provided JWT and pepper.
StaticisChecks if the provided public key is a valid instance by verifying its structure and types.
The public key to validate.
A boolean indicating whether the public key is a valid instance.
StaticisDetermines if the provided public key is an instance of KeylessPublicKey.
The public key to check.
A boolean indicating whether the public key is a KeylessPublicKey instance.
StaticloadLoads a KeylessPublicKey instance from the provided deserializer. This function is used to deserialize the necessary components to create a KeylessPublicKey.
The deserializer used to extract the string and byte data.
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.
Creates a new instance of the class with a copy of the provided data buffer. This prevents outside mutation of the buffer.
The data to be copied into the internal buffer as a Uint8Array.
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 call deserializer.deserialize(MyClass).
The BCS-deserializable class to deserialize the buffered bytes into.
the deserialized value of class type T
Deserializes a boolean value from a byte stream.
The BCS layout for a boolean uses one byte, where "0x01" represents true and "0x00" represents false. An error is thrown if the byte value is not valid.
The deserialized boolean value.
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.
The deserialized array of bytes.
Deserializes an array of bytes of a specified length.
The number of bytes to read from the source.
Deserializes an optional value from the buffer.
The BCS layout for Optional
Either a Deserializable class or one of the string literals: "string", "bytes", or "fixedBytes"
The deserialized value if present, undefined otherwise
// 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]
Deserializes an optional value from the buffer.
The BCS layout for Optional
Either a Deserializable class or one of the string literals: "string", "bytes", or "fixedBytes"
The deserialized value if present, undefined otherwise
// 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]
Deserializes an optional value from the buffer.
The BCS layout for Optional
Either a Deserializable class or one of the string literals: "string", "bytes", or "fixedBytes"
Required length when type is "fixedBytes", ignored otherwise
The deserialized value if present, undefined otherwise
// 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]
Deserializes an optional value from the buffer.
The BCS layout for Optional
Either a Deserializable class or one of the string literals: "string", "bytes", or "fixedBytes"
The deserialized value if present, undefined otherwise
// 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]
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.
Deserializes a uint128 number from its binary representation. This function combines two 64-bit values to return a single uint128 value in little-endian format.
The deserialized uint128 number.
Deserializes a uint256 number from its binary representation.
The BCS layout for "uint256" consists of thirty-two bytes in little-endian format.
The deserialized uint256 number.
Deserializes a uint64 number.
This function combines two 32-bit values to return a 64-bit unsigned integer in little-endian representation.
Deserializes a uint8 number from the binary data.
BCS layout for "uint8": One byte. Binary format in little-endian representation.
The deserialized uint8 number.
Deserializes an array of BCS Deserializable values given an existing Deserializer instance with a loaded byte buffer.
The BCS-deserializable class to deserialize the buffered bytes into.
An array of deserialized values of type T.
// 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
Returns the number of bytes remaining in the buffer.
This information is useful to determine if there's more data to be read.
The number of bytes remaining in the buffer.
A new instance of KeylessPublicKey.
Returns the hex string representation of the Serializable value without the 0x prefix.
the hex format as a string without 0x prefix.
Verifies a keyless signature for a given message. It will fetch the keyless configuration and the JWK to use for verification from the appropriate network as defined by the aptosConfig.
The aptos config to use for fetching the keyless configuration.
The message to verify the signature against.
Optionaloptions?: { throwErrorWithReason?: boolean }OptionalthrowErrorWithReason?: booleanWhether to throw an error with the reason for the failure instead of returning false.
The signature to verify.
true if the signature is valid
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.