@aptos-labs/ts-sdk 1.8.0 → 1.9.0

package/dist/browser/index.d.ts

@@ -1,36 +1,5 @@
 import EventEmitter from 'eventemitter3';
 
-/**
- * This error is used to explain why parsing failed.
- */
-declare class ParsingError<T> extends Error {
-    /**
-     * 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.
-     */
-    invalidReason: T;
-    constructor(message: string, invalidReason: T);
-}
-/**
- * Whereas ParsingError is thrown when parsing fails, e.g. in a fromString function,
- * this type is returned from "defensive" functions like isValid.
- */
-type ParsingResult<T> = {
-    /**
-     * True if valid, false otherwise.
-     */
-    valid: boolean;
-    /**
-     * If valid is false, this will be a code explaining why parsing failed.
-     */
-    invalidReason?: T;
-    /**
-     * If valid is false, this will be a string explaining why parsing failed.
-     */
-    invalidReasonMessage?: string;
-};
-
 declare const NetworkToIndexerAPI: Record<string, string>;
 declare const NetworkToNodeAPI: Record<string, string>;
 declare const NetworkToFaucetAPI: Record<string, string>;
@@ -1731,6 +1700,180 @@ type GenerateAccountWithSingleSignerSecp256k1Key = {
 };
 type GenerateAccount = GenerateAccountWithEd25519 | GenerateAccountWithSingleSignerSecp256k1Key;
 
+/**
+ * This interface exists to define Deserializable<T> inputs for functions that
+ * deserialize a byte buffer into a type T.
+ * It is not intended to be implemented or extended, because Typescript has no support
+ * for static methods in interfaces.
+ */
+interface Deserializable<T> {
+    deserialize(deserializer: Deserializer): T;
+}
+declare class Deserializer {
+    private buffer;
+    private offset;
+    constructor(data: Uint8Array);
+    private read;
+    /**
+     * Deserializes a string. UTF8 string is supported. Reads the string's bytes length "l" first,
+     * and then reads "l" bytes of content. Decodes the byte array 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.
+     *
+     * @example
+     * ```ts
+     * const deserializer = new Deserializer(new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
+     * assert(deserializer.deserializeStr() === "1234abcd");
+     * ```
+     */
+    deserializeStr(): string;
+    /**
+     * Deserializes an array of bytes.
+     *
+     * 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.
+     */
+    deserializeBytes(): Uint8Array;
+    /**
+     * Deserializes an array of bytes. The number of bytes to read is already known.
+     *
+     */
+    deserializeFixedBytes(len: number): Uint8Array;
+    /**
+     * Deserializes a boolean value.
+     *
+     * BCS layout for "boolean": One byte. "0x01" for true and "0x00" for false.
+     */
+    deserializeBool(): boolean;
+    /**
+     * Deserializes a uint8 number.
+     *
+     * BCS layout for "uint8": One byte. Binary format in little-endian representation.
+     */
+    deserializeU8(): Uint8;
+    /**
+     * Deserializes a uint16 number.
+     *
+     * BCS layout for "uint16": Two bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const deserializer = new Deserializer(new Uint8Array([0x34, 0x12]));
+     * assert(deserializer.deserializeU16() === 4660);
+     * ```
+     */
+    deserializeU16(): Uint16;
+    /**
+     * Deserializes a uint32 number.
+     *
+     * BCS layout for "uint32": Four bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const deserializer = new Deserializer(new Uint8Array([0x78, 0x56, 0x34, 0x12]));
+     * assert(deserializer.deserializeU32() === 305419896);
+     * ```
+     */
+    deserializeU32(): Uint32;
+    /**
+     * Deserializes a uint64 number.
+     *
+     * BCS layout for "uint64": Eight bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const deserializer = new Deserializer(new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
+     * assert(deserializer.deserializeU64() === 1311768467750121216);
+     * ```
+     */
+    deserializeU64(): Uint64;
+    /**
+     * Deserializes a uint128 number.
+     *
+     * BCS layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
+     */
+    deserializeU128(): Uint128;
+    /**
+     * Deserializes a uint256 number.
+     *
+     * BCS layout for "uint256": Thirty-two bytes. Binary format in little-endian representation.
+     */
+    deserializeU256(): Uint256;
+    /**
+     * Deserializes a uleb128 encoded uint32 number.
+     *
+     * BCS use uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
+     */
+    deserializeUleb128AsU32(): Uint32;
+    /**
+     * 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)`.
+     *
+     * @example const deserializer = new Deserializer(new Uint8Array([1, 2, 3]));
+     * const value = deserializer.deserialize(MyClass); // where MyClass has a `deserialize` function
+     * // value is now an instance of MyClass
+     * // equivalent to `const value = MyClass.deserialize(deserializer)`
+     * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
+     *
+     * @returns the deserialized value of class type T
+     */
+    deserialize<T>(cls: Deserializable<T>): T;
+    /**
+     * Deserializes an array of BCS Deserializable values given an existing Deserializer
+     * instance with a loaded byte buffer.
+     *
+     * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
+     * @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
+     * @returns an array of deserialized values of type T
+     */
+    deserializeVector<T>(cls: Deserializable<T>): Array<T>;
+}
+
+/**
+ * This error is used to explain why parsing failed.
+ */
+declare class ParsingError<T> extends Error {
+    /**
+     * 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.
+     */
+    invalidReason: T;
+    constructor(message: string, invalidReason: T);
+}
+/**
+ * Whereas ParsingError is thrown when parsing fails, e.g. in a fromString function,
+ * this type is returned from "defensive" functions like isValid.
+ */
+type ParsingResult<T> = {
+    /**
+     * True if valid, false otherwise.
+     */
+    valid: boolean;
+    /**
+     * If valid is false, this will be a code explaining why parsing failed.
+     */
+    invalidReason?: T;
+    /**
+     * If valid is false, this will be a string explaining why parsing failed.
+     */
+    invalidReasonMessage?: string;
+};
+
 /**
  * This enum is used to explain why parsing might have failed.
  */
@@ -2011,169 +2154,26 @@ declare function ensureBoolean(value: unknown): asserts value is boolean;
 declare const outOfRangeErrorMessage: (value: AnyNumber, min: AnyNumber, max: AnyNumber) => string;
 declare function validateNumberInRange<T extends AnyNumber>(value: T, minValue: T, maxValue: T): void;
 
-/**
- * This interface exists to define Deserializable<T> inputs for functions that
- * deserialize a byte buffer into a type T.
- * It is not intended to be implemented or extended, because Typescript has no support
- * for static methods in interfaces.
- */
-interface Deserializable<T> {
-    deserialize(deserializer: Deserializer): T;
+interface TransactionArgument extends EntryFunctionArgument, ScriptFunctionArgument {
 }
-declare class Deserializer {
-    private buffer;
-    private offset;
-    constructor(data: Uint8Array);
-    private read;
+interface EntryFunctionArgument {
     /**
-     * Deserializes a string. UTF8 string is supported. Reads the string's bytes length "l" first,
-     * and then reads "l" bytes of content. Decodes the byte array 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.
-     *
-     * @example
-     * ```ts
-     * const deserializer = new Deserializer(new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
-     * assert(deserializer.deserializeStr() === "1234abcd");
-     * ```
+     * Serialize an argument to BCS-serialized bytes.
      */
-    deserializeStr(): string;
+    serialize(serializer: Serializer): void;
     /**
-     * Deserializes an array of bytes.
-     *
-     * 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.
+     * 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.
      */
-    deserializeBytes(): Uint8Array;
+    serializeForEntryFunction(serializer: Serializer): void;
+    bcsToBytes(): Uint8Array;
+    bcsToHex(): Hex;
+}
+interface ScriptFunctionArgument {
     /**
-     * Deserializes an array of bytes. The number of bytes to read is already known.
-     *
+     * Serialize an argument to BCS-serialized bytes.
      */
-    deserializeFixedBytes(len: number): Uint8Array;
-    /**
-     * Deserializes a boolean value.
-     *
-     * BCS layout for "boolean": One byte. "0x01" for true and "0x00" for false.
-     */
-    deserializeBool(): boolean;
-    /**
-     * Deserializes a uint8 number.
-     *
-     * BCS layout for "uint8": One byte. Binary format in little-endian representation.
-     */
-    deserializeU8(): Uint8;
-    /**
-     * Deserializes a uint16 number.
-     *
-     * BCS layout for "uint16": Two bytes. Binary format in little-endian representation.
-     * @example
-     * ```ts
-     * const deserializer = new Deserializer(new Uint8Array([0x34, 0x12]));
-     * assert(deserializer.deserializeU16() === 4660);
-     * ```
-     */
-    deserializeU16(): Uint16;
-    /**
-     * Deserializes a uint32 number.
-     *
-     * BCS layout for "uint32": Four bytes. Binary format in little-endian representation.
-     * @example
-     * ```ts
-     * const deserializer = new Deserializer(new Uint8Array([0x78, 0x56, 0x34, 0x12]));
-     * assert(deserializer.deserializeU32() === 305419896);
-     * ```
-     */
-    deserializeU32(): Uint32;
-    /**
-     * Deserializes a uint64 number.
-     *
-     * BCS layout for "uint64": Eight bytes. Binary format in little-endian representation.
-     * @example
-     * ```ts
-     * const deserializer = new Deserializer(new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
-     * assert(deserializer.deserializeU64() === 1311768467750121216);
-     * ```
-     */
-    deserializeU64(): Uint64;
-    /**
-     * Deserializes a uint128 number.
-     *
-     * BCS layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
-     */
-    deserializeU128(): Uint128;
-    /**
-     * Deserializes a uint256 number.
-     *
-     * BCS layout for "uint256": Thirty-two bytes. Binary format in little-endian representation.
-     */
-    deserializeU256(): Uint256;
-    /**
-     * Deserializes a uleb128 encoded uint32 number.
-     *
-     * BCS use uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
-     */
-    deserializeUleb128AsU32(): Uint32;
-    /**
-     * 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)`.
-     *
-     * @example const deserializer = new Deserializer(new Uint8Array([1, 2, 3]));
-     * const value = deserializer.deserialize(MyClass); // where MyClass has a `deserialize` function
-     * // value is now an instance of MyClass
-     * // equivalent to `const value = MyClass.deserialize(deserializer)`
-     * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
-     *
-     * @returns the deserialized value of class type T
-     */
-    deserialize<T>(cls: Deserializable<T>): T;
-    /**
-     * Deserializes an array of BCS Deserializable values given an existing Deserializer
-     * instance with a loaded byte buffer.
-     *
-     * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
-     * @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
-     * @returns an array of deserialized values of type T
-     */
-    deserializeVector<T>(cls: Deserializable<T>): Array<T>;
-}
-
-interface TransactionArgument extends EntryFunctionArgument, ScriptFunctionArgument {
-}
-interface EntryFunctionArgument {
-    /**
-     * Serialize an argument to BCS-serialized bytes.
-     */
-    serialize(serializer: Serializer): void;
-    /**
-     * 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.
-     */
-    serializeForEntryFunction(serializer: Serializer): void;
-    bcsToBytes(): Uint8Array;
-    bcsToHex(): Hex;
-}
-interface ScriptFunctionArgument {
-    /**
-     * Serialize an argument to BCS-serialized bytes.
-     */
-    serialize(serializer: Serializer): void;
+    serialize(serializer: 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
@@ -2184,238 +2184,6 @@ interface ScriptFunctionArgument {
     bcsToHex(): Hex;
 }
 
-/**
- * This enum is used to explain why an address was invalid.
- */
-declare enum AddressInvalidReason {
-    INCORRECT_NUMBER_OF_BYTES = "incorrect_number_of_bytes",
-    INVALID_HEX_CHARS = "invalid_hex_chars",
-    TOO_SHORT = "too_short",
-    TOO_LONG = "too_long",
-    LEADING_ZERO_X_REQUIRED = "leading_zero_x_required",
-    LONG_FORM_REQUIRED_UNLESS_SPECIAL = "long_form_required_unless_special",
-    INVALID_PADDING_ZEROES = "INVALID_PADDING_ZEROES"
-}
-type AccountAddressInput = HexInput | 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.
- */
-declare class AccountAddress extends Serializable implements TransactionArgument {
-    /**
-     * This is the internal representation of an account address.
-     */
-    readonly data: Uint8Array;
-    /**
-     * The number of bytes that make up an account address.
-     */
-    static readonly LENGTH: number;
-    /**
-     * The length of an address string in LONG form without a leading 0x.
-     */
-    static readonly LONG_STRING_LENGTH: number;
-    static ZERO: AccountAddress;
-    static ONE: AccountAddress;
-    static TWO: AccountAddress;
-    static THREE: AccountAddress;
-    static FOUR: AccountAddress;
-    /**
-     * Creates an instance of AccountAddress from a Uint8Array.
-     *
-     * @param args.data A Uint8Array representing an account address.
-     */
-    constructor(input: Uint8Array);
-    /**
-     * Returns whether an address is special, where special 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 true if the address is special, false if not.
-     */
-    isSpecial(): boolean;
-    /**
-     * Return the AccountAddress as a string as per AIP-40.
-     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
-     *
-     * In short, it means that special addresses are represented in SHORT form, meaning
-     * 0x0 through to 0xf inclusive, and every other address is represented in LONG form,
-     * meaning 0x + 64 hex characters.
-     *
-     * @returns AccountAddress as a string conforming to AIP-40.
-     */
-    toString(): `0x${string}`;
-    /**
-     * NOTE: Prefer to use `toString` where possible.
-     *
-     * Return the AccountAddress as a string as per AIP-40 but without the leading 0x.
-     *
-     * Learn more by reading the docstring of `toString`.
-     *
-     * @returns AccountAddress as a string conforming to AIP-40 but without the leading 0x.
-     */
-    toStringWithoutPrefix(): string;
-    /**
-     * NOTE: Prefer to use `toString` where possible.
-     *
-     * Whereas toString will format special addresses (as defined by isSpecial) using the
-     * SHORT form (no leading 0s), this format the address in the LONG format
-     * unconditionally.
-     *
-     * This means it will be 0x + 64 hex characters.
-     *
-     * @returns AccountAddress as a string in LONG form.
-     */
-    toStringLong(): `0x${string}`;
-    /**
-     * NOTE: Prefer to use `toString` where possible.
-     *
-     * Whereas toString will format special addresses (as defined by isSpecial) using the
-     * SHORT form (no leading 0s), this function will include leading zeroes. The string
-     * will not have a leading zero.
-     *
-     * This means it will be 64 hex characters without a leading 0x.
-     *
-     * @returns AccountAddress as a string in LONG form without a leading 0x.
-     */
-    toStringLongWithoutPrefix(): string;
-    /**
-     * Get the inner hex data. The inner data is already a Uint8Array so no conversion
-     * is taking place here, it just returns the inner data.
-     *
-     * @returns Hex data as Uint8Array
-     */
-    toUint8Array(): Uint8Array;
-    /**
-     * Serialize the AccountAddress to a Serializer instance's data buffer.
-     * @param serializer The serializer to serialize the AccountAddress to.
-     * @returns void
-     * @example
-     * const serializer = new Serializer();
-     * const address = AccountAddress.fromString("0x1");
-     * address.serialize(serializer);
-     * const bytes = serializer.toUint8Array();
-     * // `bytes` is now the BCS-serialized address.
-     */
-    serialize(serializer: Serializer): void;
-    serializeForEntryFunction(serializer: Serializer): void;
-    serializeForScriptFunction(serializer: Serializer): void;
-    /**
-     * Deserialize an AccountAddress from the byte buffer in a Deserializer instance.
-     * @param deserializer The deserializer to deserialize the AccountAddress from.
-     * @returns An instance of AccountAddress.
-     * @example
-     * const bytes = hexToBytes("0x0102030405060708091011121314151617181920212223242526272829303132");
-     * const deserializer = new Deserializer(bytes);
-     * const address = AccountAddress.deserialize(deserializer);
-     * // `address` is now an instance of AccountAddress.
-     */
-    static deserialize(deserializer: Deserializer): AccountAddress;
-    /**
-     * NOTE: This function has strict parsing behavior. For relaxed behavior, please use
-     * the `fromString` function.
-     *
-     * 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.
-     *
-     * Learn more about the different address formats by reading AIP-40:
-     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
-     *
-     * @param input A hex string representing an account address.
-     *
-     * @returns An instance of AccountAddress.
-     */
-    static fromStringStrict(input: string): AccountAddress;
-    /**
-     * NOTE: This function has relaxed parsing behavior. For strict behavior, please use
-     * the `fromStringStrict` function. Where possible use `fromStringStrict` rather than this
-     * function, `fromString` is only provided for backwards compatibility.
-     *
-     * 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.
-     * - 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.
-     *
-     * @param input A hex string representing an account address.
-     *
-     * @returns An instance of AccountAddress.
-     */
-    static fromString(input: string): AccountAddress;
-    /**
-     * Convenience method for creating an AccountAddress from all known inputs.
-     *
-     * This handles, Uint8array, string, and AccountAddress itself
-     * @param input
-     */
-    static from(input: AccountAddressInput): AccountAddress;
-    /**
-     * Convenience method for creating an AccountAddress from all known inputs.
-     *
-     * This handles, Uint8array, string, and AccountAddress itself
-     * @param input
-     */
-    static fromStrict(input: AccountAddressInput): AccountAddress;
-    /**
-     * Check if the string is a valid AccountAddress.
-     *
-     * @param args.input A hex string representing an account address.
-     * @param args.strict If true, use strict parsing behavior. If false, use relaxed parsing behavior.
-     *
-     * @returns valid = true if the string is valid, valid = false if not. If the string
-     * is not valid, invalidReason will be set explaining why it is invalid.
-     */
-    static isValid(args: {
-        input: AccountAddressInput;
-        strict?: boolean;
-    }): ParsingResult<AddressInvalidReason>;
-    /**
-     * Return whether AccountAddresses are equal. AccountAddresses are considered equal
-     * if their underlying byte data is identical.
-     *
-     * @param other The AccountAddress to compare to.
-     * @returns true if the AccountAddresses are equal, false if not.
-     */
-    equals(other: AccountAddress): boolean;
-}
-
 /**
  *  This class exists to represent a contiguous sequence of already serialized BCS-bytes.
  *
@@ -2794,85 +2562,253 @@ declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends
      * the resulting MoveOption's .isSome() method will return false.
      * @returns a MoveOption<Bool> with an inner value `value`
      */
-    static Bool(value?: boolean | null): MoveOption<Bool>;
+    static Bool(value?: boolean | null): MoveOption<Bool>;
+    /**
+     * Factory method to generate a MoveOption<MoveString> from a `string` or `undefined`.
+     *
+     * @example
+     * MoveOption.MoveString("hello").isSome() === true;
+     * MoveOption.MoveString("").isSome() === true;
+     * MoveOption.MoveString().isSome() === false;
+     * MoveOption.MoveString(undefined).isSome() === false;
+     * @params value: the value used to fill the MoveOption. If `value` is undefined
+     * the resulting MoveOption's .isSome() method will return false.
+     * @returns a MoveOption<MoveString> with an inner value `value`
+     */
+    static MoveString(value?: string | null): MoveOption<MoveString>;
+    static deserialize<U extends Serializable & EntryFunctionArgument>(deserializer: Deserializer, cls: Deserializable<U>): MoveOption<U>;
+}
+
+/**
+ * This enum is used to explain why an address was invalid.
+ */
+declare enum AddressInvalidReason {
+    INCORRECT_NUMBER_OF_BYTES = "incorrect_number_of_bytes",
+    INVALID_HEX_CHARS = "invalid_hex_chars",
+    TOO_SHORT = "too_short",
+    TOO_LONG = "too_long",
+    LEADING_ZERO_X_REQUIRED = "leading_zero_x_required",
+    LONG_FORM_REQUIRED_UNLESS_SPECIAL = "long_form_required_unless_special",
+    INVALID_PADDING_ZEROES = "INVALID_PADDING_ZEROES"
+}
+type AccountAddressInput = HexInput | 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.
+ */
+declare class AccountAddress extends Serializable implements TransactionArgument {
+    /**
+     * This is the internal representation of an account address.
+     */
+    readonly data: Uint8Array;
+    /**
+     * The number of bytes that make up an account address.
+     */
+    static readonly LENGTH: number;
+    /**
+     * The length of an address string in LONG form without a leading 0x.
+     */
+    static readonly LONG_STRING_LENGTH: number;
+    static ZERO: AccountAddress;
+    static ONE: AccountAddress;
+    static TWO: AccountAddress;
+    static THREE: AccountAddress;
+    static FOUR: AccountAddress;
+    /**
+     * Creates an instance of AccountAddress from a Uint8Array.
+     *
+     * @param args.data A Uint8Array representing an account address.
+     */
+    constructor(input: Uint8Array);
+    /**
+     * Returns whether an address is special, where special 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 true if the address is special, false if not.
+     */
+    isSpecial(): boolean;
+    /**
+     * Return the AccountAddress as a string as per AIP-40.
+     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+     *
+     * In short, it means that special addresses are represented in SHORT form, meaning
+     * 0x0 through to 0xf inclusive, and every other address is represented in LONG form,
+     * meaning 0x + 64 hex characters.
+     *
+     * @returns AccountAddress as a string conforming to AIP-40.
+     */
+    toString(): `0x${string}`;
+    /**
+     * NOTE: Prefer to use `toString` where possible.
+     *
+     * Return the AccountAddress as a string as per AIP-40 but without the leading 0x.
+     *
+     * Learn more by reading the docstring of `toString`.
+     *
+     * @returns AccountAddress as a string conforming to AIP-40 but without the leading 0x.
+     */
+    toStringWithoutPrefix(): string;
+    /**
+     * NOTE: Prefer to use `toString` where possible.
+     *
+     * Whereas toString will format special addresses (as defined by isSpecial) using the
+     * SHORT form (no leading 0s), this format the address in the LONG format
+     * unconditionally.
+     *
+     * This means it will be 0x + 64 hex characters.
+     *
+     * @returns AccountAddress as a string in LONG form.
+     */
+    toStringLong(): `0x${string}`;
     /**
-     * Factory method to generate a MoveOption<MoveString> from a `string` or `undefined`.
+     * NOTE: Prefer to use `toString` where possible.
      *
-     * @example
-     * MoveOption.MoveString("hello").isSome() === true;
-     * MoveOption.MoveString("").isSome() === true;
-     * MoveOption.MoveString().isSome() === false;
-     * MoveOption.MoveString(undefined).isSome() === false;
-     * @params value: the value used to fill the MoveOption. If `value` is undefined
-     * the resulting MoveOption's .isSome() method will return false.
-     * @returns a MoveOption<MoveString> with an inner value `value`
+     * Whereas toString will format special addresses (as defined by isSpecial) using the
+     * SHORT form (no leading 0s), this function will include leading zeroes. The string
+     * will not have a leading zero.
+     *
+     * This means it will be 64 hex characters without a leading 0x.
+     *
+     * @returns AccountAddress as a string in LONG form without a leading 0x.
      */
-    static MoveString(value?: string | null): MoveOption<MoveString>;
-    static deserialize<U extends Serializable & EntryFunctionArgument>(deserializer: Deserializer, cls: Deserializable<U>): MoveOption<U>;
-}
-
-/**
- * An abstract representation of a public key.  All Asymmetric key pairs will use this to
- * verify signatures and for authentication keys.
- */
-declare abstract class PublicKey extends Serializable {
+    toStringLongWithoutPrefix(): string;
     /**
-     * Verifies that the private key associated with this public key signed the message with the given signature.
-     * @param args.message The message that was signed
-     * @param args.signature The signature to verify
+     * Get the inner hex data. The inner data is already a Uint8Array so no conversion
+     * is taking place here, it just returns the inner data.
+     *
+     * @returns Hex data as Uint8Array
      */
-    abstract verifySignature(args: {
-        message: HexInput;
-        signature: Signature;
-    }): boolean;
+    toUint8Array(): Uint8Array;
     /**
-     * Get the raw public key bytes
+     * Serialize the AccountAddress to a Serializer instance's data buffer.
+     * @param serializer The serializer to serialize the AccountAddress to.
+     * @returns void
+     * @example
+     * const serializer = new Serializer();
+     * const address = AccountAddress.fromString("0x1");
+     * address.serialize(serializer);
+     * const bytes = serializer.toUint8Array();
+     * // `bytes` is now the BCS-serialized address.
      */
-    abstract toUint8Array(): Uint8Array;
+    serialize(serializer: Serializer): void;
+    serializeForEntryFunction(serializer: Serializer): void;
+    serializeForScriptFunction(serializer: Serializer): void;
     /**
-     * Get the public key as a hex string with a 0x prefix e.g. 0x123456...
+     * Deserialize an AccountAddress from the byte buffer in a Deserializer instance.
+     * @param deserializer The deserializer to deserialize the AccountAddress from.
+     * @returns An instance of AccountAddress.
+     * @example
+     * const bytes = hexToBytes("0x0102030405060708091011121314151617181920212223242526272829303132");
+     * const deserializer = new Deserializer(bytes);
+     * const address = AccountAddress.deserialize(deserializer);
+     * // `address` is now an instance of AccountAddress.
      */
-    abstract toString(): string;
-    abstract serialize(serializer: Serializer): void;
-}
-/**
- * An abstract representation of a private key.  This is used to sign transactions and
- * derive the public key associated.
- */
-declare abstract class PrivateKey extends Serializable {
+    static deserialize(deserializer: Deserializer): AccountAddress;
     /**
-     * Sign a message with the key
-     * @param message The message to sign
+     * NOTE: This function has strict parsing behavior. For relaxed behavior, please use
+     * the `fromString` function.
+     *
+     * 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.
+     *
+     * Learn more about the different address formats by reading AIP-40:
+     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+     *
+     * @param input A hex string representing an account address.
+     *
+     * @returns An instance of AccountAddress.
      */
-    abstract sign(message: HexInput): Signature;
+    static fromStringStrict(input: string): AccountAddress;
     /**
-     * Get the raw private key bytes
+     * NOTE: This function has relaxed parsing behavior. For strict behavior, please use
+     * the `fromStringStrict` function. Where possible use `fromStringStrict` rather than this
+     * function, `fromString` is only provided for backwards compatibility.
+     *
+     * 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.
+     * - 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.
+     *
+     * @param input A hex string representing an account address.
+     *
+     * @returns An instance of AccountAddress.
      */
-    abstract toUint8Array(): Uint8Array;
+    static fromString(input: string): AccountAddress;
     /**
-     * Get the private key as a hex string with a 0x prefix e.g. 0x123456...
+     * Convenience method for creating an AccountAddress from all known inputs.
+     *
+     * This handles, Uint8array, string, and AccountAddress itself
+     * @param input
      */
-    abstract toString(): string;
-    abstract serialize(serializer: Serializer): void;
+    static from(input: AccountAddressInput): AccountAddress;
     /**
-     * Derives the public key associated with the private key
+     * Convenience method for creating an AccountAddress from all known inputs.
+     *
+     * This handles, Uint8array, string, and AccountAddress itself
+     * @param input
      */
-    abstract publicKey(): PublicKey;
-}
-/**
- * An abstract representation of a signature.  This is the product of signing a
- * message and can be used with the PublicKey to verify the signature.
- */
-declare abstract class Signature extends Serializable {
+    static fromStrict(input: AccountAddressInput): AccountAddress;
     /**
-     * Get the raw signature bytes
+     * Check if the string is a valid AccountAddress.
+     *
+     * @param args.input A hex string representing an account address.
+     * @param args.strict If true, use strict parsing behavior. If false, use relaxed parsing behavior.
+     *
+     * @returns valid = true if the string is valid, valid = false if not. If the string
+     * is not valid, invalidReason will be set explaining why it is invalid.
      */
-    abstract toUint8Array(): Uint8Array;
+    static isValid(args: {
+        input: AccountAddressInput;
+        strict?: boolean;
+    }): ParsingResult<AddressInvalidReason>;
     /**
-     * Get the signature as a hex string with a 0x prefix e.g. 0x123456...
+     * Return whether AccountAddresses are equal. AccountAddresses are considered equal
+     * if their underlying byte data is identical.
+     *
+     * @param other The AccountAddress to compare to.
+     * @returns true if the AccountAddresses are equal, false if not.
      */
-    abstract toString(): string;
-    abstract serialize(serializer: Serializer): void;
+    equals(other: AccountAddress): boolean;
 }
 
 /**
@@ -2905,7 +2841,12 @@ declare class AuthenticationKey extends Serializable {
     static deserialize(deserializer: Deserializer): AuthenticationKey;
     toString(): string;
     toUint8Array(): Uint8Array;
+    static fromSchemeAndBytes(args: {
+        scheme: AuthenticationKeyScheme;
+        input: HexInput;
+    }): AuthenticationKey;
     /**
+     * @deprecated Use `fromPublicKey` instead
      * Derives an AuthenticationKey from the public key seed bytes and an explicit derivation scheme.
      *
      * This facilitates targeting a specific scheme for deriving an authentication key from a public key.
@@ -2913,7 +2854,7 @@ declare class AuthenticationKey extends Serializable {
      * @param args - the public key and scheme to use for the derivation
      */
     static fromPublicKeyAndScheme(args: {
-        publicKey: PublicKey;
+        publicKey: AccountPublicKey;
         scheme: AuthenticationKeyScheme;
     }): AuthenticationKey;
     /**
@@ -2924,7 +2865,7 @@ declare class AuthenticationKey extends Serializable {
      * @returns AuthenticationKey
      */
     static fromPublicKey(args: {
-        publicKey: PublicKey;
+        publicKey: AccountPublicKey;
     }): AuthenticationKey;
     /**
      * Derives an account address from an AuthenticationKey. Since an AccountAddress is also 32 bytes,
@@ -2936,172 +2877,81 @@ declare class AuthenticationKey extends Serializable {
 }
 
 /**
- * Class for creating and managing account on Aptos network
- *
- * Use this class to create accounts, sign transactions, and more.
- * Note: Creating an account instance does not create the account on-chain.
- *
- * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
- * `Legacy` and `Unified` authentications.
- *
- * @Legacy includes `ED25519` and `MultiED25519`
- * @Unified includes `SingleSender` and `MultiSender`, where currently
- * `SingleSender` supports `ED25519` and `Secp256k1`, and `MultiSender` supports
- * `MultiED25519`.
- *
- * In TypeScript SDK, we support all of these options:
- *
- * @generate default to generate Legacy Ed25519 keys, with an optional `legacy` boolean argument
- * that lets you generate new keys conforming to the Unified authentication.
- *
- * @fromPrivateKey derives an account by a provided private key and address, with an optional
- * `legacy` boolean argument that lets you generate new keys conforming to the Unified authentication.
- *
- * @fromDerivationPath derives an account with bip44 path and mnemonics,
+ * An abstract representation of a crypto signature,
+ * associated to a specific signature scheme e.g. Ed25519 or Secp256k1
  *
+ * This is the product of signing a message directly from a PrivateKey
+ * and can be verified against a CryptoPublicKey.
  */
-declare class Account$1 {
-    /**
-     * Public key associated with the account
-     */
-    readonly publicKey: PublicKey;
-    /**
-     * Private key associated with the account
-     */
-    readonly privateKey: PrivateKey;
-    /**
-     * Account address associated with the account
-     */
-    readonly accountAddress: AccountAddress;
-    /**
-     * Signing scheme used to sign transactions
-     */
-    readonly signingScheme: SigningScheme;
+declare abstract class Signature extends Serializable {
     /**
-     * constructor for Account
-     *
-     * Need to update this to use the new crypto library if new schemes are added.
-     *
-     * @param args.privateKey PrivateKey - private key of the account
-     * @param args.address AccountAddress - address of the account
-     * @param args.legacy optional. If set to false, the keypair authentication keys will be derived with a unified scheme.
-     * Defaults to deriving an authentication key with the legacy scheme.
-     *
-     * This method is private because it should only be called by the factory static methods.
-     * @returns Account
+     * Get the raw signature bytes
      */
-    private constructor();
+    abstract toUint8Array(): Uint8Array;
     /**
-     * Derives an account with random private key and address.
-     *
-     * Default generation is using the Legacy ED25519 key
-     *
-     * @param args optional. Unify GenerateAccount type for Legacy and Unified keys
-     *
-     * Account input type to generate an account using Legacy
-     * Ed25519 or MultiEd25519 keys or without a specified `scheme`.
-     * ```
-     * GenerateAccountWithLegacyKey = {
-     *  scheme?: SigningSchemeInput.Ed25519 | SigningSchemeInput.MultiEd25519;
-     *  legacy: true;
-     * };
-     * ```
-     *
-     * Account input type to generate an account using Unified
-     * Secp256k1Ecdsa key
-     * In this case `legacy` is always false
-     * ```
-     * GenerateAccountWithUnifiedKey = {
-     *  scheme: SigningSchemeInput.Secp256k1Ecdsa;
-     *  legacy?: false;
-     * };
-     * ```
-     *
-     * @returns Account with the given signing scheme
+     * Get the signature as a hex string with a 0x prefix e.g. 0x123456...
      */
-    static generate(args?: GenerateAccount): Account$1;
+    toString(): string;
+}
+
+/**
+ * Arguments for verifying a signature
+ */
+interface VerifySignatureArgs {
+    message: HexInput;
+    signature: Signature;
+}
+/**
+ * An abstract representation of a public key.
+ *
+ * Provides a common interface for verifying any signature.
+ */
+declare abstract class PublicKey extends Serializable {
     /**
-     * Instantiates an account given a 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.
-     *
-     * @param privateKey PrivateKey - private key of the account
-     * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
-     * to generating a Legacy Ed25519 keypair
-     *
-     * @returns Account
+     * Verifies that the private key associated with this public key signed the message with the given signature.
+     * @param args.message The message that was signed
+     * @param args.signature The signature to verify
      */
-    static fromPrivateKey(args: {
-        privateKey: PrivateKey;
-        legacy?: boolean;
-    }): Account$1;
+    abstract verifySignature(args: VerifySignatureArgs): boolean;
     /**
-     * Instantiates an account given a private key and a specified account address.
-     * This is primarily used to instantiate an `Account` that has had its authentication key rotated.
-     *
-     * @param args.privateKey PrivateKey - the underlying private key for the account
-     * @param args.address AccountAddress - The account address the `Account` will sign for
-     * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
-     * to generating a Legacy Ed25519 keypair
-     *
-     * @returns Account
+     * Get the raw public key bytes
      */
-    static fromPrivateKeyAndAddress(args: {
-        privateKey: PrivateKey;
-        address: AccountAddress;
-        legacy?: boolean;
-    }): Account$1;
+    abstract toUint8Array(): Uint8Array;
     /**
-     * Derives an account with bip44 path and mnemonics,
-     *
-     * @param args.scheme The signing scheme to derive with
-     * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
-     * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
-     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
-     * @param args.mnemonic the mnemonic seed phrase of the account
-     * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
-     * to generating a Legacy Ed25519 keypair
-     *
-     * @returns Account
+     * Get the public key as a hex string with a 0x prefix e.g. 0x123456...
      */
-    static fromDerivationPath(args: {
-        scheme: SigningSchemeInput;
-        path: string;
-        mnemonic: string;
-        legacy?: boolean;
-    }): Account$1;
+    toString(): string;
+}
+/**
+ * An abstract representation of an account public key.
+ *
+ * Provides a common interface for deriving an authentication key.
+ */
+declare abstract class AccountPublicKey extends PublicKey {
     /**
-     * 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: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}
-     *
-     * @param args.publicKey PublicKey - public key of the account
-     * @returns The authentication key for the associated account
+     * Get the authentication key associated with this public key
      */
-    static authKey(args: {
-        publicKey: PublicKey;
-    }): AuthenticationKey;
+    abstract authKey(): AuthenticationKey;
+}
+
+/**
+ * An abstract representation of a private key.
+ * It is associated to a signature scheme and provides signing capabilities.
+ */
+interface PrivateKey {
     /**
      * Sign the given message with the private key.
-     *
-     * TODO: Add sign transaction or specific types
-     *
-     * @param data in HexInput format
-     * @returns Signature
+     * @param message in HexInput format
      */
-    sign(data: HexInput): Signature;
+    sign(message: HexInput): Signature;
     /**
-     * Verify the given message and signature with the public key.
-     *
-     * @param args.message raw message data in HexInput format
-     * @param args.signature signed message Signature
-     * @returns
+     * Derive the public key associated with the private key
+     */
+    publicKey(): PublicKey;
+    /**
+     * Get the private key in bytes (Uint8Array).
      */
-    verifySignature(args: {
-        message: HexInput;
-        signature: Signature;
-    }): boolean;
+    toUint8Array(): Uint8Array;
 }
 
 /**
@@ -3113,7 +2963,7 @@ declare class Account$1 {
  * Ed25519 scheme is represented in the SDK as `Legacy authentication key` and also
  * as `AnyPublicKey` that represents any `Unified authentication key`
  */
-declare class Ed25519PublicKey extends PublicKey {
+declare class Ed25519PublicKey extends AccountPublicKey {
     /**
      * Length of an Ed25519 public key
      */
@@ -3129,36 +2979,30 @@ declare class Ed25519PublicKey extends PublicKey {
      * @param hexInput A HexInput (string or Uint8Array)
      */
     constructor(hexInput: HexInput);
+    /**
+     * Verifies a signed data with a public key
+     * @param args.message a signed message
+     * @param args.signature the signature of the message
+     */
+    verifySignature(args: VerifySignatureArgs): boolean;
+    authKey(): AuthenticationKey;
     /**
      * Get the public key in bytes (Uint8Array).
      *
      * @returns Uint8Array representation of the public key
      */
     toUint8Array(): Uint8Array;
-    /**
-     * Get the public key as a hex string with the 0x prefix.
-     *
-     * @returns string representation of the public key
-     */
-    toString(): string;
-    /**
-     * Verifies a signed data with a public key
-     * @param args.message a signed message
-     * @param args.signature the signature of the message
-     */
-    verifySignature(args: {
-        message: HexInput;
-        signature: Ed25519Signature;
-    }): boolean;
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Ed25519PublicKey;
-    static load(deserializer: Deserializer): Ed25519PublicKey;
-    static isPublicKey(publicKey: PublicKey): publicKey is Ed25519PublicKey;
+    /**
+     * @deprecated use `instanceof Ed25519PublicKey` instead.
+     */
+    static isPublicKey(publicKey: AccountPublicKey): publicKey is Ed25519PublicKey;
 }
 /**
  * Represents the private key of an Ed25519 key pair.
  */
-declare class Ed25519PrivateKey extends PrivateKey {
+declare class Ed25519PrivateKey extends Serializable implements PrivateKey {
     /**
      * Length of an Ed25519 private key
      */
@@ -3179,39 +3023,12 @@ declare class Ed25519PrivateKey extends PrivateKey {
      * @param hexInput HexInput (string or Uint8Array)
      */
     constructor(hexInput: HexInput);
-    /**
-     * Get the private key in bytes (Uint8Array).
-     *
-     * @returns Uint8Array representation of the private key
-     */
-    toUint8Array(): Uint8Array;
-    /**
-     * Get the private key as a hex string with the 0x prefix.
-     *
-     * @returns string representation of the private key
-     */
-    toString(): string;
-    /**
-     * Sign the given message with the private key.
-     *
-     * @param message in HexInput format
-     * @returns Signature
-     */
-    sign(message: HexInput): Ed25519Signature;
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): Ed25519PrivateKey;
     /**
      * Generate a new random private key.
      *
      * @returns Ed25519PrivateKey
      */
     static generate(): Ed25519PrivateKey;
-    /**
-     * Derive the Ed25519PublicKey for this private key.
-     *
-     * @returns Ed25519PublicKey
-     */
-    publicKey(): Ed25519PublicKey;
     /**
      * Derives a private key from a mnemonic seed phrase.
      *
@@ -3234,6 +3051,36 @@ declare class Ed25519PrivateKey extends PrivateKey {
      * @returns
      */
     private static fromDerivationPathInner;
+    /**
+     * Derive the Ed25519PublicKey for this private key.
+     *
+     * @returns Ed25519PublicKey
+     */
+    publicKey(): Ed25519PublicKey;
+    /**
+     * Sign the given message with the private key.
+     *
+     * @param message in HexInput format
+     * @returns Signature
+     */
+    sign(message: HexInput): Ed25519Signature;
+    /**
+     * Get the private key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the private key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the private key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the private key
+     */
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Ed25519PrivateKey;
+    /**
+     * @deprecated use `instanceof Ed25519PrivateKey` instead.
+     */
     static isPrivateKey(privateKey: PrivateKey): privateKey is Ed25519PrivateKey;
 }
 /**
@@ -3250,28 +3097,79 @@ declare class Ed25519Signature extends Signature {
      */
     private readonly data;
     constructor(hexInput: HexInput);
-    /**
-     * Get the signature in bytes (Uint8Array).
-     *
-     * @returns Uint8Array representation of the signature
-     */
     toUint8Array(): Uint8Array;
-    /**
-     * Get the signature as a hex string with the 0x prefix.
-     *
-     * @returns string representation of the signature
-     */
-    toString(): string;
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Ed25519Signature;
-    static load(deserializer: Deserializer): Ed25519Signature;
-    static isSignature(signature: Signature): signature is Ed25519Signature;
 }
 
+type DerivedKeys = {
+    key: Uint8Array;
+    chainCode: Uint8Array;
+};
+/**
+ * Aptos derive path is 637
+ */
+declare const APTOS_HARDENED_REGEX: RegExp;
+declare const APTOS_BIP44_REGEX: RegExp;
+/**
+ * A list of supported key types and associated seeds
+ */
+declare enum KeyType {
+    ED25519 = "ed25519 seed"
+}
+declare const HARDENED_OFFSET = 2147483648;
+/**
+ * Aptos derive path is 637
+ *
+ * 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, last two components must be non-hardened.
+ *
+ * @param path path string (e.g. `m/44'/637'/0'/0/0`).
+ */
+declare function isValidBIP44Path(path: string): 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 {@link https://github.com/satoshilabs/slips/blob/master/slip-0044.md}
+ * See BIP-44 {@link 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.
+ *
+ * @param path path string (e.g. `m/44'/637'/0'/0'/0'`).
+ */
+declare function isValidHardenedPath(path: string): boolean;
+declare const deriveKey: (hashSeed: Uint8Array | string, data: Uint8Array | string) => DerivedKeys;
+/**
+ * Derive a child key from the private key
+ * @param key
+ * @param chainCode
+ * @param index
+ * @constructor
+ */
+declare const CKDPriv: ({ key, chainCode }: DerivedKeys, index: number) => DerivedKeys;
+/**
+ * Splits derive path into segments
+ * @param path
+ */
+declare const splitPath: (path: string) => Array<string>;
+/**
+ * Normalizes the mnemonic by removing extra whitespace and making it lowercase
+ * @param mnemonic the mnemonic seed phrase
+ */
+declare const mnemonicToSeed: (mnemonic: string) => Uint8Array;
+
 /**
  * Represents the public key of a K-of-N Ed25519 multi-sig transaction.
  */
-declare class MultiEd25519PublicKey extends PublicKey {
+declare class MultiEd25519PublicKey extends AccountPublicKey {
     /**
      * Maximum number of public keys supported
      */
@@ -3285,7 +3183,7 @@ declare class MultiEd25519PublicKey extends PublicKey {
      */
     static readonly MIN_THRESHOLD = 1;
     /**
-     * List of Ed25519 public keys for this MultiEd25519PublicKey
+     * List of Ed25519 public keys for this LegacyMultiEd25519PublicKey
      */
     readonly publicKeys: Ed25519PublicKey[];
     /**
@@ -3307,34 +3205,181 @@ declare class MultiEd25519PublicKey extends PublicKey {
         publicKeys: Ed25519PublicKey[];
         threshold: number;
     });
+    verifySignature(args: VerifySignatureArgs): boolean;
+    authKey(): AuthenticationKey;
+    /**
+     * Converts a PublicKeys into Uint8Array (bytes) with: bytes = p1_bytes | ... | pn_bytes | threshold
+     */
+    toUint8Array(): Uint8Array;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MultiEd25519PublicKey;
+}
+/**
+ * Represents the signature of a K-of-N Ed25519 multi-sig transaction.
+ */
+declare class MultiEd25519Signature extends Signature {
+    /**
+     * Maximum number of Ed25519 signatures supported
+     */
+    static MAX_SIGNATURES_SUPPORTED: number;
+    /**
+     * Number of bytes in the bitmap representing who signed the transaction (32-bits)
+     */
+    static BITMAP_LEN: number;
+    /**
+     * The list of underlying Ed25519 signatures
+     */
+    readonly signatures: Ed25519Signature[];
+    /**
+     * 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.
+     */
+    readonly bitmap: Uint8Array;
+    /**
+     * Signature for a K-of-N multi-sig transaction.
+     *
+     * @see {@link
+     * https://aptos.dev/integration/creating-a-signed-transaction/#multisignature-transactions | Creating a Signed Transaction}
+     *
+     * @param args.signatures A list of signatures
+     * @param args.bitmap 4 bytes, at most 32 signatures are supported. If Nth bit value is `1`, the Nth
+     * signature should be provided in `signatures`. Bits are read from left to right.
+     * Alternatively, you can specify an array of bitmap positions.
+     * Valid position should range between 0 and 31.
+     * @see MultiEd25519Signature.createBitmap
+     */
+    constructor(args: {
+        signatures: Ed25519Signature[];
+        bitmap: Uint8Array | number[];
+    });
+    /**
+     * Converts a MultiSignature into Uint8Array (bytes) with `bytes = s1_bytes | ... | sn_bytes | bitmap`
+     */
+    toUint8Array(): Uint8Array;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MultiEd25519Signature;
+    /**
+     * Helper method to create a bitmap out of the specified bit positions
+     * @param args.bits The bitmap positions that should be set. A position starts at index 0.
+     * Valid position should range between 0 and 31.
+     * @example
+     * Here's an example of valid `bits`
+     * ```
+     * [0, 2, 31]
+     * ```
+     * `[0, 2, 31]` means the 1st, 3rd and 32nd bits should be set in the bitmap.
+     * The result bitmap should be 0b1010000000000000000000000000001
+     *
+     * @returns bitmap that is 32bit long
+     */
+    static createBitmap(args: {
+        bits: number[];
+    }): Uint8Array;
+}
+
+/**
+ * Represents any public key supported by Aptos.
+ *
+ * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
+ * `Legacy` and `Unified` authentication keys.
+ *
+ * Any unified authentication key is represented in the SDK as `AnyPublicKey`.
+ */
+declare class AnyPublicKey extends AccountPublicKey {
+    /**
+     * Reference to the inner public key
+     */
+    readonly publicKey: PublicKey;
+    /**
+     * Index of the underlying enum variant
+     */
+    readonly variant: AnyPublicKeyVariant;
+    constructor(publicKey: PublicKey);
+    verifySignature(args: VerifySignatureArgs): boolean;
+    authKey(): AuthenticationKey;
+    toUint8Array(): Uint8Array;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): AnyPublicKey;
+    /**
+     * @deprecated use `instanceof AnyPublicKey` instead.
+     */
+    static isPublicKey(publicKey: AccountPublicKey): publicKey is AnyPublicKey;
+    /**
+     * @deprecated use `publicKey instanceof Ed25519PublicKey` instead.
+     */
+    isEd25519(): boolean;
+    /**
+     * @deprecated use `publicKey instanceof Secp256k1PublicKey` instead.
+     */
+    isSecp256k1PublicKey(): boolean;
+}
+/**
+ * Instance of signature that uses the SingleKey authentication scheme.
+ * This signature can only be generated by a `SingleKeySigner`, since it uses the
+ * same authentication scheme.
+ */
+declare class AnySignature extends Signature {
+    readonly signature: Signature;
     /**
-     * Converts a PublicKeys into Uint8Array (bytes) with: bytes = p1_bytes | ... | pn_bytes | threshold
+     * Index of the underlying enum variant
      */
+    private readonly variant;
+    constructor(signature: Signature);
     toUint8Array(): Uint8Array;
-    toString(): string;
-    verifySignature(args: {
-        message: HexInput;
-        signature: MultiEd25519Signature;
-    }): boolean;
     serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MultiEd25519PublicKey;
+    static deserialize(deserializer: Deserializer): AnySignature;
 }
+
 /**
- * Represents the signature of a K-of-N Ed25519 multi-sig transaction.
+ * Represents the public key of a multi-agent account.
+ *
+ * The public keys of each individual agent can be any type of public key supported by Aptos.
+ * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
+ * `Legacy` and `Unified` authentication keys.
  */
-declare class MultiEd25519Signature extends Signature {
+declare class MultiKey extends AccountPublicKey {
     /**
-     * Maximum number of Ed25519 signatures supported
+     * List of any public keys
      */
-    static MAX_SIGNATURES_SUPPORTED: number;
+    readonly publicKeys: AnyPublicKey[];
+    /**
+     * The minimum number of valid signatures required, for the number of public keys specified
+     */
+    readonly signaturesRequired: number;
+    constructor(args: {
+        publicKeys: Array<PublicKey>;
+        signaturesRequired: number;
+    });
+    verifySignature(args: VerifySignatureArgs): boolean;
+    authKey(): AuthenticationKey;
+    toUint8Array(): Uint8Array;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MultiKey;
+    /**
+     * Create a bitmap that holds the mapping from the original public keys
+     * to the signatures passed in
+     *
+     * @param args.bits array of the index mapping to the matching public keys
+     * @returns Uint8array bit map
+     */
+    createBitmap(args: {
+        bits: number[];
+    }): Uint8Array;
+}
+declare class MultiKeySignature extends Signature {
     /**
      * Number of bytes in the bitmap representing who signed the transaction (32-bits)
      */
     static BITMAP_LEN: number;
+    /**
+     * Maximum number of Ed25519 signatures supported
+     */
+    static MAX_SIGNATURES_SUPPORTED: number;
     /**
      * The list of underlying Ed25519 signatures
      */
-    readonly signatures: Ed25519Signature[];
+    readonly signatures: AnySignature[];
     /**
      * 32-bit Bitmap representing who signed the transaction
      *
@@ -3352,14 +3397,9 @@ declare class MultiEd25519Signature extends Signature {
      * signature should be provided in `signatures`. Bits are read from left to right
      */
     constructor(args: {
-        signatures: Ed25519Signature[];
-        bitmap: Uint8Array;
+        signatures: Array<Signature | AnySignature>;
+        bitmap: Uint8Array | number[];
     });
-    /**
-     * Converts a MultiSignature into Uint8Array (bytes) with `bytes = s1_bytes | ... | sn_bytes | bitmap`
-     */
-    toUint8Array(): Uint8Array;
-    toString(): string;
     /**
      * Helper method to create a bitmap out of the specified bit positions
      * @param args.bits The bitmap positions that should be set. A position starts at index 0.
@@ -3377,8 +3417,9 @@ declare class MultiEd25519Signature extends Signature {
     static createBitmap(args: {
         bits: number[];
     }): Uint8Array;
+    toUint8Array(): Uint8Array;
     serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MultiEd25519Signature;
+    static deserialize(deserializer: Deserializer): MultiKeySignature;
 }
 
 /**
@@ -3395,38 +3436,20 @@ declare class Secp256k1PublicKey extends PublicKey {
      * @param hexInput A HexInput (string or Uint8Array)
      */
     constructor(hexInput: HexInput);
-    /**
-     * Get the public key in bytes (Uint8Array).
-     *
-     * @returns Uint8Array representation of the public key
-     */
+    verifySignature(args: VerifySignatureArgs): boolean;
     toUint8Array(): Uint8Array;
-    /**
-     * Get the public key as a hex string with the 0x prefix.
-     *
-     * @returns string representation of the public key
-     */
-    toString(): string;
-    /**
-     * Verifies a signed data with a public key
-     *
-     * @param args.message message
-     * @param args.signature The signature
-     * @returns true if the signature is valid
-     */
-    verifySignature(args: {
-        message: HexInput;
-        signature: Secp256k1Signature;
-    }): boolean;
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Secp256k1PublicKey;
-    static load(deserializer: Deserializer): Secp256k1PublicKey;
+    /**
+     * @deprecated use `instanceof Secp256k1PublicKey` instead
+     * @param publicKey
+     */
     static isPublicKey(publicKey: PublicKey): publicKey is Secp256k1PublicKey;
 }
 /**
  * A Secp256k1 ecdsa private key
  */
-declare class Secp256k1PrivateKey extends PrivateKey {
+declare class Secp256k1PrivateKey extends Serializable implements PrivateKey {
     /**
      * Length of Secp256k1 ecdsa private key
      */
@@ -3443,17 +3466,30 @@ declare class Secp256k1PrivateKey extends PrivateKey {
      */
     constructor(hexInput: HexInput);
     /**
-     * Get the private key in bytes (Uint8Array).
+     * Generate a new random private key.
      *
-     * @returns
+     * @returns Secp256k1PrivateKey
      */
-    toUint8Array(): Uint8Array;
+    static generate(): Secp256k1PrivateKey;
     /**
-     * Get the private key as a hex string with the 0x prefix.
+     * Derives a private key from a mnemonic seed phrase.
      *
-     * @returns string representation of the private key
+     * @param path the BIP44 path
+     * @param mnemonics the mnemonic seed phrase
+     *
+     * @returns The generated key
      */
-    toString(): string;
+    static fromDerivationPath(path: string, mnemonics: string): Secp256k1PrivateKey;
+    /**
+     * A private inner function so we can separate from the main fromDerivationPath() method
+     * to add tests to verify we create the keys correctly.
+     *
+     * @param path the BIP44 path
+     * @param seed the seed phrase created by the mnemonics
+     *
+     * @returns The generated key
+     */
+    private static fromDerivationPathInner;
     /**
      * Sign the given message with the private key.
      *
@@ -3461,14 +3497,6 @@ declare class Secp256k1PrivateKey extends PrivateKey {
      * @returns Signature
      */
     sign(message: HexInput): Secp256k1Signature;
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): Secp256k1PrivateKey;
-    /**
-     * Generate a new random private key.
-     *
-     * @returns Secp256k1PrivateKey
-     */
-    static generate(): Secp256k1PrivateKey;
     /**
      * Derive the Secp256k1PublicKey from this private key.
      *
@@ -3476,227 +3504,397 @@ declare class Secp256k1PrivateKey extends PrivateKey {
      */
     publicKey(): Secp256k1PublicKey;
     /**
-     * Derives a private key from a mnemonic seed phrase.
+     * Get the private key in bytes (Uint8Array).
      *
-     * @param path the BIP44 path
-     * @param mnemonics the mnemonic seed phrase
+     * @returns
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the private key as a hex string with the 0x prefix.
      *
-     * @returns The generated key
+     * @returns string representation of the private key
      */
-    static fromDerivationPath(path: string, mnemonics: string): Secp256k1PrivateKey;
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Secp256k1PrivateKey;
     /**
-     * A private inner function so we can separate from the main fromDerivationPath() method
-     * to add tests to verify we create the keys correctly.
+     * @deprecated use `instanceof Secp256k1PrivateKey` instead
+     */
+    static isPrivateKey(privateKey: PrivateKey): privateKey is Secp256k1PrivateKey;
+}
+/**
+ * A signature of a message signed using a Secp256k1 ecdsa private key
+ */
+declare class Secp256k1Signature extends Signature {
+    /**
+     * Secp256k1 ecdsa signatures are 256-bit.
+     */
+    static readonly LENGTH = 64;
+    /**
+     * The signature bytes
+     * @private
+     */
+    private readonly data;
+    /**
+     * Create a new Signature instance from a Uint8Array or String.
      *
-     * @param path the BIP44 path
-     * @param seed the seed phrase created by the mnemonics
+     * @param hexInput A HexInput (string or Uint8Array)
+     */
+    constructor(hexInput: HexInput);
+    toUint8Array(): Uint8Array;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Secp256k1Signature;
+}
+
+declare abstract class AccountAuthenticator extends Serializable {
+    abstract serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): AccountAuthenticator;
+    isEd25519(): this is AccountAuthenticatorEd25519;
+    isMultiEd25519(): this is AccountAuthenticatorMultiEd25519;
+    isSingleKey(): this is AccountAuthenticatorSingleKey;
+    isMultiKey(): this is AccountAuthenticatorMultiKey;
+}
+/**
+ * Transaction authenticator Ed25519 for a multi signer transaction
+ *
+ * @param public_key Account's Ed25519 public key.
+ * @param signature Account's Ed25519 signature
+ *
+ */
+declare class AccountAuthenticatorEd25519 extends AccountAuthenticator {
+    readonly public_key: Ed25519PublicKey;
+    readonly signature: Ed25519Signature;
+    constructor(public_key: Ed25519PublicKey, signature: Ed25519Signature);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): AccountAuthenticatorEd25519;
+}
+/**
+ * Transaction authenticator Multi Ed25519 for a multi signers transaction
+ *
+ * @param public_key Account's MultiEd25519 public key.
+ * @param signature Account's MultiEd25519 signature
+ *
+ */
+declare class AccountAuthenticatorMultiEd25519 extends AccountAuthenticator {
+    readonly public_key: MultiEd25519PublicKey;
+    readonly signature: MultiEd25519Signature;
+    constructor(public_key: MultiEd25519PublicKey, signature: MultiEd25519Signature);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): AccountAuthenticatorMultiEd25519;
+}
+/**
+ * AccountAuthenticatorSingleKey for a single signer
+ *
+ * @param public_key AnyPublicKey
+ * @param signature AnySignature
+ *
+ */
+declare class AccountAuthenticatorSingleKey extends AccountAuthenticator {
+    readonly public_key: AnyPublicKey;
+    readonly signature: AnySignature;
+    constructor(public_key: AnyPublicKey, signature: AnySignature);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): AccountAuthenticatorSingleKey;
+}
+/**
+ * AccountAuthenticatorMultiKey for a multi signer
+ *
+ * @param public_keys MultiKey
+ * @param signatures Signature
+ *
+ */
+declare class AccountAuthenticatorMultiKey extends AccountAuthenticator {
+    readonly public_keys: MultiKey;
+    readonly signatures: Array<AnySignature>;
+    readonly signatures_bitmap: Uint8Array;
+    constructor(public_keys: MultiKey, signatures: Array<AnySignature>, signatures_bitmap: Uint8Array);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): AccountAuthenticatorMultiKey;
+}
+
+interface SingleKeySignerConstructorArgs {
+    privateKey: PrivateKey;
+    address?: AccountAddressInput;
+}
+interface SingleKeySignerGenerateArgs {
+    scheme?: SigningSchemeInput;
+}
+type SingleKeySignerFromDerivationPathArgs = SingleKeySignerGenerateArgs & {
+    path: string;
+    mnemonic: string;
+};
+interface VerifySingleKeySignatureArgs {
+    message: HexInput;
+    signature: AnySignature;
+}
+/**
+ * Signer implementation for the SingleKey authentication scheme.
+ * This 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.
+ */
+declare class SingleKeyAccount implements Account$1 {
+    /**
+     * Private key associated with the account
+     */
+    readonly privateKey: PrivateKey;
+    readonly publicKey: AnyPublicKey;
+    readonly accountAddress: AccountAddress;
+    readonly signingScheme = SigningScheme.SingleKey;
+    constructor(args: SingleKeySignerConstructorArgs);
+    /**
+     * Derives an account from a randomly generated private key.
+     * Default generation is using an Ed25519 key
+     * @returns Account with the given signature scheme
+     */
+    static generate(args?: SingleKeySignerGenerateArgs): SingleKeyAccount;
+    /**
+     * Derives an account with bip44 path and mnemonics,
+     * Default to using an Ed25519 signature scheme.
      *
-     * @returns The generated key
+     * @param args.scheme The signature scheme to derive the private key with
+     * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
+     * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
+     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
+     * @param args.mnemonic the mnemonic seed phrase of the account
      */
-    private static fromDerivationPathInner;
-    static isPrivateKey(privateKey: PrivateKey): privateKey is Secp256k1PrivateKey;
+    static fromDerivationPath(args: SingleKeySignerFromDerivationPathArgs): SingleKeyAccount;
+    verifySignature(args: VerifySingleKeySignatureArgs): boolean;
+    signWithAuthenticator(message: HexInput): AccountAuthenticatorSingleKey;
+    sign(message: HexInput): AnySignature;
+}
+
+/**
+ * Arguments for creating an `Ed25519Account` from an `Ed25519PrivateKey`.
+ * This is the default input type when passing an `Ed25519PrivateKey`.
+ * In order to use the SingleKey authentication scheme, `legacy` needs to be explicitly set to false.
+ */
+interface CreateEd25519AccountFromPrivateKeyArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+    legacy?: true;
+}
+/**
+ * Arguments for creating an `SingleKeyAccount` from an `Ed25519PrivateKey`.
+ * The `legacy` argument needs to be explicitly set to false in order to
+ * use the `SingleKey` authentication scheme.
+ */
+interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+    legacy: false;
+}
+/**
+ * Arguments for creating an `SingleKeyAccount` from any supported private key
+ * that is not an `Ed25519PrivateKey`.
+ * The `legacy` argument defaults to false and cannot be explicitly set to true.
+ */
+interface CreateSingleKeyAccountFromPrivateKeyArgs {
+    privateKey: Exclude<PrivateKey, Ed25519PrivateKey>;
+    address?: AccountAddressInput;
+    legacy?: false;
+}
+/**
+ * Arguments for creating an opaque `Account` from any supported private key.
+ * This is used when the private key type is not known at compilation time.
+ */
+interface CreateAccountFromPrivateKeyArgs {
+    privateKey: PrivateKey;
+    address?: AccountAddressInput;
+    legacy?: boolean;
+}
+/**
+ * Arguments for generating an `Ed25519Account`.
+ * This is the input type used by default.
+ */
+interface GenerateEd25519AccountArgs {
+    scheme?: SigningSchemeInput.Ed25519;
+    legacy?: true;
+}
+/**
+ * Arguments for generating an `SingleKeyAccount` with ah underlying `Ed25519PrivateKey`.
+ * The `legacy` argument needs to be explicitly set to false,
+ * otherwise an `Ed25519Account` will be returned instead.
+ */
+interface GenerateEd25519SingleKeyAccountArgs {
+    scheme?: SigningSchemeInput.Ed25519;
+    legacy: false;
+}
+/**
+ * Arguments for generating an `SingleKeyAccount` with any supported private key
+ * that is not an `Ed25519PrivateKey`.
+ * The `legacy` argument defaults to false and cannot be explicitly set to true.
+ */
+interface GenerateSingleKeyAccountArgs {
+    scheme: Exclude<SigningSchemeInput, SigningSchemeInput.Ed25519>;
+    legacy?: false;
+}
+/**
+ * Arguments for generating an opaque `Account`.
+ * This is used when the input signature scheme is not known at compilation time.
+ */
+interface GenerateAccountArgs {
+    scheme?: SigningSchemeInput;
+    legacy?: boolean;
 }
 /**
- * A signature of a message signed using an Secp256k1 ecdsa private key
+ * Arguments for deriving a private key from a mnemonic phrase and a BIP44 path.
  */
-declare class Secp256k1Signature extends Signature {
+interface PrivateKeyFromDerivationPathArgs {
+    path: string;
+    mnemonic: string;
+}
+/**
+ * Interface for a generic Aptos account.
+ *
+ * The interface is defined as abstract class to provide a single entrypoint for account generation,
+ * either through `Account.generate()` or `Account.fromDerivationPath`.
+ * Despite this being 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.
+ */
+declare abstract class Account$1 {
     /**
-     * Secp256k1 ecdsa signatures are 256-bit.
+     * Private key associated with the account.
+     * Note: this will be removed in the next major release,
+     *  as not all accounts have a private key.
      */
-    static readonly LENGTH = 64;
+    abstract readonly privateKey: PrivateKey;
     /**
-     * The signature bytes
-     * @private
+     * Public key associated with the account
      */
-    private readonly data;
+    abstract readonly publicKey: AccountPublicKey;
     /**
-     * Create a new Signature instance from a Uint8Array or String.
-     *
-     * @param hexInput A HexInput (string or Uint8Array)
+     * Account address associated with the account
      */
-    constructor(hexInput: HexInput);
+    abstract readonly accountAddress: AccountAddress;
     /**
-     * Get the signature in bytes (Uint8Array).
-     *
-     * @returns Uint8Array representation of the signature
+     * Signing scheme used to sign transactions
      */
-    toUint8Array(): Uint8Array;
+    abstract signingScheme: SigningScheme;
     /**
-     * Get the signature as a hex string with the 0x prefix.
-     *
-     * @returns string representation of the signature
+     * Derives an account from a randomly generated private key.
+     * @param args.scheme The signature scheme to use, to generate the private key
+     * @param args.legacy Whether to use a legacy authentication scheme, when applicable
+     * @returns An account compatible with the provided signature scheme
      */
-    toString(): string;
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): Secp256k1Signature;
-    static load(deserializer: Deserializer): Secp256k1Signature;
-    static isSignature(signature: Signature): signature is Secp256k1Signature;
-}
-
-declare class AnySignature extends Signature {
-    readonly signature: Signature;
-    constructor(signature: Signature);
+    static generate(args?: GenerateEd25519AccountArgs): Ed25519Account;
+    static generate(args: GenerateEd25519SingleKeyAccountArgs): SingleKeyAccount;
+    static generate(args: GenerateSingleKeyAccountArgs): SingleKeyAccount;
+    static generate(args: GenerateAccountArgs): Account$1;
     /**
-     * Get the public key in bytes (Uint8Array).
+     * Creates an account from the provided private key.
      *
-     * @returns Uint8Array representation of the public key
+     * @param args.privateKey a valid private key
+     * @param args.address the account's address. If not provided, it will be derived from the public key.
+     * @param args.legacy Whether to use a legacy authentication scheme, when applicable
      */
-    toUint8Array(): Uint8Array;
+    static fromPrivateKey(args: CreateEd25519AccountFromPrivateKeyArgs): Ed25519Account;
+    static fromPrivateKey(args: CreateEd25519SingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
+    static fromPrivateKey(args: CreateSingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
+    static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs): Account$1;
     /**
-     * Get the public key as a hex string with the 0x prefix.
+     * @deprecated use `fromPrivateKey` instead.
+     * Instantiates an account given a private key and a specified account address.
+     * This is primarily used to instantiate an `Account` that has had its authentication key rotated.
      *
-     * @returns string representation of the public key
-     */
-    toString(): string;
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): AnySignature;
-}
-
-/**
- * Represents any public key supported by Aptos.
- *
- * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
- * `Legacy` and `Unified` authentication keys.
- *
- * Any unified authentication key is represented in the SDK as `AnyPublicKey`.
- */
-declare class AnyPublicKey extends PublicKey {
-    /**
-     * Reference to the inner public key
-     */
-    readonly publicKey: PublicKey;
-    constructor(publicKey: PublicKey);
-    /**
-     * Get the public key in bytes (Uint8Array).
+     * @param args.privateKey PrivateKey - the underlying private key for the account
+     * @param args.address AccountAddress - The account address the `Account` will sign for
+     * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
+     * to generating a Legacy Ed25519 keypair
      *
-     * @returns Uint8Array representation of the public key
+     * @returns Account
      */
-    toUint8Array(): Uint8Array;
+    static fromPrivateKeyAndAddress(args: CreateAccountFromPrivateKeyArgs): Account$1;
     /**
-     * Get the public key as a hex string with the 0x prefix.
+     * Derives an account with bip44 path and mnemonics
      *
-     * @returns string representation of the public key
+     * @param args.scheme The signature scheme to derive the private key with
+     * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
+     * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
+     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
+     * @param args.mnemonic the mnemonic seed phrase of the account
      */
-    toString(): string;
+    static fromDerivationPath(args: GenerateEd25519AccountArgs & PrivateKeyFromDerivationPathArgs): Ed25519Account;
+    static fromDerivationPath(args: GenerateEd25519SingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;
+    static fromDerivationPath(args: GenerateSingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;
+    static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs): Account$1;
     /**
-     * Verifies a signed data with a public key
+     * @deprecated use `publicKey.authKey()` instead.
+     * 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: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}
      *
-     * @param args.message message
-     * @param args.signature The signature
-     * @returns true if the signature is valid
-     */
-    verifySignature(args: {
-        message: HexInput;
-        signature: AnySignature;
-    }): boolean;
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): AnyPublicKey;
-    static isPublicKey(publicKey: PublicKey): publicKey is AnyPublicKey;
-    isEd25519(): this is Ed25519PublicKey;
-    isSecp256k1PublicKey(): this is Secp256k1PublicKey;
-}
-
-declare class MultiKey extends PublicKey {
-    /**
-     * List of any public keys
+     * @param args.publicKey PublicKey - public key of the account
+     * @returns The authentication key for the associated account
      */
-    readonly publicKeys: AnyPublicKey[];
+    static authKey(args: {
+        publicKey: AccountPublicKey;
+    }): AuthenticationKey;
     /**
-     * The minimum number of valid signatures required, for the number of public keys specified
+     * Sign a message using the available signing capabilities.
+     * @param message the signing message, as binary input
+     * @return the AccountAuthenticator containing the signature, together with the account's public key
      */
-    readonly signaturesRequired: number;
-    constructor(args: {
-        publicKeys: PublicKey[];
-        signaturesRequired: number;
-    });
-    toUint8Array(): Uint8Array;
+    abstract signWithAuthenticator(message: HexInput): AccountAuthenticator;
     /**
-     * Create a bitmap that holds the mapping from the original public keys
-     * to the signatures passed in
-     *
-     * @param args.bits array of the index mapping to the matching public keys
-     * @returns Uint8array bit map
+     * Sign the given message with the private key.
+     * @param message in HexInput format
+     * @returns AccountSignature
      */
-    createBitmap(args: {
-        bits: number[];
-    }): Uint8Array;
+    abstract sign(message: HexInput): Signature;
     /**
-     * Hex string representation the multi key bytes
-     *
-     * @returns string
+     * @param args.message raw message data in HexInput format
+     * @param args.signature signed message signature
      */
-    toString(): string;
-    verifySignature(args: {
-        message: HexInput;
-        signature: AnySignature;
-    }): boolean;
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MultiKey;
+    verifySignature(args: VerifySignatureArgs): boolean;
 }
 
-type DerivedKeys = {
-    key: Uint8Array;
-    chainCode: Uint8Array;
-};
-/**
- * Aptos derive path is 637
- */
-declare const APTOS_HARDENED_REGEX: RegExp;
-declare const APTOS_BIP44_REGEX: RegExp;
-/**
- * A list of supported key types and associated seeds
- */
-declare enum KeyType {
-    ED25519 = "ed25519 seed"
+interface Ed25519SignerConstructorArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+}
+interface Ed25519SignerFromDerivationPathArgs {
+    path: string;
+    mnemonic: string;
+}
+interface VerifyEd25519SignatureArgs {
+    message: HexInput;
+    signature: Ed25519Signature;
 }
-declare const HARDENED_OFFSET = 2147483648;
-/**
- * Aptos derive path is 637
- *
- * 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, last two components must be non-hardened.
- *
- * @param path path string (e.g. `m/44'/637'/0'/0/0`).
- */
-declare function isValidBIP44Path(path: string): 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 {@link https://github.com/satoshilabs/slips/blob/master/slip-0044.md}
- * See BIP-44 {@link 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.
+ * Signer implementation for the Ed25519 authentication scheme.
+ * This extends an {@link Ed25519Account} by adding signing capabilities through an {@link Ed25519PrivateKey}.
  *
- * @param path path string (e.g. `m/44'/637'/0'/0'/0'`).
- */
-declare function isValidHardenedPath(path: string): boolean;
-declare const deriveKey: (hashSeed: Uint8Array | string, data: Uint8Array | string) => DerivedKeys;
-/**
- * Derive a child key from the private key
- * @param key
- * @param chainCode
- * @param index
- * @constructor
- */
-declare const CKDPriv: ({ key, chainCode }: DerivedKeys, index: number) => DerivedKeys;
-/**
- * Splits derive path into segments
- * @param path
- */
-declare const splitPath: (path: string) => Array<string>;
-/**
- * Normalizes the mnemonic by removing extra whitespace and making it lowercase
- * @param mnemonic the mnemonic seed phrase
+ * Note: Generating a signer instance does not create the account on-chain.
  */
-declare const mnemonicToSeed: (mnemonic: string) => Uint8Array;
+declare class Ed25519Account implements Account$1 {
+    /**
+     * Private key associated with the account
+     */
+    readonly privateKey: Ed25519PrivateKey;
+    readonly publicKey: Ed25519PublicKey;
+    readonly accountAddress: AccountAddress;
+    readonly signingScheme = SigningScheme.Ed25519;
+    constructor(args: Ed25519SignerConstructorArgs);
+    /**
+     * Derives a signer from a randomly generated private key
+     */
+    static generate(): Ed25519Account;
+    /**
+     * Derives an account with bip44 path and mnemonics
+     *
+     * @param args.path the BIP44 derive hardened path e.g. m/44'/637'/0'/0'/0'
+     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
+     * @param args.mnemonic the mnemonic seed phrase of the account
+     */
+    static fromDerivationPath(args: Ed25519SignerFromDerivationPathArgs): Ed25519Account;
+    verifySignature(args: VerifyEd25519SignatureArgs): boolean;
+    signWithAuthenticator(message: HexInput): AccountAuthenticatorEd25519;
+    sign(message: HexInput): Ed25519Signature;
+}
 
 /**
  * Type of API endpoint for request routing
@@ -3706,7 +3904,6 @@ declare enum AptosApiType {
     INDEXER = 1,
     FAUCET = 2
 }
-declare const DEFAULT_NETWORK = Network.DEVNET;
 /**
  * The default max gas amount when none is given.
  *
@@ -4563,72 +4760,6 @@ declare class RotationProofChallenge extends Serializable {
     serialize(serializer: Serializer): void;
 }
 
-declare abstract class AccountAuthenticator extends Serializable {
-    abstract serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): AccountAuthenticator;
-    isEd25519(): this is AccountAuthenticatorEd25519;
-    isMultiEd25519(): this is AccountAuthenticatorMultiEd25519;
-    isSingleKey(): this is AccountAuthenticatorSingleKey;
-    isMultiKey(): this is AccountAuthenticatorMultiKey;
-}
-/**
- * Transaction authenticator Ed25519 for a multi signer transaction
- *
- * @param public_key Account's Ed25519 public key.
- * @param signature Account's Ed25519 signature
- *
- */
-declare class AccountAuthenticatorEd25519 extends AccountAuthenticator {
-    readonly public_key: Ed25519PublicKey;
-    readonly signature: Ed25519Signature;
-    constructor(public_key: Ed25519PublicKey, signature: Ed25519Signature);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): AccountAuthenticatorEd25519;
-}
-/**
- * Transaction authenticator Multi Ed25519 for a multi signers transaction
- *
- * @param public_key Account's MultiEd25519 public key.
- * @param signature Account's MultiEd25519 signature
- *
- */
-declare class AccountAuthenticatorMultiEd25519 extends AccountAuthenticator {
-    readonly public_key: MultiEd25519PublicKey;
-    readonly signature: MultiEd25519Signature;
-    constructor(public_key: MultiEd25519PublicKey, signature: MultiEd25519Signature);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): AccountAuthenticatorMultiEd25519;
-}
-/**
- * AccountAuthenticatorSingleKey for a single signer
- *
- * @param public_key AnyPublicKey
- * @param signature AnySignature
- *
- */
-declare class AccountAuthenticatorSingleKey extends AccountAuthenticator {
-    readonly public_key: AnyPublicKey;
-    readonly signature: AnySignature;
-    constructor(public_key: AnyPublicKey, signature: AnySignature);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): AccountAuthenticatorSingleKey;
-}
-/**
- * AccountAuthenticatorMultiKey for a multi signer
- *
- * @param public_keys MultiKey
- * @param signatures Signature
- *
- */
-declare class AccountAuthenticatorMultiKey extends AccountAuthenticator {
-    readonly public_keys: MultiKey;
-    readonly signatures: Array<AnySignature>;
-    readonly signatures_bitmap: Uint8Array;
-    constructor(public_keys: MultiKey, signatures: Array<AnySignature>, signatures_bitmap: Uint8Array);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): AccountAuthenticatorMultiKey;
-}
-
 declare abstract class TransactionAuthenticator extends Serializable {
     abstract serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): TransactionAuthenticator;
@@ -5011,6 +5142,17 @@ declare class DigitalAsset {
         minimumLedgerVersion?: AnyNumber;
         options?: TokenStandardArg;
     }): Promise<GetCollectionDataResponse>;
+    /**
+     * Queries data of a specific collection by the collection ID.
+     *
+     * @param args.collectionId the ID of the collection, it's the same thing as the address of the collection object
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @returns GetCollectionDataResponse response type
+     */
+    getCollectionDataByCollectionId(args: {
+        collectionId: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<GetCollectionDataResponse>;
     /**
      * Queries a collection's ID.
      *
@@ -6994,4 +7136,4 @@ declare function postAptosFullNode<Req extends {}, Res extends {}>(options: Post
 declare function postAptosIndexer<Req extends {}, Res extends {}>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
 declare function postAptosFaucet<Req extends {}, Res extends {}>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
 
-export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_HARDENED_REGEX, Account$1 as Account, AccountAddress, type AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountAuthenticatorVariant, type AccountData, AccountSequenceNumber, type AccountSignature, AddressInvalidReason, type AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, AnySignatureVariant, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, type AptosRequest, type AptosResponse, type AptosSettings, AuthenticationKey, type AuthenticationKeyScheme, type Block, type BlockMetadataTransactionResponse, Bool, CKDPriv, ChainId, type Client, type ClientConfig, type ClientRequest, type ClientResponse, type CommittedTransactionResponse, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_NETWORK, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DecodedTableData, type DeletedTableData, DeriveScheme, type DerivedKeys, type Deserializable, Deserializer, type DirectWriteSet, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, EntryFunction, type EntryFunctionABI, type EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, type EntryFunctionPayloadResponse, type Event$1 as Event, type EventGuid, type ExecutionFinishEventData, type FailureEventData, FeePayerRawTransaction, FixedBytes, type GasEstimation, type GenerateAccount, type GenerateAccountWithEd25519, type GenerateAccountWithSingleSignerSecp256k1Key, type GenesisPayload, type GenesisTransactionResponse, type GetANSNameResponse, type GetAccountCoinsDataResponse, type GetAccountCollectionsWithOwnedTokenResponse, type GetAccountOwnedObjectsResponse, type GetAccountOwnedTokensFromCollectionResponse, type GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, type GetChainTopUserTransactionsResponse, type GetCollectionDataResponse, type GetCurrentFungibleAssetBalancesResponse, type GetCurrentTokenOwnershipResponse, type GetDelegatedStakingActivitiesResponse, type GetEventsResponse, type GetFungibleAssetActivitiesResponse, type GetFungibleAssetMetadataResponse, type GetNumberOfDelegatorsResponse, type GetOwnedTokensResponse, type GetProcessorStatusResponse, type GetRequestOptions, type GetTokenActivityResponse, type GetTokenDataResponse, type GraphqlQuery, HARDENED_OFFSET, Hex, type HexInput, HexInvalidReason, Identifier, type InputEntryFunctionData, type InputEntryFunctionDataWithABI, type InputEntryFunctionDataWithRemoteABI, type InputGenerateMultiAgentRawTransactionArgs, type InputGenerateMultiAgentRawTransactionData, type InputGenerateRawTransactionArgs, type InputGenerateSingleSignerRawTransactionArgs, type InputGenerateSingleSignerRawTransactionData, type InputGenerateTransactionData, type InputGenerateTransactionOptions, type InputGenerateTransactionPayloadData, type InputGenerateTransactionPayloadDataWithABI, type InputGenerateTransactionPayloadDataWithRemoteABI, type InputMultiSigData, type InputMultiSigDataWithABI, type InputMultiSigDataWithRemoteABI, type InputScriptData, type InputSimulateTransactionData, type InputSimulateTransactionOptions, type InputSubmitTransactionData, type InputViewRequestData, KeyType, type LedgerInfo, type LedgerVersionArg, MimeType, ModuleId, MoveAbility, type MoveAddressType, type MoveFunction, type MoveFunctionGenericTypeParam, type MoveFunctionId, MoveFunctionVisibility, type MoveModule, type MoveModuleBytecode, type MoveModuleId, type MoveObjectType, MoveOption, type MoveOptionType, type MoveResource, type MoveScriptBytecode, MoveString, type MoveStruct, type MoveStructField, type MoveStructId, type MoveStructType, type MoveType, type MoveUint128Type, type MoveUint16Type, type MoveUint256Type, type MoveUint32Type, type MoveUint64Type, type MoveUint8Type, type MoveValue, MoveVector, MultiAgentRawTransaction, type MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiSig, MultiSigTransactionPayload, type MultisigPayloadResponse, Network, NetworkToChainId, NetworkToFaucetAPI, NetworkToIndexerAPI, NetworkToNetworkName, NetworkToNodeAPI, type OrderBy, type OrderByArg, type OrderByValue, type PaginationArgs, ParsingError, type ParsingResult, type PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, PrivateKey, ProcessorType, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RoleType, RotationProofChallenge, Script, type ScriptFunctionArgument, type ScriptFunctionArgumentTypes, type ScriptPayloadResponse, ScriptTransactionArgumentVariants, type ScriptWriteSet, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, type SimpleTransaction, type StateCheckpointTransactionResponse, StructTag, type SuccessEventData, type TableItemRequest, type TokenStandard, type TokenStandardArg, type TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionAuthenticatorVariant, type TransactionEd25519Signature, type TransactionFeePayerSignature, type TransactionMultiAgentSignature, type TransactionMultiEd25519Signature, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, type TransactionPayloadResponse, TransactionPayloadScript, TransactionPayloadVariants, type TransactionResponse, TransactionResponseType, type TransactionSecp256k1Signature, type TransactionSignature, TransactionVariants, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVariants, TypeTagVector, U128, U16, U256, U32, U64, U8, type Uint128, type Uint16, type Uint256, type Uint32, type Uint64, type Uint8, type UserTransactionResponse, type ValidatorTransactionResponse, type ViewRequest, type WaitForTransactionOptions, type WhereArg, type WriteSet, type WriteSetChange, type WriteSetChangeDeleteModule, type WriteSetChangeDeleteResource, type WriteSetChangeDeleteTableItem, type WriteSetChangeWriteModule, type WriteSetChangeWriteResource, type WriteSetChangeWriteTableItem, aptosCoinStructTag, aptosRequest, buildTransaction, checkOrConvertArgument, convertArgument, deriveKey, deriveTransactionType, deserializeFromScriptArgument, ensureBoolean, fetchEntryFunctionAbi, findFirstNonSignerArg, generateMultiSignersSignedTransaction, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateTransactionPayload, generateTransactionPayloadWithABI, get, getAptosFullNode, getAuthenticatorForSimulation, getFunctionParts, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBlockMetadataTransactionResponse, isBool, isEd25519Signature, isEncodedEntryFunctionArgument, isFeePayerSignature, isGenesisTransactionResponse, isLargeNumber, isMultiAgentSignature, isMultiEd25519Signature, isNull, isNumber, isPendingTransactionResponse, isScriptDataInput, isSecp256k1Signature, isStateCheckpointTransactionResponse, isString, isUserTransactionResponse, isValidBIP44Path, isValidHardenedPath, isValidatorTransactionResponse, mnemonicToSeed, objectStructTag, optionStructTag, outOfRangeErrorMessage, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, promiseFulfilledStatus, request, sign, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch, validateNumberInRange };
+export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_HARDENED_REGEX, Account$1 as Account, AccountAddress, type AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountAuthenticatorVariant, type AccountData, AccountPublicKey, AccountSequenceNumber, type AccountSignature, AddressInvalidReason, type AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, AnySignatureVariant, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, type AptosRequest, type AptosResponse, type AptosSettings, AuthenticationKey, type AuthenticationKeyScheme, type Block, type BlockMetadataTransactionResponse, Bool, CKDPriv, ChainId, type Client, type ClientConfig, type ClientRequest, type ClientResponse, type CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DecodedTableData, type DeletedTableData, DeriveScheme, type DerivedKeys, type Deserializable, Deserializer, type DirectWriteSet, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, type EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, type EntryFunctionPayloadResponse, type Event$1 as Event, type EventGuid, type ExecutionFinishEventData, type FailureEventData, FeePayerRawTransaction, FixedBytes, type GasEstimation, type GenerateAccount, type GenerateAccountArgs, type GenerateAccountWithEd25519, type GenerateAccountWithSingleSignerSecp256k1Key, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, type GenesisPayload, type GenesisTransactionResponse, type GetANSNameResponse, type GetAccountCoinsDataResponse, type GetAccountCollectionsWithOwnedTokenResponse, type GetAccountOwnedObjectsResponse, type GetAccountOwnedTokensFromCollectionResponse, type GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, type GetChainTopUserTransactionsResponse, type GetCollectionDataResponse, type GetCurrentFungibleAssetBalancesResponse, type GetCurrentTokenOwnershipResponse, type GetDelegatedStakingActivitiesResponse, type GetEventsResponse, type GetFungibleAssetActivitiesResponse, type GetFungibleAssetMetadataResponse, type GetNumberOfDelegatorsResponse, type GetOwnedTokensResponse, type GetProcessorStatusResponse, type GetRequestOptions, type GetTokenActivityResponse, type GetTokenDataResponse, type GraphqlQuery, HARDENED_OFFSET, Hex, type HexInput, HexInvalidReason, Identifier, type InputEntryFunctionData, type InputEntryFunctionDataWithABI, type InputEntryFunctionDataWithRemoteABI, type InputGenerateMultiAgentRawTransactionArgs, type InputGenerateMultiAgentRawTransactionData, type InputGenerateRawTransactionArgs, type InputGenerateSingleSignerRawTransactionArgs, type InputGenerateSingleSignerRawTransactionData, type InputGenerateTransactionData, type InputGenerateTransactionOptions, type InputGenerateTransactionPayloadData, type InputGenerateTransactionPayloadDataWithABI, type InputGenerateTransactionPayloadDataWithRemoteABI, type InputMultiSigData, type InputMultiSigDataWithABI, type InputMultiSigDataWithRemoteABI, type InputScriptData, type InputSimulateTransactionData, type InputSimulateTransactionOptions, type InputSubmitTransactionData, type InputViewRequestData, KeyType, type LedgerInfo, type LedgerVersionArg, MimeType, ModuleId, MoveAbility, type MoveAddressType, type MoveFunction, type MoveFunctionGenericTypeParam, type MoveFunctionId, MoveFunctionVisibility, type MoveModule, type MoveModuleBytecode, type MoveModuleId, type MoveObjectType, MoveOption, type MoveOptionType, type MoveResource, type MoveScriptBytecode, MoveString, type MoveStruct, type MoveStructField, type MoveStructId, type MoveStructType, type MoveType, type MoveUint128Type, type MoveUint16Type, type MoveUint256Type, type MoveUint32Type, type MoveUint64Type, type MoveUint8Type, type MoveValue, MoveVector, MultiAgentRawTransaction, type MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeySignature, MultiSig, MultiSigTransactionPayload, type MultisigPayloadResponse, Network, NetworkToChainId, NetworkToFaucetAPI, NetworkToIndexerAPI, NetworkToNetworkName, NetworkToNodeAPI, type OrderBy, type OrderByArg, type OrderByValue, type PaginationArgs, ParsingError, type ParsingResult, type PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, type PrivateKey, type PrivateKeyFromDerivationPathArgs, ProcessorType, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RoleType, RotationProofChallenge, Script, type ScriptFunctionArgument, type ScriptFunctionArgumentTypes, type ScriptPayloadResponse, ScriptTransactionArgumentVariants, type ScriptWriteSet, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, type SimpleTransaction, SingleKeyAccount, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, type StateCheckpointTransactionResponse, StructTag, type SuccessEventData, type TableItemRequest, type TokenStandard, type TokenStandardArg, type TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionAuthenticatorVariant, type TransactionEd25519Signature, type TransactionFeePayerSignature, type TransactionMultiAgentSignature, type TransactionMultiEd25519Signature, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, type TransactionPayloadResponse, TransactionPayloadScript, TransactionPayloadVariants, type TransactionResponse, TransactionResponseType, type TransactionSecp256k1Signature, type TransactionSignature, TransactionVariants, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVariants, TypeTagVector, U128, U16, U256, U32, U64, U8, type Uint128, type Uint16, type Uint256, type Uint32, type Uint64, type Uint8, type UserTransactionResponse, type ValidatorTransactionResponse, type VerifyEd25519SignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewRequest, type WaitForTransactionOptions, type WhereArg, type WriteSet, type WriteSetChange, type WriteSetChangeDeleteModule, type WriteSetChangeDeleteResource, type WriteSetChangeDeleteTableItem, type WriteSetChangeWriteModule, type WriteSetChangeWriteResource, type WriteSetChangeWriteTableItem, aptosCoinStructTag, aptosRequest, buildTransaction, checkOrConvertArgument, convertArgument, deriveKey, deriveTransactionType, deserializeFromScriptArgument, ensureBoolean, fetchEntryFunctionAbi, findFirstNonSignerArg, generateMultiSignersSignedTransaction, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateTransactionPayload, generateTransactionPayloadWithABI, get, getAptosFullNode, getAuthenticatorForSimulation, getFunctionParts, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBlockMetadataTransactionResponse, isBool, isEd25519Signature, isEncodedEntryFunctionArgument, isFeePayerSignature, isGenesisTransactionResponse, isLargeNumber, isMultiAgentSignature, isMultiEd25519Signature, isNull, isNumber, isPendingTransactionResponse, isScriptDataInput, isSecp256k1Signature, isStateCheckpointTransactionResponse, isString, isUserTransactionResponse, isValidBIP44Path, isValidHardenedPath, isValidatorTransactionResponse, mnemonicToSeed, objectStructTag, optionStructTag, outOfRangeErrorMessage, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, promiseFulfilledStatus, request, sign, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch, validateNumberInRange };