@aptos-labs/ts-sdk 1.31.0 → 1.32.0

package/dist/common/index.d.ts

@@ -1,5 +1,7 @@
-import { S as Serializable, T as TransactionArgument, H as HexInput, a as Serializer, D as Deserializer, E as EntryFunctionArgument, U as Uint8, b as Uint16, c as Uint32, A as AnyNumber, d as Deserializable, e as Hex, f as AuthenticationKeyScheme, g as AccountAddress, h as AnyPublicKeyVariant, i as EphemeralPublicKeyVariant, N as Network, C as Client, j as ClientConfig, F as FullNodeConfig, I as IndexerConfig, k as FaucetConfig, l as AptosSettings, m as EphemeralCertificateVariant, Z as ZkpVariant, L as LedgerVersionArg, n as AccountAddressInput, M as MoveModuleId, o as ScriptFunctionArgument, p as MoveFunctionId, q as MoveStructId, r as MoveValue, s as MoveFunctionGenericTypeParam, t as SigningSchemeInput, u as SigningScheme, v as AccountData, P as PaginationArgs, w as MoveModuleBytecode, x as TransactionResponse, y as MoveResource, z as TokenStandardArg, O as OrderByArg, G as GetAccountOwnedTokensQueryResponse, B as GetAccountOwnedTokensFromCollectionResponse, J as GetAccountCollectionsWithOwnedTokenResponse, K as GetAccountCoinsDataResponse, W as WhereArg, Q as GetObjectDataQueryResponse, R as GetCollectionDataResponse, V as GetTokenDataResponse, X as GetCurrentTokenOwnershipResponse, Y as GetOwnedTokensResponse, _ as GetTokenActivityResponse, $ as GetEventsResponse, a0 as WaitForTransactionOptions, a1 as UserTransactionResponse, a2 as MoveFunction, a3 as GetFungibleAssetMetadataResponse, a4 as GetFungibleAssetActivitiesResponse, a5 as GetCurrentFungibleAssetBalancesResponse, a6 as LedgerInfo, a7 as Block, a8 as GetChainTopUserTransactionsResponse, a9 as GraphqlQuery, aa as GetProcessorStatusResponse, ab as GetANSNameResponse, ac as GetNumberOfDelegatorsResponse, ad as GetDelegatedStakingActivitiesResponse, ae as PendingTransactionResponse, af as CommittedTransactionResponse, ag as GasEstimation, ah as TableItemRequest, ai as GetTableItemsDataResponse, aj as GetTableItemsMetadataResponse, ak as AptosRequest, al as ClientRequest, am as ClientResponse, an as MimeType } from './accountAddress-DnSqjhSl.js';
-export { aA as AccountAuthenticatorVariant, bj as AccountSignature, ar as AddressInvalidReason, aB as AnySignatureVariant, aT as BlockEndInfo, aU as BlockEpilogueTransactionResponse, aQ as BlockMetadataTransactionResponse, aG as ClientHeadersType, b0 as DecodedTableData, b1 as DeletedTableData, bG as DeriveScheme, bm as DirectWriteSet, b3 as EntryFunctionPayloadResponse, aC as EphemeralSignatureVariant, bo as Event, bn as EventGuid, bJ as GenerateAccount, bH as GenerateAccountWithEd25519, bI as GenerateAccountWithSingleSignerSecp256k1Key, b6 as GenesisPayload, aP as GenesisTransactionResponse, au as HexInvalidReason, bB as MoveAbility, bv as MoveAddressType, bA as MoveFunctionVisibility, bD as MoveModule, bw as MoveObjectType, bx as MoveOptionType, b7 as MoveScriptBytecode, bE as MoveStruct, bC as MoveStructField, by as MoveStructType, bz as MoveType, bt as MoveUint128Type, bq as MoveUint16Type, bu as MoveUint256Type, br as MoveUint32Type, bs as MoveUint64Type, bp as MoveUint8Type, b5 as MultisigPayloadResponse, bS as NetworkToChainId, bP as NetworkToFaucetAPI, bN as NetworkToIndexerAPI, bT as NetworkToNetworkName, bO as NetworkToNodeAPI, bQ as NetworkToPepperAPI, bR as NetworkToProverAPI, bK as OrderBy, bL as OrderByValue, as as ParsingError, at as ParsingResult, bF as RoleType, b4 as ScriptPayloadResponse, aw as ScriptTransactionArgumentVariants, bl as ScriptWriteSet, aR as StateCheckpointTransactionResponse, bM as TokenStandard, az as TransactionAuthenticatorVariant, be as TransactionEd25519Signature, bi as TransactionFeePayerSignature, bh as TransactionMultiAgentSignature, bg as TransactionMultiEd25519Signature, b2 as TransactionPayloadResponse, ax as TransactionPayloadVariants, aH as TransactionResponseType, bf as TransactionSecp256k1Signature, b8 as TransactionSignature, ay as TransactionVariants, av as TypeTagVariants, aE as Uint128, aF as Uint256, aD as Uint64, aS as ValidatorTransactionResponse, bk as WriteSet, aV as WriteSetChange, aW as WriteSetChangeDeleteModule, aX as WriteSetChangeDeleteResource, aY as WriteSetChangeDeleteTableItem, aZ as WriteSetChangeWriteModule, a_ as WriteSetChangeWriteResource, a$ as WriteSetChangeWriteTableItem, ao as ensureBoolean, aO as isBlockEpilogueTransactionResponse, aL as isBlockMetadataTransactionResponse, b9 as isEd25519Signature, bc as isFeePayerSignature, aK as isGenesisTransactionResponse, bb as isMultiAgentSignature, bd as isMultiEd25519Signature, aI as isPendingTransactionResponse, ba as isSecp256k1Signature, aM as isStateCheckpointTransactionResponse, aJ as isUserTransactionResponse, aN as isValidatorTransactionResponse, ap as outOfRangeErrorMessage, aq as validateNumberInRange } from './accountAddress-DnSqjhSl.js';
+import { S as Serializable, T as TransactionArgument, H as HexInput, a as Serializer, D as Deserializer, E as EntryFunctionArgument, U as Uint8, b as Uint16, c as Uint32, A as AnyNumber, d as Deserializable, e as Hex, f as AuthenticationKeyScheme, g as AccountAddress, P as PrivateKeyVariants, h as AnyPublicKeyVariant, i as EphemeralPublicKeyVariant, N as Network, C as Client, j as ClientConfig, F as FullNodeConfig, I as IndexerConfig, k as FaucetConfig, l as AptosSettings, m as EphemeralCertificateVariant, Z as ZkpVariant, L as LedgerVersionArg, n as AccountAddressInput, M as MoveModuleId, o as ScriptFunctionArgument, p as MoveFunctionId, q as MoveStructId, r as MoveValue, s as MoveFunctionGenericTypeParam, t as SigningSchemeInput, u as SigningScheme, v as AccountData, w as PaginationArgs, x as MoveModuleBytecode, y as TransactionResponse, z as MoveResource, B as TokenStandardArg, O as OrderByArg, G as GetAccountOwnedTokensQueryResponse, J as GetAccountOwnedTokensFromCollectionResponse, K as GetAccountCollectionsWithOwnedTokenResponse, Q as GetAccountCoinsDataResponse, W as WhereArg, R as GetObjectDataQueryResponse, V as GetCollectionDataResponse, X as GetTokenDataResponse, Y as GetCurrentTokenOwnershipResponse, _ as GetOwnedTokensResponse, $ as GetTokenActivityResponse, a0 as GetEventsResponse, a1 as WaitForTransactionOptions, a2 as UserTransactionResponse, a3 as MoveFunction, a4 as GetFungibleAssetMetadataResponse, a5 as GetFungibleAssetActivitiesResponse, a6 as GetCurrentFungibleAssetBalancesResponse, a7 as LedgerInfo, a8 as Block, a9 as GetChainTopUserTransactionsResponse, aa as GraphqlQuery, ab as GetProcessorStatusResponse, ac as GetANSNameResponse, ad as GetNumberOfDelegatorsResponse, ae as GetDelegatedStakingActivitiesResponse, af as PendingTransactionResponse, ag as CommittedTransactionResponse, ah as GasEstimation, ai as TableItemRequest, aj as GetTableItemsDataResponse, ak as GetTableItemsMetadataResponse, al as ClientRequest, am as ClientResponse, an as AptosRequest, ao as AptosResponse, ap as MimeType } from './accountAddress-6RqI8Aam.js';
+export { aG as AccountAuthenticatorVariant, bp as AccountSignature, at as AddressInvalidReason, aH as AnySignatureVariant, aZ as BlockEndInfo, a_ as BlockEpilogueTransactionResponse, aW as BlockMetadataTransactionResponse, aM as ClientHeadersType, b6 as DecodedTableData, b7 as DeletedTableData, bM as DeriveScheme, bs as DirectWriteSet, b9 as EntryFunctionPayloadResponse, aI as EphemeralSignatureVariant, bu as Event, bt as EventGuid, bP as GenerateAccount, bN as GenerateAccountWithEd25519, bO as GenerateAccountWithSingleSignerSecp256k1Key, bc as GenesisPayload, aV as GenesisTransactionResponse, aw as HexInvalidReason, bH as MoveAbility, bB as MoveAddressType, bG as MoveFunctionVisibility, bJ as MoveModule, bC as MoveObjectType, bD as MoveOptionType, bd as MoveScriptBytecode, bK as MoveStruct, bI as MoveStructField, bE as MoveStructType, bF as MoveType, bz as MoveUint128Type, bw as MoveUint16Type, bA as MoveUint256Type, bx as MoveUint32Type, by as MoveUint64Type, bv as MoveUint8Type, bb as MultisigPayloadResponse, bV as NetworkToChainId, bS as NetworkToFaucetAPI, bQ as NetworkToIndexerAPI, bW as NetworkToNetworkName, bR as NetworkToNodeAPI, bT as NetworkToPepperAPI, bU as NetworkToProverAPI, ay as OrderBy, az as OrderByValue, au as ParsingError, av as ParsingResult, bL as RoleType, ba as ScriptPayloadResponse, aC as ScriptTransactionArgumentVariants, br as ScriptWriteSet, aX as StateCheckpointTransactionResponse, aA as TokenStandard, aF as TransactionAuthenticatorVariant, bk as TransactionEd25519Signature, bo as TransactionFeePayerSignature, bn as TransactionMultiAgentSignature, bm as TransactionMultiEd25519Signature, b8 as TransactionPayloadResponse, aD as TransactionPayloadVariants, aN as TransactionResponseType, bl as TransactionSecp256k1Signature, be as TransactionSignature, aE as TransactionVariants, aB as TypeTagVariants, aK as Uint128, aL as Uint256, aJ as Uint64, aY as ValidatorTransactionResponse, bq as WriteSet, a$ as WriteSetChange, b0 as WriteSetChangeDeleteModule, b1 as WriteSetChangeDeleteResource, b2 as WriteSetChangeDeleteTableItem, b3 as WriteSetChangeWriteModule, b4 as WriteSetChangeWriteResource, b5 as WriteSetChangeWriteTableItem, aq as ensureBoolean, ax as hexToAsciiString, aU as isBlockEpilogueTransactionResponse, aR as isBlockMetadataTransactionResponse, bf as isEd25519Signature, bi as isFeePayerSignature, aQ as isGenesisTransactionResponse, bh as isMultiAgentSignature, bj as isMultiEd25519Signature, aO as isPendingTransactionResponse, bg as isSecp256k1Signature, aS as isStateCheckpointTransactionResponse, aP as isUserTransactionResponse, aT as isValidatorTransactionResponse, ar as outOfRangeErrorMessage, as as validateNumberInRange } from './accountAddress-6RqI8Aam.js';
+import { CallArgument } from '@wgb5445/aptos-intent-npm';
+export { CallArgument } from '@wgb5445/aptos-intent-npm';
 import EventEmitter from 'eventemitter3';
 
 type Maybe<T> = T | null;
@@ -635,8 +637,7 @@ declare class U256 extends Serializable implements TransactionArgument {
  * const vecOfStrings = new MoveVector([new MoveString("hello"), new MoveString("world")]);
  * const vecOfStrings2 = MoveVector.MoveString(["hello", "world"]);
  *
- * @params
- * values: an Array<T> of values where T is a class that implements Serializable
+ * @param values an Array<T> of values where T is a class that implements Serializable
  * @returns a `MoveVector<T>` with the values `values`
  */
 declare class MoveVector<T extends Serializable & EntryFunctionArgument> extends Serializable implements TransactionArgument {
@@ -875,7 +876,7 @@ declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends
      * MoveOption.U8(1).isSome() === true;
      * MoveOption.U8().isSome() === false;
      * MoveOption.U8(undefined).isSome() === false;
-     * @params value: the value used to fill the MoveOption. If `value` is undefined
+     * @param value the value used to fill the MoveOption. If `value` is undefined
      * the resulting MoveOption's .isSome() method will return false.
      * @returns a MoveOption<U8> with an inner value `value`
      */
@@ -887,7 +888,7 @@ declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends
      * MoveOption.U16(1).isSome() === true;
      * MoveOption.U16().isSome() === false;
      * MoveOption.U16(undefined).isSome() === false;
-     * @params value: the value used to fill the MoveOption. If `value` is undefined
+     * @param value the value used to fill the MoveOption. If `value` is undefined
      * the resulting MoveOption's .isSome() method will return false.
      * @returns a MoveOption<U16> with an inner value `value`
      */
@@ -899,7 +900,7 @@ declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends
      * MoveOption.U32(1).isSome() === true;
      * MoveOption.U32().isSome() === false;
      * MoveOption.U32(undefined).isSome() === false;
-     * @params value: the value used to fill the MoveOption. If `value` is undefined
+     * @param value the value used to fill the MoveOption. If `value` is undefined
      * the resulting MoveOption's .isSome() method will return false.
      * @returns a MoveOption<U32> with an inner value `value`
      */
@@ -911,7 +912,7 @@ declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends
      * MoveOption.U64(1).isSome() === true;
      * MoveOption.U64().isSome() === false;
      * MoveOption.U64(undefined).isSome() === false;
-     * @params value: the value used to fill the MoveOption. If `value` is undefined
+     * @param value the value used to fill the MoveOption. If `value` is undefined
      * the resulting MoveOption's .isSome() method will return false.
      * @returns a MoveOption<U64> with an inner value `value`
      */
@@ -923,7 +924,7 @@ declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends
      * MoveOption.U128(1).isSome() === true;
      * MoveOption.U128().isSome() === false;
      * MoveOption.U128(undefined).isSome() === false;
-     * @params value: the value used to fill the MoveOption. If `value` is undefined
+     * @param value the value used to fill the MoveOption. If `value` is undefined
      * the resulting MoveOption's .isSome() method will return false.
      * @returns a MoveOption<U128> with an inner value `value`
      */
@@ -935,7 +936,7 @@ declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends
      * MoveOption.U256(1).isSome() === true;
      * MoveOption.U256().isSome() === false;
      * MoveOption.U256(undefined).isSome() === false;
-     * @params value: the value used to fill the MoveOption. If `value` is undefined
+     * @param value the value used to fill the MoveOption. If `value` is undefined
      * the resulting MoveOption's .isSome() method will return false.
      * @returns a MoveOption<U256> with an inner value `value`
      */
@@ -947,7 +948,7 @@ declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends
      * MoveOption.Bool(true).isSome() === true;
      * MoveOption.Bool().isSome() === false;
      * MoveOption.Bool(undefined).isSome() === false;
-     * @params value: the value used to fill the MoveOption. If `value` is undefined
+     * @param value the value used to fill the MoveOption. If `value` is undefined
      * the resulting MoveOption's .isSome() method will return false.
      * @returns a MoveOption<Bool> with an inner value `value`
      */
@@ -960,7 +961,7 @@ declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends
      * 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
+     * @param 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`
      */
@@ -1132,10 +1133,6 @@ declare abstract class AccountPublicKey extends PublicKey {
 
 /**
  * Represents a private key used for signing messages and deriving the associated public key.
- *
- * @method sign - Signs the given message with the private key.
- * @method publicKey - Derives the public key associated with the private key.
- * @method toUint8Array - Retrieves the private key in bytes.
  */
 interface PrivateKey {
     /**
@@ -1153,6 +1150,37 @@ interface PrivateKey {
      */
     toUint8Array(): Uint8Array;
 }
+declare class PrivateKey {
+    /**
+     * The AIP-80 compliant prefixes for each private key type. Append this to a private key's hex representation
+     * to get an AIP-80 compliant string.
+     *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     */
+    static readonly AIP80_PREFIXES: {
+        ed25519: string;
+        secp256k1: string;
+    };
+    /**
+     * Format a HexInput to an AIP-80 compliant string.
+     *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     *
+     * @param privateKey - The HexString or Uint8Array format of the private key.
+     * @param privateKeyType - The private key type
+     */
+    static formatPrivateKey(privateKey: HexInput, type: PrivateKeyVariants): string;
+    /**
+     * Parse a HexInput that may be a HexString, Uint8Array, or a AIP-80 compliant string to a Hex instance.
+     *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     *
+     * @param value - A HexString, Uint8Array, or a AIP-80 compliant string.
+     * @param privateKeyType - The private key type
+     * @param strict - If true, the value MUST be compliant with AIP-80.
+     */
+    static parseHexInput(value: HexInput, type: PrivateKeyVariants, strict?: boolean): Hex;
+}
 
 /**
  * Checks if an ED25519 signature is non-canonical.
@@ -1247,20 +1275,17 @@ declare class Ed25519PublicKey extends AccountPublicKey {
 }
 /**
  * Represents the private key of an Ed25519 key pair.
- *
- * @static
- * @readonly LENGTH - Length of an Ed25519 private key.
- * @static
- * @readonly SLIP_0010_SEED - The Ed25519 key seed to use for BIP-32 compatibility.
  */
 declare class Ed25519PrivateKey extends Serializable implements PrivateKey {
     /**
      * Length of an Ed25519 private key
+     * @readonly
      */
     static readonly LENGTH: number;
     /**
      * The Ed25519 key seed to use for BIP-32 compatibility
      * See more {@link https://github.com/satoshilabs/slips/blob/master/slip-0010.md}
+     * @readonly
      */
     static readonly SLIP_0010_SEED = "ed25519 seed";
     /**
@@ -1271,9 +1296,12 @@ declare class Ed25519PrivateKey extends Serializable implements PrivateKey {
     /**
      * Create a new PrivateKey instance from a Uint8Array or String.
      *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     *
      * @param hexInput HexInput (string or Uint8Array)
+     * @param strict If true, private key must AIP-80 compliant.
      */
-    constructor(hexInput: HexInput);
+    constructor(hexInput: HexInput, strict?: boolean);
     /**
      * Generate a new random private key.
      *
@@ -1328,6 +1356,20 @@ declare class Ed25519PrivateKey extends Serializable implements PrivateKey {
      * @returns string representation of the private key.
      */
     toString(): string;
+    /**
+     * Get the private key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the private key.
+     */
+    toHexString(): string;
+    /**
+     * Get the private key as a AIP-80 compliant hex string.
+     *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     *
+     * @returns AIP-80 compliant string representation of the private key.
+     */
+    toAIP80String(): string;
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Ed25519PrivateKey;
     /**
@@ -1342,12 +1384,12 @@ declare class Ed25519PrivateKey extends Serializable implements PrivateKey {
 }
 /**
  * Represents a signature of a message signed using an Ed25519 private key.
- *
- * @static LENGTH - Length of an Ed25519 signature, which is 64 bytes.
  */
 declare class Ed25519Signature extends Signature {
     /**
-     * Length of an Ed25519 signature
+     * Length of an Ed25519 signature, which is 64 bytes.
+     *
+     * @readonly
      */
     static readonly LENGTH = 64;
     /**
@@ -1414,7 +1456,6 @@ declare const deriveKey: (hashSeed: Uint8Array | string, data: Uint8Array | stri
  * @param key
  * @param chainCode
  * @param index
- * @constructor
  */
 declare const CKDPriv: ({ key, chainCode }: DerivedKeys, index: number) => DerivedKeys;
 /**
@@ -1938,6 +1979,12 @@ type Groth16VerificationKeyResponse = {
     gamma_abc_g1: [string, string];
     gamma_g2: string;
 };
+type MoveAnyStruct = {
+    variant: {
+        data: string;
+        type_name: string;
+    };
+};
 
 /**
  * Types of API endpoints used for routing requests in the Aptos network.
@@ -2330,6 +2377,12 @@ declare class KeylessSignature extends Signature {
         ephemeralPublicKey: EphemeralPublicKey;
         ephemeralSignature: EphemeralSignature;
     });
+    /**
+     * Get the kid of the JWT used to derive the Keyless Account used to sign.
+     *
+     * @returns the kid as a string
+     */
+    getJwkKid(): string;
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): KeylessSignature;
     static getSimulationSignature(): KeylessSignature;
@@ -2478,12 +2531,12 @@ declare class KeylessConfiguration {
     /**
      * The verification key used to verify Groth16 proofs on chain
      */
-    readonly verficationKey: Groth16VerificationKey;
+    readonly verificationKey: Groth16VerificationKey;
     /**
      * The maximum lifespan of an ephemeral key pair.  This is configured on chain.
      */
     readonly maxExpHorizonSecs: number;
-    constructor(verficationKey: Groth16VerificationKey, maxExpHorizonSecs: number);
+    constructor(verificationKey: Groth16VerificationKey, maxExpHorizonSecs: number);
     static create(res: Groth16VerificationKeyResponse, maxExpHorizonSecs: number): KeylessConfiguration;
 }
 /**
@@ -2505,7 +2558,7 @@ declare class Groth16VerificationKey {
     /**
      * The `gamma^{-1} * (beta * a_i + alpha * b_i + c_i) * H`, where H is the generator of G1
      */
-    readonly gammaAbcG1: G1Bytes[];
+    readonly gammaAbcG1: [G1Bytes, G1Bytes];
     /**
      * The `gamma * H`, where `H` is the generator of G2
      */
@@ -2517,6 +2570,14 @@ declare class Groth16VerificationKey {
         gammaAbcG1: [HexInput, HexInput];
         gammaG2: HexInput;
     });
+    /**
+     * Calculates the hash of the serialized form of the verification key.
+     * This is useful for comparing verification keys or using them as unique identifiers.
+     *
+     * @returns The SHA3-256 hash of the serialized verification key as a Uint8Array
+     */
+    hash(): Uint8Array;
+    serialize(serializer: Serializer): void;
     /**
      * Converts a Groth16VerificationKeyResponse object into a Groth16VerificationKey instance.
      *
@@ -2544,6 +2605,53 @@ declare function getKeylessConfig(args: {
     aptosConfig: AptosConfig;
     options?: LedgerVersionArg;
 }): Promise<KeylessConfiguration>;
+/**
+ * Parses a JWT and returns the 'iss', 'aud', and 'uid' values.
+ *
+ * @param args - The arguments for parsing the JWT.
+ * @param args.jwt - The JWT to parse.
+ * @param args.uidKey - The key to use for the 'uid' value; defaults to 'sub'.
+ * @returns The 'iss', 'aud', and 'uid' values from the JWT.
+ */
+declare function getIssAudAndUidVal(args: {
+    jwt: string;
+    uidKey?: string;
+}): {
+    iss: string;
+    aud: string;
+    uidVal: string;
+};
+declare function getKeylessJWKs(args: {
+    aptosConfig: AptosConfig;
+    jwkAddr?: AccountAddressInput;
+    options?: LedgerVersionArg;
+}): Promise<Map<string, MoveJWK[]>>;
+declare class MoveJWK extends Serializable {
+    kid: string;
+    kty: string;
+    alg: string;
+    e: string;
+    n: string;
+    constructor(args: {
+        kid: string;
+        kty: string;
+        alg: string;
+        e: string;
+        n: string;
+    });
+    serialize(serializer: Serializer): void;
+    static fromMoveStruct(struct: MoveAnyStruct): MoveJWK;
+    static deserialize(deserializer: Deserializer): MoveJWK;
+}
+interface JwtHeader {
+    kid: string;
+}
+/**
+ * Safely parses the JWT header.
+ * @param jwtHeader The JWT header string
+ * @returns Parsed JWT header as an object.
+ */
+declare function parseJwtHeader(jwtHeader: string): JwtHeader;
 
 /**
  * Represents the FederatedKeylessPublicKey public key
@@ -2661,7 +2769,6 @@ declare function poseidonHash(inputs: (number | bigint | string)[]): bigint;
  * Represents a Secp256k1 ECDSA public key.
  *
  * @extends PublicKey
- * @static
  * @property LENGTH - The length of the Secp256k1 public key in bytes.
  */
 declare class Secp256k1PublicKey extends PublicKey {
@@ -2739,9 +2846,12 @@ declare class Secp256k1PrivateKey extends Serializable implements PrivateKey {
     /**
      * Create a new PrivateKey instance from a Uint8Array or String.
      *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     *
      * @param hexInput A HexInput (string or Uint8Array)
+     * @param strict If true, private key must AIP-80 compliant.
      */
-    constructor(hexInput: HexInput);
+    constructor(hexInput: HexInput, strict?: boolean);
     /**
      * Generate a new random private key.
      *
@@ -2795,6 +2905,20 @@ declare class Secp256k1PrivateKey extends Serializable implements PrivateKey {
      * @returns string representation of the private key
      */
     toString(): string;
+    /**
+     * Get the private key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the private key.
+     */
+    toHexString(): string;
+    /**
+     * Get the private key as a AIP-80 compliant hex string.
+     *
+     * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
+     *
+     * @returns AIP-80 compliant string representation of the private key.
+     */
+    toAIP80String(): string;
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Secp256k1PrivateKey;
     /**
@@ -2809,13 +2933,11 @@ declare class Secp256k1PrivateKey extends Serializable implements PrivateKey {
 /**
  * Represents a signature of a message signed using a Secp256k1 ECDSA private key.
  *
- * @static
- * @readonly
- * @length The length of Secp256k1 ECDSA signatures, which is 64 bytes.
  */
 declare class Secp256k1Signature extends Signature {
     /**
-     * Secp256k1 ecdsa signatures are 256-bit.
+     * Secp256k1 ecdsa signatures are 256-bit or 64 bytes
+     * @readonly
      */
     static readonly LENGTH = 64;
     /**
@@ -3834,6 +3956,11 @@ declare abstract class TransactionAuthenticator extends Serializable {
      * @param deserializer - The deserializer instance used to read the serialized data.
      */
     static deserialize(deserializer: Deserializer): TransactionAuthenticator;
+    isEd25519(): this is TransactionAuthenticatorEd25519;
+    isMultiEd25519(): this is TransactionAuthenticatorMultiEd25519;
+    isMultiAgent(): this is TransactionAuthenticatorMultiAgent;
+    isFeePayer(): this is TransactionAuthenticatorFeePayer;
+    isSingleSender(): this is TransactionAuthenticatorSingleSender;
 }
 /**
  * Represents a transaction authenticator using Ed25519 for a single signer transaction.
@@ -4143,6 +4270,14 @@ type InputMultiSigDataWithABI = {
 type InputEntryFunctionDataWithRemoteABI = InputEntryFunctionData & {
     aptosConfig: AptosConfig;
 };
+/**
+ * The data needed to generate a batched function payload
+ */
+type InputBatchedFunctionData = {
+    function: MoveFunctionId;
+    typeArguments?: Array<TypeArgument>;
+    functionArguments: Array<EntryFunctionArgumentTypes | CallArgument | SimpleEntryFunctionArgumentTypes>;
+};
 /**
  * The data needed to generate a Multi Sig payload
  */
@@ -4904,11 +5039,18 @@ declare class EphemeralKeyPair extends Serializable {
     sign(data: HexInput): EphemeralSignature;
 }
 
+/**
+ * An interface which defines if an Account utilizes Keyless signing.
+ */
+interface KeylessSigner extends Account$1 {
+    checkKeylessAccountValidity(aptosConfig: AptosConfig): Promise<void>;
+}
+declare function isKeylessSigner(obj: any): obj is KeylessSigner;
 /**
  * Account implementation for the Keyless authentication scheme.  This abstract class is used for standard Keyless Accounts
  * and Federated Keyless Accounts.
  */
-declare abstract class AbstractKeylessAccount extends Serializable implements Account$1 {
+declare abstract class AbstractKeylessAccount extends Serializable implements KeylessSigner {
     static readonly PEPPER_LENGTH: number;
     /**
      * The KeylessPublicKey associated with the account
@@ -4956,10 +5098,34 @@ declare abstract class AbstractKeylessAccount extends Serializable implements Ac
      * The JWT token used to derive the account
      */
     readonly jwt: string;
+    /**
+     * The hash of the verification key used to verify the proof. This is optional and can be used to check verifying key
+     * rotations which may invalidate the proof.
+     */
+    readonly verificationKeyHash?: Uint8Array;
     /**
      * An event emitter used to assist in handling asynchronous proof fetching.
      */
     private readonly emitter;
+    /**
+     * Use the static generator `create(...)` instead.
+     * Creates an instance of the KeylessAccount with an optional proof.
+     *
+     * @param args - The parameters for creating a KeylessAccount.
+     * @param args.address - Optional account address associated with the KeylessAccount.
+     * @param args.publicKey - A KeylessPublicKey or FederatedKeylessPublicKey.
+     * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
+     * @param args.iss - A JWT issuer.
+     * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.
+     * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.
+     * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's
+     * OIDC registration with the identity provider.
+     * @param args.pepper - A hexadecimal input used for additional security.
+     * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
+     * @param args.proofFetchCallback - Optional callback function for fetching proof.
+     * @param args.jwt - A JSON Web Token used for authentication.
+     * @param args.verificationKeyHash Optional 32-byte verification key hash as hex input used to check proof validity.
+     */
     protected constructor(args: {
         address?: AccountAddress;
         publicKey: KeylessPublicKey | FederatedKeylessPublicKey;
@@ -4972,13 +5138,29 @@ declare abstract class AbstractKeylessAccount extends Serializable implements Ac
         proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
         proofFetchCallback?: ProofFetchCallback;
         jwt: string;
+        verificationKeyHash?: HexInput;
     });
     /**
-     * This initializes the asynchronous proof fetch
-     * @return
+     * This initializes the asynchronous proof fetch.
+     * @return Emits whether the proof succeeds or fails, but has no return.
      */
     init(promise: Promise<ZeroKnowledgeSig>): Promise<void>;
+    /**
+     * Serializes the jwt data into a format suitable for transmission or storage.
+     * This function ensures that both the jwt data and the proof are properly serialized.
+     *
+     * @param serializer - The serializer instance used to convert the jwt data into bytes.
+     */
     serialize(serializer: Serializer): void;
+    static partialDeserialize(deserializer: Deserializer): {
+        address: AccountAddress;
+        jwt: string;
+        uidKey: string;
+        pepper: Uint8Array;
+        ephemeralKeyPair: EphemeralKeyPair;
+        proof: ZeroKnowledgeSig;
+        verificationKeyHash?: Uint8Array;
+    };
     /**
      * Checks if the proof is expired.  If so the account must be re-derived with a new EphemeralKeyPair
      * and JWT token.
@@ -5002,6 +5184,11 @@ declare abstract class AbstractKeylessAccount extends Serializable implements Ac
      * @return
      */
     waitForProofFetch(): Promise<void>;
+    /**
+     * Validates that the Keyless Account can be used to sign transactions.
+     * @return
+     */
+    checkKeylessAccountValidity(aptosConfig: AptosConfig): Promise<void>;
     /**
      * Sign the given message using Keyless.
      * @param message in HexInput format
@@ -5030,6 +5217,19 @@ declare abstract class AbstractKeylessAccount extends Serializable implements Ac
         message: HexInput;
         signature: KeylessSignature;
     }): boolean;
+    /**
+     * Fetches the JWK from the issuer's well-known JWKS endpoint.
+     *
+     * @param args.publicKey The keyless public key to query
+     * @param args.kid The kid of the JWK to fetch
+     * @returns A JWK matching the `kid` in the JWT header.
+     * @throws {KeylessError} If the JWK cannot be fetched
+     */
+    static fetchJWK(args: {
+        aptosConfig: AptosConfig;
+        publicKey: KeylessPublicKey | FederatedKeylessPublicKey;
+        kid: string;
+    }): Promise<MoveJWK>;
 }
 /**
  * A container class to hold a transaction and a proof.  It implements CryptoHashable which is used to create
@@ -5049,6 +5249,12 @@ declare class TransactionAndProof extends Serializable {
      */
     readonly domainSeparator = "APTOS::TransactionAndProof";
     constructor(transaction: AnyRawTransactionInstance, proof?: ZkProof);
+    /**
+     * Serializes the transaction data into a format suitable for transmission or storage.
+     * This function ensures that both the transaction bytes and the proof are properly serialized.
+     *
+     * @param serializer - The serializer instance used to convert the transaction data into bytes.
+     */
     serialize(serializer: Serializer): void;
     /**
      * Hashes the bcs serialized from of the class. This is the typescript corollary to the BCSCryptoHash macro in aptos-core.
@@ -5079,9 +5285,6 @@ interface ProofFetchEvents {
  *
  * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,
  * EphemeralKeyPair, and corresponding proof.
- *
- * @static
- * @readonly PEPPER_LENGTH - The length of the pepper used for privacy preservation.
  */
 declare class KeylessAccount extends AbstractKeylessAccount {
     /**
@@ -5089,9 +5292,21 @@ declare class KeylessAccount extends AbstractKeylessAccount {
      */
     readonly publicKey: KeylessPublicKey;
     /**
-     * Creates an instance of the transaction with an optional proof.
+     * Use the static generator `create(...)` instead.
+     * Creates an instance of the KeylessAccount with an optional proof.
      *
-     * @param args.proof - An optional ZkProof associated with the transaction.
+     * @param args - The parameters for creating a KeylessAccount.
+     * @param args.address - Optional account address associated with the KeylessAccount.
+     * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
+     * @param args.iss - A JWT issuer.
+     * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.
+     * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.
+     * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's
+     * OIDC registration with the identity provider.
+     * @param args.pepper - A hexadecimal input used for additional security.
+     * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
+     * @param args.proofFetchCallback - Optional callback function for fetching proof.
+     * @param args.jwt - A JSON Web Token used for authentication.
      */
     private constructor();
     /**
@@ -5109,10 +5324,17 @@ declare class KeylessAccount extends AbstractKeylessAccount {
      * @returns A KeylessAccount instance created from the deserialized data.
      */
     static deserialize(deserializer: Deserializer): KeylessAccount;
-    static fromBytes(bytes: Uint8Array): KeylessAccount;
+    /**
+     * Deserialize bytes using this account's information.
+     *
+     * @param bytes The bytes being interpreted.
+     * @returns
+     */
+    static fromBytes(bytes: HexInput): KeylessAccount;
     /**
      * Creates a KeylessAccount instance using the provided parameters.
      * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
+     * This is used instead of the KeylessAccount constructor.
      *
      * @param args - The parameters for creating a KeylessAccount.
      * @param args.address - Optional account address associated with the KeylessAccount.
@@ -5131,6 +5353,7 @@ declare class KeylessAccount extends AbstractKeylessAccount {
         pepper: HexInput;
         uidKey?: string;
         proofFetchCallback?: ProofFetchCallback;
+        verificationKey?: Groth16VerificationKey;
     }): KeylessAccount;
 }
 
@@ -5139,8 +5362,8 @@ declare class KeylessAccount extends AbstractKeylessAccount {
  *
  * Used to represent a FederatedKeyless based account and sign transactions with it.
  *
- * Use `FederatedKeylessAccount.create()` to instantiate a KeylessAccount with a JWT, proof, EphemeralKeyPair and the
- * address the JWKs are installed that will be used to verify the JWT.
+ * Use `FederatedKeylessAccount.create()` to instantiate a KeylessAccount with a JSON Web Token (JWT), proof, EphemeralKeyPair and the
+ * address the JSON Web Key Set (JWKS) are installed that will be used to verify the JWT.
  *
  * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,
  * EphemeralKeyPair, and corresponding proof.
@@ -5150,10 +5373,57 @@ declare class FederatedKeylessAccount extends AbstractKeylessAccount {
      * The FederatedKeylessPublicKey associated with the account
      */
     readonly publicKey: FederatedKeylessPublicKey;
+    /**
+     * Use the static generator `FederatedKeylessAccount.create(...)` instead.
+     * Creates a KeylessAccount instance using the provided parameters.
+     * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
+     *
+     * @param args - The parameters for creating a KeylessAccount.
+     * @param args.address - Optional account address associated with the KeylessAccount.
+     * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
+     * @param args.jwt - A JSON Web Token used for authentication.
+     * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
+     * @param args.jwkAddress - The address which stores the JSON Web Key Set (JWKS) used to verify the JWT.
+     * @param args.uidKey - Optional key for user identification, defaults to "sub".
+     * @param args.proofFetchCallback - Optional callback function for fetching proof.
+     */
     private constructor();
+    /**
+     * Serializes the transaction data into a format suitable for transmission or storage.
+     * This function ensures that both the transaction bytes and the proof are properly serialized.
+     *
+     * @param serializer - The serializer instance used to convert the transaction data into bytes.
+     */
     serialize(serializer: Serializer): void;
+    /**
+     * Deserializes the provided deserializer to create a KeylessAccount instance.
+     * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.
+     *
+     * @param deserializer - The deserializer instance used to retrieve the serialized data.
+     * @returns A KeylessAccount instance created from the deserialized data.
+     */
     static deserialize(deserializer: Deserializer): FederatedKeylessAccount;
-    static fromBytes(bytes: Uint8Array): FederatedKeylessAccount;
+    /**
+     * Deserialize bytes using this account's information.
+     *
+     * @param bytes The bytes being interpreted.
+     * @returns
+     */
+    static fromBytes(bytes: HexInput): FederatedKeylessAccount;
+    /**
+     * Creates a KeylessAccount instance using the provided parameters.
+     * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
+     * This is used instead of the KeylessAccount constructor.
+     *
+     * @param args - The parameters for creating a KeylessAccount.
+     * @param args.address - Optional account address associated with the KeylessAccount.
+     * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
+     * @param args.jwt - A JSON Web Token used for authentication.
+     * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
+     * @param args.jwkAddress - The address which stores the JSON Web Key Set (JWKS) used to verify the JWT.
+     * @param args.uidKey - Optional key for user identification, defaults to "sub".
+     * @param args.proofFetchCallback - Optional callback function for fetching proof.
+     */
     static create(args: {
         address?: AccountAddress;
         proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
@@ -5163,6 +5433,7 @@ declare class FederatedKeylessAccount extends AbstractKeylessAccount {
         jwkAddress: AccountAddressInput;
         uidKey?: string;
         proofFetchCallback?: ProofFetchCallback;
+        verificationKey?: Groth16VerificationKey;
     }): FederatedKeylessAccount;
 }
 
@@ -5184,7 +5455,7 @@ interface VerifyMultiKeySignatureArgs {
  *
  * Note: Generating a signer instance does not create the account on-chain.
  */
-declare class MultiKeyAccount implements Account$1 {
+declare class MultiKeyAccount implements Account$1, KeylessSigner {
     /**
      * Public key associated with the account
      */
@@ -5264,9 +5535,14 @@ declare class MultiKeyAccount implements Account$1 {
      */
     waitForProofFetch(): Promise<void>;
     /**
-     * Sign the given data using the MultiKeyAccount's signers.
-     * @param data - The data to be signed in HexInput format.
-     * @returns MultiKeySignature - The resulting multi-key signature.
+     * Validates that the Keyless Account can be used to sign transactions.
+     * @return
+     */
+    checkKeylessAccountValidity(aptosConfig: AptosConfig): Promise<void>;
+    /**
+     * Sign the given message using the MultiKeyAccount's signers
+     * @param message in HexInput format
+     * @returns MultiKeySignature
      */
     sign(data: HexInput): MultiKeySignature;
     /**
@@ -7546,6 +7822,14 @@ declare function standardizeTypeTags(typeArguments?: Array<TypeArgument>): Array
  * @param aptosConfig - The configuration settings for Aptos.
  */
 declare function fetchFunctionAbi(moduleAddress: string, moduleName: string, functionName: string, aptosConfig: AptosConfig): Promise<MoveFunction | undefined>;
+/**
+ * Fetches a function ABI from the on-chain module ABI.  It doesn't validate whether it's a view or entry function.
+ * @param moduleAddress
+ * @param moduleName
+ * @param functionName
+ * @param aptosConfig
+ */
+declare function fetchMoveFunctionAbi(moduleAddress: string, moduleName: string, functionName: string, aptosConfig: AptosConfig): Promise<FunctionABI>;
 /**
  * Fetches the ABI for an entry function from the specified module address.
  * This function validates if the ABI corresponds to an entry function and retrieves its parameters.
@@ -7570,6 +7854,18 @@ declare function fetchEntryFunctionAbi(moduleAddress: string, moduleName: string
  * @throws Error if the ABI cannot be found or if the function is not a view function.
  */
 declare function fetchViewFunctionAbi(moduleAddress: string, moduleName: string, functionName: string, aptosConfig: AptosConfig): Promise<ViewFunctionABI>;
+/**
+ * Converts a entry function argument into CallArgument, if necessary.
+ * This function checks the provided argument against the expected parameter type and converts it accordingly.
+ *
+ * @param functionName - The name of the function for which the argument is being converted.
+ * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.
+ * @param argument - The argument to be converted, which can be of various types. If the argument is already
+ *                   CallArgument returned from TransactionComposer it would be returned immediately.
+ * @param position - The index of the argument in the function's parameter list.
+ * @param genericTypeParams - An array of type tags for any generic type parameters.
+ */
+declare function convertCallArgument(argument: CallArgument | EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes, functionName: string, functionAbi: FunctionABI, position: number, genericTypeParams: Array<TypeTag>): CallArgument;
 /**
  * Converts a non-BCS encoded argument into BCS encoded, if necessary.
  * This function checks the provided argument against the expected parameter type and converts it accordingly.
@@ -7701,6 +7997,14 @@ declare function parseTypeTag(typeStr: string, options?: {
     allowGenerics?: boolean;
 }): TypeTag;
 
+declare class AptosScriptComposer {
+    private builder;
+    private config;
+    constructor(aptosConfig: AptosConfig);
+    addBatchedCalls(input: InputBatchedFunctionData): Promise<CallArgument[]>;
+    build(): Uint8Array;
+}
+
 /**
  * A class for querying and managing fungible asset-related operations on the Aptos blockchain.
  */
@@ -8972,6 +9276,70 @@ declare class Build {
         options?: InputGenerateTransactionOptions;
         withFeePayer?: boolean;
     }): Promise<SimpleTransaction>;
+    /**
+     * Build a transaction from a series of Move calls.
+     *
+     * This function allows you to create a transaction with a list of Move calls.
+     *
+     * Right now we only tested this logic with single signer and we will add support
+     * for mutli agent transactions if needed.
+     *
+     * @param args.sender - The sender account address.
+     * @param args.builder - The closure to construct the list of calls.
+     * @param args.options - Optional transaction configurations.
+     * @param args.withFeePayer - Whether there is a fee payer for the transaction.
+     *
+     * @returns SimpleTransaction
+     *
+     * @example
+     * ```typescript
+     * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+     *
+     * const config = new AptosConfig({ network: Network.TESTNET });
+     * const aptos = new Aptos(config);
+     *
+     * async function runExample() {
+     *   // Build a transaction from a chained series of Move calls.
+     *   const transaction = await aptos.transaction.script_composer({
+     *     sender: "0x1", // replace with a real sender account address
+     *     builder: builder: async (builder) => {
+     *       const coin = await builder.addBatchedCalls({
+     *          function: "0x1::coin::withdraw",
+     *          functionArguments: [CallArgument.new_signer(0), 1],
+     *          typeArguments: ["0x1::aptos_coin::AptosCoin"],
+     *        });
+     *
+     *        // Pass the returned value from the first function call to the second call
+     *        const fungibleAsset = await builder.addBatchedCalls({
+     *          function: "0x1::coin::coin_to_fungible_asset",
+     *          functionArguments: [coin[0]],
+     *          typeArguments: ["0x1::aptos_coin::AptosCoin"],
+     *        });
+     *
+     *        await builder.addBatchedCalls({
+     *          function: "0x1::primary_fungible_store::deposit",
+     *          functionArguments: [singleSignerED25519SenderAccount.accountAddress, fungibleAsset[0]],
+     *          typeArguments: [],
+     *        });
+     *        return builder;
+     *     },
+     *     options: {
+     *       gasUnitPrice: 100, // specify your own gas unit price if needed
+     *       maxGasAmount: 1000, // specify your own max gas amount if needed
+     *     },
+     *   });
+     *
+     *   console.log(transaction);
+     * }
+     * runExample().catch(console.error);
+     * ```
+     */
+    scriptComposer(args: {
+        sender: AccountAddressInput;
+        builder: (builder: AptosScriptComposer) => Promise<AptosScriptComposer>;
+        options?: InputGenerateTransactionOptions;
+        withFeePayer?: boolean;
+    }): Promise<SimpleTransaction>;
     /**
      * Build a multi-agent transaction that allows multiple signers to authorize a transaction.
      *
@@ -10661,7 +11029,7 @@ declare class Keyless {
     /**
      * This installs a set of FederatedJWKs at an address for a given iss.
      *
-     * It will fetch the JWK set from the well-known endpoint and update the FederatedJWKs at the sender's address
+     * It will fetch the JSON Web Keyset (JWK) set from the well-known endpoint and update the FederatedJWKs at the sender's address
      * to reflect it.
      *
      * @param args.sender The account that will install the JWKs
@@ -10810,64 +11178,6 @@ declare class Aptos {
 interface Aptos extends Account, ANS, Coin, DigitalAsset, Event, Faucet, FungibleAsset, General, Keyless, Staking, Table, AptosObject, Omit<Transaction, "build" | "simulate" | "submit" | "batch"> {
 }
 
-/**
- * The API response type
- *
- * @param status - the response status. i.e. 200
- * @param statusText - the response message
- * @param data the response data
- * @param url the url the request was made to
- * @param headers the response headers
- * @param config (optional) - the request object
- * @param request (optional) - the request object
- */
-interface AptosResponse<Req, Res> {
-    status: number;
-    statusText: string;
-    data: Res;
-    url: string;
-    headers: any;
-    config?: any;
-    request?: Req;
-}
-/**
- * Options for handling errors in the Aptos API.
- */
-type AptosApiErrorOpts = {
-    apiType: AptosApiType;
-    aptosRequest: AptosRequest;
-    aptosResponse: AptosResponse<any, any>;
-};
-/**
- * Represents an error returned from the Aptos API.
- * This class encapsulates the details of the error, including the request URL, response status, and additional data.
- *
- * @param name - The name of the error, which is always "AptosApiError".
- * @param url - The URL to which the request was made.
- * @param status - The HTTP response status code (e.g., 400).
- * @param statusText - The message associated with the response status.
- * @param data - The response data returned from the API.
- * @param request - The original AptosRequest that triggered the error.
- */
-declare class AptosApiError extends Error {
-    readonly url: string;
-    readonly status: number;
-    readonly statusText: string;
-    readonly data: any;
-    readonly request: AptosRequest;
-    /**
-     * Constructs an instance of AptosApiError with relevant error details.
-     *
-     * @param opts - The options for creating the AptosApiError.
-     * @param opts.apiType - The type of API that generated the error.
-     * @param opts.aptosRequest - The request object that caused the error.
-     * @param opts.aptosResponse - The response object containing error details.
-     *
-     * @internal This constructor is for SDK internal use - do not instantiate outside the SDK codebase.
-     */
-    constructor({ apiType, aptosRequest, aptosResponse }: AptosApiErrorOpts);
-}
-
 type DeserializableClass<T extends Serializable> = {
     /**
      * Deserializes a serialized object using the provided deserializer.
@@ -10893,6 +11203,13 @@ declare function normalizeBundle<T extends Serializable>(cls: DeserializableClas
  * @param timeMs - The time in milliseconds to sleep.
  */
 declare function sleep(timeMs: number): Promise<null>;
+/**
+ * Get the error message from an unknown error.
+ *
+ * @param error The error to get the message from
+ * @returns The error message
+ */
+declare function getErrorMessage(error: unknown): string;
 declare const nowInSeconds: () => number;
 /**
  * Floors the given timestamp to the nearest whole hour.
@@ -11192,4 +11509,118 @@ declare function postAptosPepperService<Req extends {}, Res extends {}>(options:
  */
 declare function postAptosProvingService<Req extends {}, Res extends {}>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
 
-export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_FA, APTOS_HARDENED_REGEX, AbstractKeylessAccount, Account$1 as Account, AccountAddress, AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountData, AccountPublicKey, AccountSequenceNumber, AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, AptosRequest, type AptosResponse, AptosSettings, AuthenticationKey, AuthenticationKeyScheme, Block, Bool, CKDPriv, ChainId, Client, ClientConfig, ClientRequest, ClientResponse, CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DerivedKeys, Deserializable, type DeserializableClass, Deserializer, EPK_HORIZON_SECS, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, EphemeralCertificate, EphemeralCertificateVariant, EphemeralKeyPair, EphemeralPublicKey, EphemeralPublicKeyVariant, EphemeralSignature, type ExecutionFinishEventData, type FailureEventData, FaucetConfig, FederatedKeylessAccount, FederatedKeylessPublicKey, FeePayerRawTransaction, FixedBytes, FullNodeConfig, type FunctionABI, GasEstimation, type GenerateAccountArgs, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, GetANSNameResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetObjectDataQueryResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, type GetRequestOptions, GetTableItemsDataResponse, GetTableItemsMetadataResponse, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, Groth16Zkp, HARDENED_OFFSET, Hex, HexInput, Identifier, IndexerConfig, 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 InputViewFunctionData, type InputViewFunctionDataWithABI, type InputViewFunctionDataWithRemoteABI, type InputViewFunctionJsonData, KeyType, KeylessAccount, KeylessConfiguration, KeylessPublicKey, KeylessSignature, LedgerInfo, LedgerVersionArg, MAX_AUD_VAL_BYTES, MAX_COMMITED_EPK_BYTES, MAX_EXTRA_FIELD_BYTES, MAX_ISS_VAL_BYTES, MAX_JWT_HEADER_B64_BYTES, MAX_UID_KEY_BYTES, MAX_UID_VAL_BYTES, MimeType, ModuleId, MoveFunction, MoveFunctionGenericTypeParam, MoveFunctionId, MoveModuleBytecode, MoveModuleId, MoveOption, MoveResource, MoveString, MoveStructId, MoveValue, MoveVector, MultiAgentRawTransaction, MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeyAccount, MultiKeySignature, MultiSig, MultiSigTransactionPayload, Network, OrderByArg, PaginationArgs, PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, type PrivateKey, type PrivateKeyFromDerivationPathArgs, ProcessorType, type ProofFetchCallback, type ProofFetchEvents, type ProofFetchFailure, type ProofFetchStatus, type ProofFetchSuccess, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RotationProofChallenge, Script, ScriptFunctionArgument, type ScriptFunctionArgumentTypes, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serialized, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, StructTag, type SuccessEventData, TableItemRequest, TokenStandardArg, TransactionAndProof, TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, TransactionPayloadScript, TransactionResponse, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, type TypeArgument, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVector, U128, U16, U256, U32, U64, U8, Uint16, Uint32, Uint8, UserTransactionResponse, type VerifyEd25519SignatureArgs, type VerifyMultiKeySignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewFunctionABI, type ViewFunctionJsonPayload, WaitForTransactionOptions, WhereArg, ZeroKnowledgeSig, ZkProof, ZkpVariant, aptosCoinStructTag, aptosRequest, base64UrlDecode, bigIntToBytesLE, buildTransaction, bytesToBigIntLE, checkOrConvertArgument, convertAmountFromHumanReadableToOnChain, convertAmountFromOnChainToHumanReadable, convertArgument, convertNumber, createObjectAddress, createResourceAddress, createTokenAddress, deriveKey, deriveTransactionType, deserializeFromScriptArgument, fetchEntryFunctionAbi, fetchFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, floorToWholeHour, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateSigningMessageForSerializable, generateSigningMessageForTransaction, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAptosPepperService, getAuthenticatorForSimulation, getFunctionParts, getKeylessConfig, hashStrToField, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBool, isCanonicalEd25519Signature, isEmptyOption, isEncodedEntryFunctionArgument, isEncodedStruct, isLargeNumber, isNumber, isScriptDataInput, isString, isValidBIP44Path, isValidHardenedPath, mnemonicToSeed, normalizeBundle, nowInSeconds, objectStructTag, optionStructTag, padAndPackBytesWithLen, paginateWithCursor, parseEncodedStruct, parseTypeTag, poseidonHash, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, postAptosPepperService, postAptosProvingService, promiseFulfilledStatus, request, sleep, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch };
+declare enum KeylessErrorCategory {
+    API_ERROR = 0,
+    EXTERNAL_API_ERROR = 1,
+    SESSION_EXPIRED = 2,
+    INVALID_STATE = 3,
+    UNKNOWN = 4
+}
+declare enum KeylessErrorResolutionTip {
+    REAUTHENTICATE = "Re-authentiate to continue using your keyless account",
+    REAUTHENTICATE_UNSURE = "Try re-authentiating. If the error persists join the telegram group at https://t.me/+h5CN-W35yUFiYzkx for further support",
+    UPDATE_REQUEST_PARAMS = "Update the invalid request parameters and reauthenticate.",
+    RATE_LIMIT_EXCEEDED = "Cache the keyless account and reuse it to avoid making too many requests.  Keyless accounts are valid until either the EphemeralKeyPair expires, when the JWK is rotated, or when the proof verifying key is changed, whichever comes soonest.",
+    SERVER_ERROR = "Try again later.  See aptosApiError error for more context. For additional support join the telegram group at https://t.me/+h5CN-W35yUFiYzkx",
+    CALL_PRECHECK = "Call `await account.checkKeylessAccountValidity()` to wait for asyncronous changes and check for account validity before signing or serializing.",
+    REINSTANTIATE = "Try instantiating the account again.  Avoid manipulating the account object directly",
+    JOIN_SUPPORT_GROUP = "For support join the telegram group at https://t.me/+h5CN-W35yUFiYzkx",
+    UNKNOWN = "Error unknown. For support join the telegram group at https://t.me/+h5CN-W35yUFiYzkx"
+}
+declare enum KeylessErrorType {
+    EPHEMERAL_KEY_PAIR_EXPIRED = 0,
+    PROOF_NOT_FOUND = 1,
+    ASYNC_PROOF_FETCH_FAILED = 2,
+    INVALID_PROOF_VERIFICATION_FAILED = 3,
+    INVALID_PROOF_VERIFICATION_KEY_NOT_FOUND = 4,
+    INVALID_JWT_SIG = 5,
+    INVALID_JWT_JWK_NOT_FOUND = 6,
+    INVALID_JWT_ISS_NOT_RECOGNIZED = 7,
+    INVALID_JWT_FEDERATED_ISS_NOT_SUPPORTED = 8,
+    INVALID_TW_SIG_VERIFICATION_FAILED = 9,
+    INVALID_TW_SIG_PUBLIC_KEY_NOT_FOUND = 10,
+    INVALID_EXPIRY_HORIZON = 11,
+    JWT_PARSING_ERROR = 12,
+    JWK_FETCH_FAILED = 13,
+    JWK_FETCH_FAILED_FEDERATED = 14,
+    RATE_LIMIT_EXCEEDED = 15,
+    PEPPER_SERVICE_INTERNAL_ERROR = 16,
+    PEPPER_SERVICE_BAD_REQUEST = 17,
+    PEPPER_SERVICE_OTHER = 18,
+    PROVER_SERVICE_INTERNAL_ERROR = 19,
+    PROVER_SERVICE_BAD_REQUEST = 20,
+    PROVER_SERVICE_OTHER = 21,
+    FULL_NODE_CONFIG_LOOKUP_ERROR = 22,
+    FULL_NODE_VERIFICATION_KEY_LOOKUP_ERROR = 23,
+    FULL_NODE_JWKS_LOOKUP_ERROR = 24,
+    FULL_NODE_OTHER = 25,
+    UNKNOWN = 26
+}
+declare class KeylessError extends Error {
+    readonly innerError?: unknown;
+    readonly category: KeylessErrorCategory;
+    readonly resolutionTip: KeylessErrorResolutionTip;
+    readonly type: KeylessErrorType;
+    readonly details?: string;
+    /** @internal this constructor is for sdk internal use - do not instantiate outside of the SDK codebase */
+    constructor(args: {
+        innerError?: unknown;
+        category: KeylessErrorCategory;
+        resolutionTip: KeylessErrorResolutionTip;
+        type: KeylessErrorType;
+        message?: string;
+        details?: string;
+    });
+    static constructMessage(message: string, tip: KeylessErrorResolutionTip, innerError?: unknown, details?: string): string;
+    /**
+     * Static constructor that creates a KeylessError instance using the KeylessErrors constant
+     * @param args.type The type of KeylessError
+     * @param args.aptosApiError optional AptosApiError supplied for api errors
+     * @param args.details optional details to include in the error message
+     * @returns A new KeylessError instance
+     */
+    static fromErrorType(args: {
+        type: KeylessErrorType;
+        error?: unknown;
+        details?: string;
+    }): KeylessError;
+}
+/**
+ * Options for handling errors in the Aptos API.
+ */
+type AptosApiErrorOpts = {
+    apiType: AptosApiType;
+    aptosRequest: AptosRequest;
+    aptosResponse: AptosResponse<any, any>;
+};
+/**
+ * Represents an error returned from the Aptos API.
+ * This class encapsulates the details of the error, including the request URL, response status, and additional data.
+ *
+ * @param name - The name of the error, which is always "AptosApiError".
+ * @param url - The URL to which the request was made.
+ * @param status - The HTTP response status code (e.g., 400).
+ * @param statusText - The message associated with the response status.
+ * @param data - The response data returned from the API.
+ * @param request - The original AptosRequest that triggered the error.
+ */
+declare class AptosApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly data: any;
+    readonly request: AptosRequest;
+    /**
+     * Constructs an instance of AptosApiError with relevant error details.
+     *
+     * @param opts - The options for creating the AptosApiError.
+     * @param opts.apiType - The type of API that generated the error.
+     * @param opts.aptosRequest - The request object that caused the error.
+     * @param opts.aptosResponse - The response object containing error details.
+     *
+     * @internal This constructor is for SDK internal use - do not instantiate outside the SDK codebase.
+     */
+    constructor({ apiType, aptosRequest, aptosResponse }: AptosApiErrorOpts);
+}
+
+export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_FA, APTOS_HARDENED_REGEX, AbstractKeylessAccount, Account$1 as Account, AccountAddress, AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountData, AccountPublicKey, AccountSequenceNumber, AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, AptosRequest, AptosResponse, AptosScriptComposer, AptosSettings, AuthenticationKey, AuthenticationKeyScheme, Block, Bool, CKDPriv, ChainId, Client, ClientConfig, ClientRequest, ClientResponse, CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DerivedKeys, Deserializable, type DeserializableClass, Deserializer, EPK_HORIZON_SECS, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, EphemeralCertificate, EphemeralCertificateVariant, EphemeralKeyPair, EphemeralPublicKey, EphemeralPublicKeyVariant, EphemeralSignature, type ExecutionFinishEventData, type FailureEventData, FaucetConfig, FederatedKeylessAccount, FederatedKeylessPublicKey, FeePayerRawTransaction, FixedBytes, FullNodeConfig, type FunctionABI, GasEstimation, type GenerateAccountArgs, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, GetANSNameResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetObjectDataQueryResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, type GetRequestOptions, GetTableItemsDataResponse, GetTableItemsMetadataResponse, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, Groth16VerificationKey, Groth16Zkp, HARDENED_OFFSET, Hex, HexInput, Identifier, IndexerConfig, type InputBatchedFunctionData, 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 InputViewFunctionData, type InputViewFunctionDataWithABI, type InputViewFunctionDataWithRemoteABI, type InputViewFunctionJsonData, KeyType, KeylessAccount, KeylessConfiguration, KeylessError, KeylessErrorCategory, KeylessErrorResolutionTip, KeylessErrorType, KeylessPublicKey, KeylessSignature, type KeylessSigner, LedgerInfo, LedgerVersionArg, MAX_AUD_VAL_BYTES, MAX_COMMITED_EPK_BYTES, MAX_EXTRA_FIELD_BYTES, MAX_ISS_VAL_BYTES, MAX_JWT_HEADER_B64_BYTES, MAX_UID_KEY_BYTES, MAX_UID_VAL_BYTES, MimeType, ModuleId, MoveFunction, MoveFunctionGenericTypeParam, MoveFunctionId, MoveJWK, MoveModuleBytecode, MoveModuleId, MoveOption, MoveResource, MoveString, MoveStructId, MoveValue, MoveVector, MultiAgentRawTransaction, MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeyAccount, MultiKeySignature, MultiSig, MultiSigTransactionPayload, Network, OrderByArg, PaginationArgs, PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, PrivateKey, type PrivateKeyFromDerivationPathArgs, PrivateKeyVariants, ProcessorType, type ProofFetchCallback, type ProofFetchEvents, type ProofFetchFailure, type ProofFetchStatus, type ProofFetchSuccess, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RotationProofChallenge, Script, ScriptFunctionArgument, type ScriptFunctionArgumentTypes, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serialized, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, StructTag, type SuccessEventData, TableItemRequest, TokenStandardArg, TransactionAndProof, TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, TransactionPayloadScript, TransactionResponse, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, type TypeArgument, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVector, U128, U16, U256, U32, U64, U8, Uint16, Uint32, Uint8, UserTransactionResponse, type VerifyEd25519SignatureArgs, type VerifyMultiKeySignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewFunctionABI, type ViewFunctionJsonPayload, WaitForTransactionOptions, WhereArg, ZeroKnowledgeSig, ZkProof, ZkpVariant, aptosCoinStructTag, aptosRequest, base64UrlDecode, bigIntToBytesLE, buildTransaction, bytesToBigIntLE, checkOrConvertArgument, convertAmountFromHumanReadableToOnChain, convertAmountFromOnChainToHumanReadable, convertArgument, convertCallArgument, convertNumber, createObjectAddress, createResourceAddress, createTokenAddress, deriveKey, deriveTransactionType, deserializeFromScriptArgument, fetchEntryFunctionAbi, fetchFunctionAbi, fetchMoveFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, floorToWholeHour, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateSigningMessageForSerializable, generateSigningMessageForTransaction, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAptosPepperService, getAuthenticatorForSimulation, getErrorMessage, getFunctionParts, getIssAudAndUidVal, getKeylessConfig, getKeylessJWKs, hashStrToField, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBool, isCanonicalEd25519Signature, isEmptyOption, isEncodedEntryFunctionArgument, isEncodedStruct, isKeylessSigner, isLargeNumber, isNumber, isScriptDataInput, isString, isValidBIP44Path, isValidHardenedPath, mnemonicToSeed, normalizeBundle, nowInSeconds, objectStructTag, optionStructTag, padAndPackBytesWithLen, paginateWithCursor, parseEncodedStruct, parseJwtHeader, parseTypeTag, poseidonHash, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, postAptosPepperService, postAptosProvingService, promiseFulfilledStatus, request, sleep, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch };