@aptos-labs/ts-sdk 0.0.6 → 0.0.8

package/dist/common/index.d.ts

@@ -1,3 +1,34 @@
+/**
+ * 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>;
@@ -521,6 +552,17 @@ type GetFungibleAssetMetadataQuery = {
         token_standard: string;
     }>;
 };
+type GetNamesQuery = {
+    current_aptos_names: Array<{
+        domain?: string | null;
+        expiration_timestamp?: any | null;
+        registered_address?: string | null;
+        subdomain?: string | null;
+        token_standard?: string | null;
+        is_primary?: boolean | null;
+        owner_address?: string | null;
+    }>;
+};
 type GetNumberOfDelegatorsQuery = {
     num_active_delegator_per_pool: Array<{
         num_active_delegator?: any | null;
@@ -672,6 +714,7 @@ type GetCurrentFungibleAssetBalancesResponse = GetCurrentFungibleAssetBalancesQu
 type GetTokenActivityResponse = GetTokenActivityQuery["token_activities_v2"];
 type GetCurrentTokenOwnershipResponse = GetCurrentTokenOwnershipQuery["current_token_ownerships_v2"][0];
 type GetOwnedTokensResponse = GetCurrentTokenOwnershipQuery["current_token_ownerships_v2"];
+type GetANSNameResponse = GetNamesQuery["current_aptos_names"];
 /**
  * A generic type that being passed by each function and holds an
  * array of properties we can sort the query by
@@ -823,6 +866,15 @@ interface PaginationArgs {
     offset?: AnyNumber;
     limit?: number;
 }
+interface TokenStandardArg {
+    tokenStandard?: TokenStandard;
+}
+interface OrderByArg<T extends {}> {
+    orderBy?: OrderBy<T>;
+}
+interface WhereArg<T extends {}> {
+    where?: T;
+}
 /**
  * QUERY TYPES
  */
@@ -888,7 +940,7 @@ type AptosRequest = {
 /**
  * Specifies ledger version of transactions. By default latest version will be used
  */
-type LedgerVersion = {
+type LedgerVersionArg = {
     ledgerVersion?: AnyNumber;
 };
 /**
@@ -933,7 +985,13 @@ declare enum TransactionResponseType {
     BlockMetadata = "block_metadata_transaction",
     StateCheckpoint = "state_checkpoint_transaction"
 }
-type TransactionResponse = PendingTransactionResponse | UserTransactionResponse | GenesisTransactionResponse | BlockMetadataTransactionResponse | StateCheckpointTransactionResponse;
+type TransactionResponse = PendingTransactionResponse | CommittedTransactionResponse;
+type CommittedTransactionResponse = UserTransactionResponse | GenesisTransactionResponse | BlockMetadataTransactionResponse | StateCheckpointTransactionResponse;
+declare function isPendingTransactionResponse(response: TransactionResponse): response is PendingTransactionResponse;
+declare function isUserTransactionResponse(response: TransactionResponse): response is UserTransactionResponse;
+declare function isGenesisTransactionResponse(response: TransactionResponse): response is GenesisTransactionResponse;
+declare function isBlockMetadataTransactionResponse(response: TransactionResponse): response is BlockMetadataTransactionResponse;
+declare function isStateCheckpointTransactionResponse(response: TransactionResponse): response is StateCheckpointTransactionResponse;
 type PendingTransactionResponse = {
     type: TransactionResponseType.Pending;
     hash: string;
@@ -1190,6 +1248,11 @@ type MoveScriptBytecode = {
  * These are the JSON representations of transaction signatures returned from the node API.
  */
 type TransactionSignature = TransactionEd25519Signature | TransactionSecp256k1Signature | TransactionMultiEd25519Signature | TransactionMultiAgentSignature | TransactionFeePayerSignature;
+declare function isEd25519Signature(signature: TransactionSignature): signature is TransactionFeePayerSignature;
+declare function isSecp256k1Signature(signature: TransactionSignature): signature is TransactionFeePayerSignature;
+declare function isMultiAgentSignature(signature: TransactionSignature): signature is TransactionMultiAgentSignature;
+declare function isFeePayerSignature(signature: TransactionSignature): signature is TransactionFeePayerSignature;
+declare function isMultiEd25519Signature(signature: TransactionSignature): signature is TransactionMultiEd25519Signature;
 type TransactionEd25519Signature = {
     type: string;
     public_key: string;
@@ -1245,10 +1308,7 @@ type TransactionFeePayerSignature = {
 /**
  * The union of all single account signatures.
  */
-type AccountSignature = AccountEd25519Signature | AccountSecp256k1Signature | AccountMultiEd25519Signature;
-type AccountEd25519Signature = TransactionEd25519Signature;
-type AccountSecp256k1Signature = TransactionSecp256k1Signature;
-type AccountMultiEd25519Signature = TransactionMultiEd25519Signature;
+type AccountSignature = TransactionEd25519Signature | TransactionSecp256k1Signature | TransactionMultiEd25519Signature;
 type WriteSet = ScriptWriteSet | DirectWriteSet;
 type ScriptWriteSet = {
     type: string;
@@ -1552,7 +1612,7 @@ declare enum DeriveScheme {
 type WaitForTransactionOptions = {
     timeoutSecs?: number;
     checkSuccess?: boolean;
-    indexerVersionCheck?: boolean;
+    waitForIndexer?: boolean;
 };
 /**
  * Input type to generate an account using Single Signer
@@ -1572,121 +1632,6 @@ type GenerateAccountWithSingleSignerSecp256k1Key = {
 };
 type GenerateAccount = GenerateAccountWithEd25519 | GenerateAccountWithSingleSignerSecp256k1Key;
 
-/**
- * Type of API endpoint for request routing
- */
-declare enum AptosApiType {
-    FULLNODE = 0,
-    INDEXER = 1,
-    FAUCET = 2
-}
-declare const DEFAULT_NETWORK = Network.DEVNET;
-/**
- * The default max gas amount when none is given.
- *
- * This is the maximum number of gas units that will be used by a transaction before being rejected.
- *
- * Note that max gas amount varies based on the transaction.  A larger transaction will go over this
- * default gas amount, and the value will need to be changed for the specific transaction.
- */
-declare const DEFAULT_MAX_GAS_AMOUNT = 200000;
-/**
- * The default transaction expiration seconds from now.
- *
- * This time is how long until the blockchain nodes will reject the transaction.
- *
- * Note that the transaction expiration time varies based on network connection and network load.  It may need to be
- * increased for the transaction to be processed.
- */
-declare const DEFAULT_TXN_EXP_SEC_FROM_NOW = 20;
-/**
- * The default number of seconds to wait for a transaction to be processed.
- *
- * This time is the amount of time that the SDK will wait for a transaction to be processed when waiting for
- * the results of the transaction.  It may take longer based on network connection and network load.
- */
-declare const DEFAULT_TXN_TIMEOUT_SEC = 20;
-/**
- * The default gas currency for the network.
- */
-declare const APTOS_COIN = "0x1::aptos_coin::AptosCoin";
-declare const RAW_TRANSACTION_SALT = "APTOS::RawTransaction";
-declare const RAW_TRANSACTION_WITH_DATA_SALT = "APTOS::RawTransactionWithData";
-
-/**
- * This class holds the config information for the SDK client instance.
- */
-declare class AptosConfig {
-    /** The Network that this SDK is associated with. */
-    readonly network: Network;
-    /**
-     * The client instance the SDK uses
-     */
-    readonly client: Client;
-    /**
-     * The optional hardcoded fullnode URL to send requests to instead of using the network
-     */
-    readonly fullnode?: string;
-    /**
-     * The optional hardcoded faucet URL to send requests to instead of using the network
-     */
-    readonly faucet?: string;
-    /**
-     * The optional hardcoded indexer URL to send requests to instead of using the network
-     */
-    readonly indexer?: string;
-    readonly clientConfig?: ClientConfig;
-    constructor(settings?: AptosSettings);
-    /**
-     * Returns the URL endpoint to send the request to.
-     * If a custom URL was provided in the config, that URL is returned.
-     * If a custom URL was provided but not URL endpoints, an error is thrown.
-     * Otherwise, the URL endpoint is derived from the network.
-     *
-     * @param apiType - The type of Aptos API to get the URL for.
-     *
-     * @internal
-     */
-    getRequestUrl(apiType: AptosApiType): string;
-    /**
-     * Checks if the URL is a known indexer endpoint
-     *
-     * @internal
-     * */
-    isIndexerRequest(url: string): boolean;
-}
-
-/**
- * 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.
  */
@@ -1949,10 +1894,10 @@ declare class Serializer {
      * @param values The array of BCS Serializable values
      * @example
      * const addresses = new Array<AccountAddress>(
-     *   AccountAddress.fromRelaxed("0x1"),
-     *   AccountAddress.fromRelaxed("0x2"),
-     *   AccountAddress.fromRelaxed("0xa"),
-     *   AccountAddress.fromRelaxed("0xb"),
+     *   AccountAddress.from("0x1"),
+     *   AccountAddress.from("0x2"),
+     *   AccountAddress.from("0xa"),
+     *   AccountAddress.from("0xb"),
      * );
      * const serializer = new Serializer();
      * serializer.serializeVector(addresses);
@@ -2092,10 +2037,10 @@ declare class Deserializer {
      * @example
      * // serialize a vector of addresses
      * const addresses = new Array<AccountAddress>(
-     *   AccountAddress.fromRelaxed("0x1"),
-     *   AccountAddress.fromRelaxed("0x2"),
-     *   AccountAddress.fromRelaxed("0xa"),
-     *   AccountAddress.fromRelaxed("0xb"),
+     *   AccountAddress.from("0x1"),
+     *   AccountAddress.from("0x2"),
+     *   AccountAddress.from("0xa"),
+     *   AccountAddress.from("0xb"),
      * );
      * const serializer = new Serializer();
      * serializer.serializeVector(addresses);
@@ -2283,7 +2228,7 @@ declare class AccountAddress extends Serializable implements TransactionArgument
     static deserialize(deserializer: Deserializer): AccountAddress;
     /**
      * NOTE: This function has strict parsing behavior. For relaxed behavior, please use
-     * the `fromStringRelaxed` function.
+     * the `fromString` function.
      *
      * Creates an instance of AccountAddress from a hex string.
      *
@@ -2308,11 +2253,11 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      *
      * @returns An instance of AccountAddress.
      */
-    static fromString(input: string): AccountAddress;
+    static fromStringStrict(input: string): AccountAddress;
     /**
      * NOTE: This function has relaxed parsing behavior. For strict behavior, please use
-     * the `fromString` function. Where possible use `fromString` rather than this
-     * function, `fromStringRelaxed` is only provided for backwards compatibility.
+     * 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.
      *
@@ -2334,33 +2279,33 @@ declare class AccountAddress extends Serializable implements TransactionArgument
      *
      * @returns An instance of AccountAddress.
      */
-    static fromStringRelaxed(input: string): 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 fromRelaxed(input: AccountAddressInput): AccountAddress;
+    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 from(input: AccountAddressInput): AccountAddress;
+    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.relaxed If true, use relaxed parsing behavior. If false, use strict parsing behavior.
+     * @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;
-        relaxed?: boolean;
+        strict?: boolean;
     }): ParsingResult<AddressInvalidReason>;
     /**
      * Return whether AccountAddresses are equal. AccountAddresses are considered equal
@@ -3109,6 +3054,7 @@ declare class Ed25519PublicKey extends PublicKey {
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Ed25519PublicKey;
     static load(deserializer: Deserializer): Ed25519PublicKey;
+    static isPublicKey(publicKey: PublicKey): publicKey is Ed25519PublicKey;
 }
 /**
  * Represents the private key of an Ed25519 key pair.
@@ -3189,6 +3135,7 @@ declare class Ed25519PrivateKey extends PrivateKey {
      * @returns
      */
     private static fromDerivationPathInner;
+    static isPrivateKey(privateKey: PrivateKey): privateKey is Ed25519PrivateKey;
 }
 /**
  * A signature of a message signed using an Ed25519 private key
@@ -3219,6 +3166,7 @@ declare class Ed25519Signature extends Signature {
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Ed25519Signature;
     static load(deserializer: Deserializer): Ed25519Signature;
+    static isSignature(signature: Signature): signature is Ed25519Signature;
 }
 
 /**
@@ -3374,6 +3322,7 @@ declare class Secp256k1PublicKey extends PublicKey {
     serialize(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Secp256k1PublicKey;
     static load(deserializer: Deserializer): Secp256k1PublicKey;
+    static isPublicKey(publicKey: PublicKey): publicKey is Secp256k1PublicKey;
 }
 /**
  * A Secp256k1 ecdsa private key
@@ -3446,6 +3395,7 @@ declare class Secp256k1PrivateKey extends PrivateKey {
      * @returns The generated key
      */
     private static fromDerivationPathInner;
+    static isPrivateKey(privateKey: PrivateKey): privateKey is Secp256k1PrivateKey;
 }
 /**
  * A signature of a message signed using an Secp256k1 ecdsa private key
@@ -3481,6 +3431,7 @@ declare class Secp256k1Signature extends Signature {
     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 {
@@ -3541,6 +3492,9 @@ declare class AnyPublicKey extends PublicKey {
     }): 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 {
@@ -3645,6 +3599,107 @@ declare const splitPath: (path: string) => Array<string>;
  */
 declare const mnemonicToSeed: (mnemonic: string) => Uint8Array;
 
+/**
+ * Type of API endpoint for request routing
+ */
+declare enum AptosApiType {
+    FULLNODE = 0,
+    INDEXER = 1,
+    FAUCET = 2
+}
+declare const DEFAULT_NETWORK = Network.DEVNET;
+/**
+ * The default max gas amount when none is given.
+ *
+ * This is the maximum number of gas units that will be used by a transaction before being rejected.
+ *
+ * Note that max gas amount varies based on the transaction.  A larger transaction will go over this
+ * default gas amount, and the value will need to be changed for the specific transaction.
+ */
+declare const DEFAULT_MAX_GAS_AMOUNT = 200000;
+/**
+ * The default transaction expiration seconds from now.
+ *
+ * This time is how long until the blockchain nodes will reject the transaction.
+ *
+ * Note that the transaction expiration time varies based on network connection and network load.  It may need to be
+ * increased for the transaction to be processed.
+ */
+declare const DEFAULT_TXN_EXP_SEC_FROM_NOW = 20;
+/**
+ * The default number of seconds to wait for a transaction to be processed.
+ *
+ * This time is the amount of time that the SDK will wait for a transaction to be processed when waiting for
+ * the results of the transaction.  It may take longer based on network connection and network load.
+ */
+declare const DEFAULT_TXN_TIMEOUT_SEC = 20;
+/**
+ * The default gas currency for the network.
+ */
+declare const APTOS_COIN = "0x1::aptos_coin::AptosCoin";
+declare const RAW_TRANSACTION_SALT = "APTOS::RawTransaction";
+declare const RAW_TRANSACTION_WITH_DATA_SALT = "APTOS::RawTransactionWithData";
+/**
+ * The list of supported Processor types for our indexer api.
+ *
+ * These can be found from the processor_status table in the indexer database.
+ * {@link https://cloud.hasura.io/public/graphiql?endpoint=https://indexer.mainnet.aptoslabs.com/v1/graphql}
+ */
+declare enum ProcessorType {
+    ACCOUNT_TRANSACTION_PROCESSOR = "account_transactions_processor",
+    COIN_PROCESSOR = "coin_processor",
+    DEFAULT = "default_processor",
+    EVENTS_PROCESSOR = "events_processor",
+    FUNGIBLE_ASSET_PROCESSOR = "fungible_asset_processor",
+    STAKE_PROCESSOR = "stake_processor",
+    TOKEN_PROCESSOR = "token_processor",
+    TOKEN_V2_PROCESSOR = "token_v2_processor",
+    USER_TRANSACTION_PROCESSOR = "user_transaction_processor"
+}
+
+/**
+ * This class holds the config information for the SDK client instance.
+ */
+declare class AptosConfig {
+    /** The Network that this SDK is associated with. Defaults to DEVNET */
+    readonly network: Network;
+    /**
+     * The client instance the SDK uses. Defaults to `@aptos-labs/aptos-client
+     */
+    readonly client: Client;
+    /**
+     * The optional hardcoded fullnode URL to send requests to instead of using the network
+     */
+    readonly fullnode?: string;
+    /**
+     * The optional hardcoded faucet URL to send requests to instead of using the network
+     */
+    readonly faucet?: string;
+    /**
+     * The optional hardcoded indexer URL to send requests to instead of using the network
+     */
+    readonly indexer?: string;
+    readonly clientConfig?: ClientConfig;
+    constructor(settings?: AptosSettings);
+    /**
+     * Returns the URL endpoint to send the request to.
+     * If a custom URL was provided in the config, that URL is returned.
+     * If a custom URL was provided but not URL endpoints, an error is thrown.
+     * Otherwise, the URL endpoint is derived from the network.
+     *
+     * @param apiType - The type of Aptos API to get the URL for.
+     *
+     * @internal
+     */
+    getRequestUrl(apiType: AptosApiType): string;
+    /**
+     * Checks if the URL is a known indexer endpoint
+     *
+     * @internal
+     * */
+    isIndexerRequest(url: string): boolean;
+}
+
 /**
  * A class to query all `Account` related queries on Aptos.
  */
@@ -3684,7 +3739,7 @@ declare class Account {
      */
     getAccountModules(args: {
         accountAddress: AccountAddressInput;
-        options?: PaginationArgs & LedgerVersion;
+        options?: PaginationArgs & LedgerVersionArg;
     }): Promise<MoveModuleBytecode[]>;
     /**
      * Queries for a specific account module given account address and module name
@@ -3706,7 +3761,7 @@ declare class Account {
     getAccountModule(args: {
         accountAddress: AccountAddressInput;
         moduleName: string;
-        options?: LedgerVersion;
+        options?: LedgerVersionArg;
     }): Promise<MoveModuleBytecode>;
     /**
      * Queries account transactions given an account address
@@ -3738,7 +3793,7 @@ declare class Account {
      */
     getAccountResources(args: {
         accountAddress: AccountAddressInput;
-        options?: PaginationArgs & LedgerVersion;
+        options?: PaginationArgs & LedgerVersionArg;
     }): Promise<MoveResource[]>;
     /**
      * Queries a specific account resource given account address and resource type. Note that the default is `any` in order
@@ -3754,14 +3809,14 @@ declare class Account {
      * @example An example of an account resource
      * ```
      * {
-     *    data: { value: 6 }
+     *    value: 6
      * }
      * ```
      */
     getAccountResource<T extends {} = any>(args: {
         accountAddress: AccountAddressInput;
         resourceType: MoveStructId;
-        options?: LedgerVersion;
+        options?: LedgerVersionArg;
     }): Promise<T>;
     /**
      * Looks up the account address for a given authentication key
@@ -3769,21 +3824,25 @@ declare class Account {
      * This handles both if the account's authentication key has been rotated or not.
      *
      * @param args.authenticationKey The authentication key
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
      * @returns Promise<AccountAddress> The accountAddress associated with the authentication key
      */
     lookupOriginalAccountAddress(args: {
         authenticationKey: AccountAddressInput;
-        options?: LedgerVersion;
+        minimumLedgerVersion?: AnyNumber;
+        options?: LedgerVersionArg;
     }): Promise<AccountAddress>;
     /**
      * Queries the current count of tokens owned by an account
      *
      * @param args.accountAddress The account address
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns Current count of tokens owned by the account
      */
     getAccountTokensCount(args: {
         accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
     }): Promise<number>;
     /**
      * Queries the account's current owned tokens.
@@ -3792,19 +3851,17 @@ declare class Account {
      * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
      *
      * @param args.accountAddress The account address we want to get the tokens for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @param args.options.tokenStandard The NFT standard to query for
-     * @param args.options.pagination.offset The number token to start returning results from
-     * @param args.options.pagination.limit The number of results to return
+     * @param args.options.offset The number token to start returning results from
+     * @param args.options.limit The number of results to return
      * @param args.options.orderBy The order to sort the tokens by
      * @returns Tokens array with the token data
      */
     getAccountOwnedTokens(args: {
         accountAddress: AccountAddressInput;
-        options?: {
-            tokenStandard?: TokenStandard;
-            pagination?: PaginationArgs;
-            orderBy?: OrderBy<GetAccountOwnedTokensQueryResponse[0]>;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;
     }): Promise<GetAccountOwnedTokensQueryResponse>;
     /**
      * Queries all current tokens of a specific collection that an account owns by the collection address
@@ -3814,20 +3871,18 @@ declare class Account {
      *
      * @param args.accountAddress The account address we want to get the tokens for
      * @param args.collectionAddress The address of the collection being queried
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @param args.options.tokenStandard The NFT standard to query for
-     * @param args.options.pagination.offset The number token to start returning results from
-     * @param args.options.pagination.limit The number of results to return
+     * @param args.options.offset The number token to start returning results from
+     * @param args.options.limit The number of results to return
      * @param args.options.orderBy The order to sort the tokens by
      * @returns Tokens array with the token data
      */
     getAccountOwnedTokensFromCollectionAddress(args: {
         accountAddress: AccountAddressInput;
         collectionAddress: AccountAddressInput;
-        options?: {
-            tokenStandard?: TokenStandard;
-            pagination?: PaginationArgs;
-            orderBy?: OrderBy<GetAccountOwnedTokensFromCollectionResponse[0]>;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;
     }): Promise<GetAccountOwnedTokensFromCollectionResponse>;
     /**
      * Queries for all collections that an account currently has tokens for.
@@ -3836,69 +3891,94 @@ declare class Account {
      * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
      *
      * @param args.accountAddress The account address we want to get the collections for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @param args.options.tokenStandard The NFT standard to query for
-     * @param args.options.pagination.offset The number collection to start returning results from
-     * @param args.options.pagination.limit The number of results to return
+     * @param args.options.offset The number collection to start returning results from
+     * @param args.options.limit The number of results to return
      * @param args.options.orderBy The order to sort the tokens by
      * @returns Collections array with the collections data
      */
     getAccountCollectionsWithOwnedTokens(args: {
         accountAddress: AccountAddressInput;
-        options?: {
-            tokenStandard?: TokenStandard;
-            pagination?: PaginationArgs;
-            orderBy?: OrderBy<GetAccountCollectionsWithOwnedTokenResponse[0]>;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;
     }): Promise<GetAccountCollectionsWithOwnedTokenResponse>;
     /**
      * Queries the current count of transactions submitted by an account
      *
      * @param args.accountAddress The account address we want to get the total count for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns Current count of transactions made by an account
      */
     getAccountTransactionsCount(args: {
         accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
     }): Promise<number>;
     /**
      * Queries an account's coins data
      *
      * @param args.accountAddress The account address we want to get the coins data for
-     * @param args.options.pagination.offset The number coin to start returning results from
-     * @param args.options.pagination.limit The number of results to return
-     * @param args.options.orderBy The order to sort the coins by
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.options.offset optional. The number coin to start returning results from
+     * @param args.options.limit optional. The number of results to return
+     * @param args.options.orderBy optional. The order to sort the coins by
+     * @param args.options.where optional. Filter the results by
      * @returns Array with the coins data
      */
     getAccountCoinsData(args: {
         accountAddress: AccountAddressInput;
-        options?: {
-            pagination?: PaginationArgs;
-            orderBy?: OrderBy<GetAccountCoinsDataResponse[0]>;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetAccountCoinsDataResponse[0]> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
     }): Promise<GetAccountCoinsDataResponse>;
     /**
      * Queries the current count of an account's coins aggregated
      *
      * @param args.accountAddress The account address we want to get the total count for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns Current count of the aggregated count of all account's coins
      */
     getAccountCoinsCount(args: {
         accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
     }): Promise<number>;
     /**
-     * Queries an account's owned objects
+     * Queries the account's APT amount
      *
-     * @param args.accountAddress The account address we want to get the objects for
-     * @param args.options.pagination.offset The number coin to start returning results from
-     * @param args.options.pagination.limit The number of results to return
-     * @param args.options.orderBy The order to sort the coins by
-     * @returns Objects array with the object data
+     * @param args.accountAddress The account address we want to get the total count for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @returns Current amount of account's APT
      */
-    getAccountOwnedObjects(args: {
+    getAccountAPTAmount(args: {
         accountAddress: AccountAddressInput;
-        options?: {
-            pagination?: PaginationArgs;
-            orderBy?: OrderBy<GetAccountOwnedObjectsResponse[0]>;
-        };
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
+    /**
+     * Queries the account's coin amount by the coin type
+     *
+     * @param args.accountAddress The account address we want to get the total count for
+     * @param args.coinType The coin type to query
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @returns Current amount of account's coin
+     */
+    getAccountCoinAmount(args: {
+        accountAddress: AccountAddressInput;
+        coinType: MoveStructId;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
+    /**
+     * Queries an account's owned objects
+     *
+     * @param args.accountAddress The account address we want to get the objects for
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.options.offset The starting position to start returning results from
+     * @param args.options.limit The number of results to return
+     * @param args.options.orderBy The order to sort the objects by
+     * @returns Objects array with the object data
+     */
+    getAccountOwnedObjects(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetAccountOwnedObjectsResponse[0]>;
     }): Promise<GetAccountOwnedObjectsResponse>;
     /**
      * Derives an account by providing a private key.
@@ -4376,6 +4456,10 @@ declare class RotationProofChallenge extends Serializable {
 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
@@ -4542,7 +4626,7 @@ declare class SignedTransaction extends Serializable {
 /**
  * Entry function arguments to be used when building a raw transaction using remote ABI
  */
-type SimpleEntryFunctionArgumentTypes = boolean | number | bigint | string | null | undefined | Uint8Array | Array<SimpleEntryFunctionArgumentTypes>;
+type SimpleEntryFunctionArgumentTypes = boolean | number | bigint | string | null | undefined | Uint8Array | Array<SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes>;
 /**
  * Entry function arguments to be used when building a raw transaction using BCS serialized arguments
  */
@@ -4589,7 +4673,7 @@ type InputEntryFunctionDataWithRemoteABI = InputEntryFunctionData & {
  * The data needed to generate a Multi Sig payload
  */
 type InputMultiSigData = {
-    multisigAddress: AccountAddress;
+    multisigAddress: AccountAddressInput;
 } & InputEntryFunctionData;
 /**
  * The data needed to generate a Multi Sig payload
@@ -4623,18 +4707,7 @@ interface InputGenerateSingleSignerRawTransactionArgs {
     sender: AccountAddressInput;
     payload: AnyTransactionPayloadInstance;
     options?: InputGenerateTransactionOptions;
-}
-/**
- * Interface of the arguments to generate a fee payer transaction.
- * Used to provide to `generateTransaction()` method in the transaction builder flow
- */
-interface InputGenerateFeePayerRawTransactionArgs {
-    aptosConfig: AptosConfig;
-    sender: AccountAddressInput;
-    payload: AnyTransactionPayloadInstance;
-    feePayerAddress: AccountAddressInput;
-    secondarySignerAddresses?: AccountAddressInput[];
-    options?: InputGenerateTransactionOptions;
+    feePayerAddress?: AccountAddressInput;
 }
 /**
  * Interface of the arguments to generate a multi-agent transaction.
@@ -4646,30 +4719,21 @@ interface InputGenerateMultiAgentRawTransactionArgs {
     payload: AnyTransactionPayloadInstance;
     secondarySignerAddresses: AccountAddressInput[];
     options?: InputGenerateTransactionOptions;
+    feePayerAddress?: AccountAddressInput;
 }
 /**
  * Unified type that holds all the interfaces to generate different transaction types
  */
-type InputGenerateRawTransactionArgs = InputGenerateSingleSignerRawTransactionArgs | InputGenerateFeePayerRawTransactionArgs | InputGenerateMultiAgentRawTransactionArgs;
+type InputGenerateRawTransactionArgs = InputGenerateSingleSignerRawTransactionArgs | InputGenerateMultiAgentRawTransactionArgs;
 /**
  * Interface that holds the return data when generating a single signer transaction
  *
  * @param rawTransaction a bcs serialized raw transaction
  */
-interface InputSingleSignerTransaction {
-    rawTransaction: RawTransaction;
-}
-/**
- * Interface that holds the return data when generating a fee payer transaction
- *
- * @param rawTransaction a bcs serialized raw transaction
- * @param secondarySignerAddresses optional. secondary signer addresses for multi-agent transaction
- * @param feePayerAddress fee payer address for a fee payer transaction (aka Sponsored Transaction)
- */
-interface InputFeePayerTransaction {
+interface SingleSignerTransaction {
     rawTransaction: RawTransaction;
-    feePayerAddress: AccountAddress;
-    secondarySignerAddresses?: AccountAddress[];
+    feePayerAddress?: AccountAddress;
+    secondarySignerAddresses?: undefined;
 }
 /**
  * Interface that holds the return data when generating a multi-agent transaction.
@@ -4677,14 +4741,15 @@ interface InputFeePayerTransaction {
  * @param rawTransaction a bcs serialized raw transaction
  * @param secondarySignerAddresses secondary signer addresses for multi-agent transaction
  */
-interface InputMultiAgentTransaction {
+interface MultiAgentTransaction {
     rawTransaction: RawTransaction;
     secondarySignerAddresses: AccountAddress[];
+    feePayerAddress?: AccountAddress;
 }
 /**
  * Unified type that holds all the return interfaces when generating different transaction types
  */
-type AnyRawTransaction = InputSingleSignerTransaction | InputFeePayerTransaction | InputMultiAgentTransaction;
+type AnyRawTransaction = SingleSignerTransaction | MultiAgentTransaction;
 type InputSimulateTransactionData = {
     /**
      * The transaction to simulate, probably generated by `generateTransaction()`
@@ -4714,32 +4779,25 @@ type InputSimulateTransactionOptions = {
  */
 interface InputGenerateSingleSignerRawTransactionData {
     sender: AccountAddressInput;
-    options?: InputGenerateTransactionOptions;
     data: InputGenerateTransactionPayloadData;
-}
-/**
- * Interface that holds the user data input when generating a fee payer transaction
- */
-interface InputGenerateFeePayerRawTransactionData {
-    sender: AccountAddressInput;
-    hasFeePayer: true;
-    secondarySignerAddresses?: AccountAddressInput[];
     options?: InputGenerateTransactionOptions;
-    data: InputGenerateTransactionPayloadData;
+    withFeePayer?: boolean;
+    secondarySignerAddresses?: undefined;
 }
 /**
  * Interface that holds the user data input when generating a multi-agent transaction
  */
 interface InputGenerateMultiAgentRawTransactionData {
     sender: AccountAddressInput;
+    data: InputGenerateTransactionPayloadData;
     secondarySignerAddresses: AccountAddressInput[];
     options?: InputGenerateTransactionOptions;
-    data: InputGenerateTransactionPayloadData;
+    withFeePayer?: boolean;
 }
 /**
  * Unified type that holds all the user data input interfaces when generating different transaction types
  */
-type InputGenerateTransactionData = InputGenerateMultiAgentRawTransactionData | InputGenerateFeePayerRawTransactionData | InputGenerateSingleSignerRawTransactionData;
+type InputGenerateTransactionData = InputGenerateSingleSignerRawTransactionData | InputGenerateMultiAgentRawTransactionData;
 /**
  * Interface that holds the user data input when submitting a transaction
  */
@@ -4772,7 +4830,7 @@ declare class Coin {
         amount: AnyNumber;
         coinType?: MoveStructId;
         options?: InputGenerateTransactionOptions;
-    }): Promise<InputSingleSignerTransaction>;
+    }): Promise<SingleSignerTransaction>;
 }
 
 /**
@@ -4834,7 +4892,7 @@ declare class DigitalAsset {
         name: string;
         uri: string;
         options?: InputGenerateTransactionOptions;
-    } & CreateCollectionOptions): Promise<InputSingleSignerTransaction>;
+    } & CreateCollectionOptions): Promise<SingleSignerTransaction>;
     /**
      * Queries data of a specific collection by the collection creator address and the collection name.
      *
@@ -4843,15 +4901,15 @@ declare class DigitalAsset {
      *
      * @param args.creatorAddress the address of the collection's creator
      * @param args.collectionName the name of the collection
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @param args.options.tokenStandard the token standard to query
      * @returns GetCollectionDataResponse response type
      */
     getCollectionData(args: {
         creatorAddress: AccountAddressInput;
         collectionName: string;
-        options?: {
-            tokenStandard?: TokenStandard;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg;
     }): Promise<GetCollectionDataResponse>;
     /**
      * Queries a collection's ID.
@@ -4861,15 +4919,15 @@ declare class DigitalAsset {
      *
      * @param args.creatorAddress the address of the collection's creator
      * @param args.collectionName the name of the collection
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @param args.options.tokenStandard the token standard to query
      * @returns the collection id
      */
     getCollectionId(args: {
         creatorAddress: AccountAddressInput;
         collectionName: string;
-        options?: {
-            tokenStandard?: TokenStandard;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg;
     }): Promise<string>;
     /**
      * Create a transaction to mint a token into the creators account within an existing collection.
@@ -4889,50 +4947,52 @@ declare class DigitalAsset {
         name: string;
         uri: string;
         options?: InputGenerateTransactionOptions;
-    }): Promise<InputSingleSignerTransaction>;
+    }): Promise<SingleSignerTransaction>;
     /**
      * Gets token data given the address of a token.
      *
      * @param args.tokenAddress The address of the token
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns GetTokenDataResponse containing relevant data to the token.
      */
     getTokenData(args: {
         tokenAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
     }): Promise<GetTokenDataResponse>;
     /**
      * Gets token ownership data given the address of a token.
      *
      * @param args.tokenAddress The address of the token
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns GetCurrentTokenOwnershipResponse containing relevant ownership data of the token.
      */
     getCurrentTokenOwnership(args: {
         tokenAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
     }): Promise<GetCurrentTokenOwnershipResponse>;
     /**
      * Gets the tokens that the given address owns.
      *
      * @param args.ownerAddress The address of the owner
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns GetOwnedTokensResponse containing ownership data of the tokens belonging to the ownerAddresss.
      */
     getOwnedTokens(args: {
         ownerAddress: AccountAddressInput;
-        options?: {
-            pagination?: PaginationArgs;
-            orderBy?: OrderBy<GetOwnedTokensResponse[0]>;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetOwnedTokensResponse[0]>;
     }): Promise<GetOwnedTokensResponse>;
     /**
      * Gets the activity data given the address of a token.
      *
      * @param args.tokenAddress The address of the token
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns GetTokenActivityResponse containing relevant activity data to the token.
      */
     getTokenActivity(args: {
         tokenAddress: AccountAddressInput;
-        options?: {
-            pagination?: PaginationArgs;
-            orderBy?: OrderBy<GetTokenActivityResponse[0]>;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetTokenActivityResponse[0]>;
     }): Promise<GetTokenActivityResponse>;
 }
 
@@ -4947,34 +5007,35 @@ declare class Event {
      *
      * @param args.accountAddress - The account address
      * @param args.creationNumber - The event creation number
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      *
      * @returns Promise<GetEventsResponse>
      */
     getAccountEventsByCreationNumber(args: {
         accountAddress: AccountAddressInput;
         creationNumber: AnyNumber;
+        minimumLedgerVersion?: AnyNumber;
     }): Promise<GetEventsResponse>;
     /**
      * Get events by event type and an account address
      *
      * @param args.accountAddress - The account address
      * @param args.eventType - The event type
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      *
      * @returns Promise<GetEventsResponse>
      */
     getAccountEventsByEventType(args: {
         accountAddress: AccountAddressInput;
         eventType: MoveStructId;
-        options?: {
-            pagination?: PaginationArgs;
-            orderBy?: OrderBy<GetEventsResponse[0]>;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetEventsResponse[0]>;
     }): Promise<GetEventsResponse>;
     /**
      * Get all events
      *
      * An optional `where` can be passed in to filter out the response.
-     *
+     *@param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @example
      * ```
      * { where:
@@ -4987,11 +5048,8 @@ declare class Event {
      * @returns GetEventsQuery response type
      */
     getEvents(args?: {
-        options?: {
-            where?: EventsBoolExp;
-            pagination?: PaginationArgs;
-            orderBy?: OrderBy<GetEventsResponse[0]>;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetEventsResponse[0]> & WhereArg<EventsBoolExp>;
     }): Promise<GetEventsResponse>;
 }
 
@@ -5014,8 +5072,185 @@ declare class Faucet {
         accountAddress: AccountAddressInput;
         amount: number;
         options?: WaitForTransactionOptions;
-    }): Promise<string>;
+    }): Promise<UserTransactionResponse>;
+}
+
+declare function isBool(arg: SimpleEntryFunctionArgumentTypes): arg is boolean;
+declare function isString(arg: any): arg is string;
+declare function isNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number;
+declare function isLargeNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number | bigint | string;
+declare function isNull(arg: SimpleEntryFunctionArgumentTypes): arg is null | undefined;
+declare function isEncodedEntryFunctionArgument(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is EntryFunctionArgumentTypes;
+declare function isBcsBool(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is Bool;
+declare function isBcsAddress(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is AccountAddress;
+declare function isBcsString(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is MoveString;
+declare function isBcsFixedBytes(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is FixedBytes;
+declare function isBcsU8(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U8;
+declare function isBcsU16(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U16;
+declare function isBcsU32(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U32;
+declare function isBcsU64(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U64;
+declare function isBcsU128(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U128;
+declare function isBcsU256(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U256;
+declare function isScriptDataInput(arg: InputGenerateTransactionPayloadDataWithRemoteABI | InputGenerateTransactionPayloadData): arg is InputScriptData;
+declare function throwTypeMismatch(expectedType: string, position: number): void;
+/**
+ * Finds first non-signer arg.
+ *
+ * A function is often defined with a `signer` or `&signer` arguments at the start, which are filled in
+ * by signatures, and not by the caller.
+ * @param functionAbi
+ */
+declare function findFirstNonSignerArg(functionAbi: MoveFunction): number;
+declare function getFunctionParts(functionArg: MoveFunctionId): {
+    moduleAddress: string;
+    moduleName: string;
+    functionName: string;
+};
+
+/**
+ * We are defining function signatures, each with its specific input and output.
+ * These are the possible function signature for our `generateTransactionPayload` function.
+ * When we call our `generateTransactionPayload` function with the relevant type properties,
+ * Typescript can infer the return type based on the appropriate function overload.
+ */
+declare function generateTransactionPayload(args: InputScriptData): Promise<TransactionPayloadScript>;
+declare function generateTransactionPayload(args: InputEntryFunctionDataWithRemoteABI): Promise<TransactionPayloadEntryFunction>;
+declare function generateTransactionPayload(args: InputMultiSigDataWithRemoteABI): Promise<TransactionPayloadMultisig>;
+declare function generateTransactionPayloadWithABI(args: InputEntryFunctionData, functionAbi: EntryFunctionABI): TransactionPayloadEntryFunction;
+declare function generateTransactionPayloadWithABI(args: InputMultiSigData, functionAbi: EntryFunctionABI): TransactionPayloadMultisig;
+/**
+ * Generates a raw transaction
+ *
+ * @param args.aptosConfig AptosConfig
+ * @param args.sender The transaction's sender account address as a hex input
+ * @param args.payload The transaction payload - can create by using generateTransactionPayload()
+ *
+ * @returns RawTransaction
+ */
+declare function generateRawTransaction(args: {
+    aptosConfig: AptosConfig;
+    sender: AccountAddressInput;
+    payload: AnyTransactionPayloadInstance;
+    options?: InputGenerateTransactionOptions;
+}): Promise<RawTransaction>;
+/**
+ * We are defining function signatures, each with its specific input and output.
+ * These are the possible function signature for our `generateTransaction` function.
+ * When we call our `generateTransaction` function with the relevant type properties,
+ * Typescript can infer the return type based on the appropriate function overload.
+ */
+declare function buildTransaction(args: InputGenerateSingleSignerRawTransactionArgs): Promise<SingleSignerTransaction>;
+declare function buildTransaction(args: InputGenerateMultiAgentRawTransactionArgs): Promise<MultiAgentTransaction>;
+/**
+ * Simulate a transaction before signing and submit to chain
+ *
+ * @param args.transaction A aptos transaction type to sign
+ * @param args.signerPublicKey The signer public key
+ * @param args.secondarySignersPublicKeys optional. The secondary signers public keys if multi signers transaction
+ * @param args.feePayerPublicKey optional. The fee payer public key is a fee payer (aka sponsored) transaction
+ * @param args.options optional. SimulateTransactionOptions
+ *
+ * @returns A signed serialized transaction that can be simulated
+ */
+declare function generateSignedTransactionForSimulation(args: InputSimulateTransactionData): Uint8Array;
+declare function getAuthenticatorForSimulation(publicKey: PublicKey): AccountAuthenticatorEd25519 | AccountAuthenticatorSingleKey;
+/**
+ * Sign a transaction that can later be submitted to chain
+ *
+ * @param args.signer The signer account to sign the transaction
+ * @param args.transaction A aptos transaction type to sign
+ *
+ * @return The signer AccountAuthenticator
+ */
+declare function sign(args: {
+    signer: Account$1;
+    transaction: AnyRawTransaction;
+}): AccountAuthenticator;
+/**
+ * Prepare a transaction to be submitted to chain
+ *
+ * @param args.transaction A aptos transaction type
+ * @param args.senderAuthenticator The account authenticator of the transaction sender
+ * @param args.secondarySignerAuthenticators optional. For when the transaction is a multi signers transaction
+ *
+ * @returns A SignedTransaction
+ */
+declare function generateSignedTransaction(args: InputSubmitTransactionData): Uint8Array;
+/**
+ * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction
+ *
+ * @param transaction A aptos transaction type
+ *
+ * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
+ */
+declare function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance;
+/**
+ * Generate a multi signers signed transaction that can be submitted to chain
+ *
+ * @param transaction MultiAgentRawTransaction | FeePayerRawTransaction
+ * @param senderAuthenticator The account authenticator of the transaction sender
+ * @param secondarySignerAuthenticators The extra signers account Authenticators
+ *
+ * @returns A SignedTransaction
+ */
+declare function generateMultiSignersSignedTransaction(transaction: MultiAgentRawTransaction | FeePayerRawTransaction, senderAuthenticator: AccountAuthenticator, feePayerAuthenticator?: AccountAuthenticator, additionalSignersAuthenticators?: Array<AccountAuthenticator>): Uint8Array;
+declare function generateSigningMessage(transaction: AnyRawTransaction): Uint8Array;
+
+/**
+ * Convert type arguments to only type tags, allowing for string representations of type tags
+ */
+declare function standardizeTypeTags(typeArguments?: Array<TypeTag | string>): Array<TypeTag>;
+/**
+ * Fetches the ABI for an entry function from the module
+ *
+ * @param moduleAddress
+ * @param moduleName
+ * @param functionName
+ * @param aptosConfig
+ */
+declare function fetchEntryFunctionAbi(moduleAddress: string, moduleName: string, functionName: string, aptosConfig: AptosConfig): Promise<EntryFunctionABI>;
+/**
+ * Converts a non-BCS encoded argument into BCS encoded, if necessary
+ * @param functionName
+ * @param functionAbi
+ * @param arg
+ * @param position
+ */
+declare function convertArgument(functionName: string, functionAbi: EntryFunctionABI, arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes, position: number, genericTypeParams: Array<TypeTag>): EntryFunctionArgumentTypes;
+declare function checkOrConvertArgument(arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes, param: TypeTag, position: number, genericTypeParams: Array<TypeTag>): EntryFunctionArgumentTypes;
+
+declare enum TypeTagParserErrorType {
+    InvalidTypeTag = "unknown type",
+    UnexpectedGenericType = "unexpected generic type",
+    UnexpectedTypeArgumentClose = "unexpected '>'",
+    UnexpectedWhitespaceCharacter = "unexpected whitespace character",
+    UnexpectedComma = "unexpected ','",
+    TypeArgumentCountMismatch = "type argument count doesn't match expected amount",
+    MissingTypeArgumentClose = "no matching '>' for '<'",
+    UnexpectedPrimitiveTypeArguments = "primitive types not expected to have type arguments",
+    UnexpectedVectorTypeArgumentCount = "vector type expected to have exactly one type argument",
+    UnexpectedStructFormat = "unexpected struct format, must be of the form 0xaddress::module_name::struct_name",
+    InvalidModuleNameCharacter = "module name must only contain alphanumeric or '_' characters",
+    InvalidStructNameCharacter = "struct name must only contain alphanumeric or '_' characters"
 }
+declare class TypeTagParserError extends Error {
+    constructor(typeTagStr: string, invalidReason: TypeTagParserErrorType);
+}
+/**
+ * All types are made of a few parts they're either:
+ * 1. A simple type e.g. u8
+ * 2. A standalone struct e.g. 0x1::account::Account
+ * 3. A nested struct e.g. 0x1::coin::Coin<0x1234::coin::MyCoin>
+ *
+ * There are a few more special cases that need to be handled, however.
+ * 1. Multiple generics e.g 0x1::pair::Pair<u8, u16>
+ * 2. Spacing in the generics e.g. 0x1::pair::Pair< u8 , u16>
+ * 3. Nested generics of different depths e.g. 0x1::pair::Pair<0x1::coin::Coin<0x1234::coin::MyCoin>, u8>
+ * 4. Generics for types in ABIs are filled in with placeholders e.g T1, T2, T3
+ */
+declare function parseTypeTag(typeStr: string, options?: {
+    allowGenerics?: boolean;
+}): TypeTag;
 
 /**
  * A class to query all `FungibleAsset` related queries on Aptos.
@@ -5024,60 +5259,75 @@ declare class FungibleAsset {
     readonly config: AptosConfig;
     constructor(config: AptosConfig);
     /**
-     * Queries the current fungible asset metadata.
+     * Queries all fungible asset metadata.
      *
-     * This query returns the fungible asset metadata for all fungible assets.
-     * It can be filtered by creator address and asset type.
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      *
-     * @returns getFungibleAssetMetadata A list of fungible asset metadata
+     * @returns A list of fungible asset metadata
      */
     getFungibleAssetMetadata(args?: {
-        options?: {
-            pagination?: PaginationArgs;
-            where?: FungibleAssetMetadataBoolExp;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & WhereArg<FungibleAssetMetadataBoolExp>;
     }): Promise<GetFungibleAssetMetadataResponse>;
     /**
-     * Queries the current specific fungible asset metadata
+     * Queries a fungible asset metadata
      *
      * This query returns the fungible asset metadata for a specific fungible asset.
      *
-     * @param assetType The asset type of the fungible asset.
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+     * @param args.assetType The asset type of the fungible asset.
      * e.g
      * "0x1::aptos_coin::AptosCoin" for Aptos Coin
      * "0xc2948283c2ce03aafbb294821de7ee684b06116bb378ab614fa2de07a99355a8" - address format if this is fungible asset
      *
-     * @returns getFungibleAssetMetadata A fungible asset metadata item
+     * @returns A fungible asset metadata item
      */
-    getFungibleAssetMetadataByAssetType(assetType: string): Promise<GetFungibleAssetMetadataResponse[0]>;
+    getFungibleAssetMetadataByAssetType(args: {
+        assetType: string;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<GetFungibleAssetMetadataResponse[0]>;
     /**
-     * Queries the fungible asset activities
+     * Queries all fungible asset activities
      *
-     * This query returns the fungible asset activities.
-     * It can be filtered by owner address, asset type, and type.
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      *
-     * @returns GetFungibleAssetActivitiesResponse A list of fungible asset metadata
+     * @returns A list of fungible asset metadata
      */
     getFungibleAssetActivities(args?: {
-        options?: {
-            pagination?: PaginationArgs;
-            where?: FungibleAssetActivitiesBoolExp;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & WhereArg<FungibleAssetActivitiesBoolExp>;
     }): Promise<GetFungibleAssetActivitiesResponse>;
     /**
-     * Queries the fungible asset balance
+     * Queries all fungible asset balances
      *
-     * This query returns the fungible asset balance.
-     * It can be filtered by owner address, and asset type
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      *
-     * @returns GetCurrentFungibleAssetBalancesResponse A list of fungible asset metadata
+     * @returns A list of fungible asset metadata
      */
     getCurrentFungibleAssetBalances(args?: {
-        options?: {
-            pagination?: PaginationArgs;
-            where?: CurrentFungibleAssetBalancesBoolExp;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
     }): Promise<GetCurrentFungibleAssetBalancesResponse>;
+    /**
+     *  Transfer `amount` of fungible asset from sender's primary store to recipient's primary store.
+     *
+     * Use this method to transfer any fungible asset including fungible token.
+     *
+     * @param sender The sender account
+     * @param fungibleAssetMetadataAddress The fungible asset account address.
+     * For example if you’re transferring USDT this would be the USDT address
+     * @param recipient The recipient account address
+     * @param amount Number of assets to transfer
+     *
+     * @returns A SingleSignerTransaction that can be simulated or submitted to chain.
+     */
+    transferFungibleAsset(args: {
+        sender: Account$1;
+        fungibleAssetMetadataAddress: AccountAddress;
+        recipient: AccountAddress;
+        amount: AnyNumber;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SingleSignerTransaction>;
 }
 
 /**
@@ -5160,7 +5410,7 @@ declare class General {
     getTableItem<T>(args: {
         handle: string;
         data: TableItemRequest;
-        options?: LedgerVersion;
+        options?: LedgerVersionArg;
     }): Promise<T>;
     /**
      * Queries for a Move view function
@@ -5179,7 +5429,7 @@ declare class General {
      */
     view<T extends Array<MoveValue>>(args: {
         payload: InputViewRequestData;
-        options?: LedgerVersion;
+        options?: LedgerVersionArg;
     }): Promise<T>;
     /**
      * Queries top user transactions
@@ -5219,6 +5469,13 @@ declare class General {
      * This is useful to tell what ledger version the indexer is updated to, as it can be behind the full nodes.
      */
     getIndexerLastSuccessVersion(): Promise<number>;
+    /**
+     * Query the processor status for a specific processor type.
+     *
+     * @param processorType The processor type to query
+     * @returns
+     */
+    getProcessorStatus(processorType: ProcessorType): Promise<GetProcessorStatusResponse[0]>;
 }
 
 /**
@@ -5234,18 +5491,33 @@ interface RegisterNameParameters {
     name: string;
     expiration: {
         policy: "domain";
-        years: 1;
+        years?: 1;
     } | {
         policy: "subdomain:follow-domain";
     } | {
         policy: "subdomain:independent";
-        expirationDate: Date;
+        expirationDate: number;
     };
     transferable?: boolean;
-    toAddress?: HexInput;
-    targetAddress?: HexInput;
+    toAddress?: AccountAddressInput;
+    targetAddress?: AccountAddressInput;
     options?: InputGenerateTransactionOptions;
 }
+interface QueryNamesOptions {
+    options?: PaginationArgs & OrderByArg<GetANSNameResponse[0]> & WhereArg<CurrentAptosNamesBoolExp>;
+}
+interface GetAccountNamesArgs extends QueryNamesOptions {
+    accountAddress: AccountAddressInput;
+}
+interface GetAccountDomainsArgs extends QueryNamesOptions {
+    accountAddress: AccountAddressInput;
+}
+interface GetAccountSubdomainsArgs extends QueryNamesOptions {
+    accountAddress: AccountAddressInput;
+}
+interface GetDomainSubdomainsArgs extends QueryNamesOptions {
+    domain: string;
+}
 
 /**
  * A class to handle all `ANS` operations
@@ -5254,11 +5526,12 @@ declare class ANS {
     readonly config: AptosConfig;
     constructor(config: AptosConfig);
     /**
-     * Retrieve the owner address of a domain name or subdomain name.
+     * Retrieve the owner address of a domain name or subdomain name from the contract.
      *
      * ```ts
-     * getOwnerAddress({name: "test.aptos"})
      * // Will return the owner address of "test.aptos.apt" or undefined
+     * const owner = await aptos.getOwnerAddress({name: "test.aptos"})
+     * // owner = 0x123...
      * ```
      *
      * @param args.name - A string of the name to retrieve
@@ -5269,26 +5542,220 @@ declare class ANS {
         name: string;
     }): Promise<MoveAddressType | undefined>;
     /**
-     * Registers a new domain or subdomain name
+     * Retrieve the expiration time of a domain name or subdomain name from the contract.
      *
-     * @param args.sender - The sender account
-     * @param args.name - A string or {domainName: string, subdomainName?: string} of the name to register. This
-     * can be inclusive or exclusive of the .apt suffix.
-     * Examples include: "xyz", "xyz.apt", "xyz.kyc.apt", {domainName: "xyz"}, {domainName: "kyc", subdomainName: "xyz"}.
-     * @param args.expiration  - An object with the expiration policy of the name.
-     * @param args.expiration.policy - 'domain' | 'subdomain:follow-domain' | 'subdomain:independent'
-     * - domain: Years is required and the name will expire after the given number of years.
-     * - subdomain:follow-domain: The name will expire at the same time as the domain name.
-     * - subdomain:independent: The name will expire at the given date.
-     * @param args.transferable  - Determines if the subdomain being minted is soul-bound. Applicable only to subdomains.
+     * ```ts
+     * // Will return the expiration of "test.aptos.apt" or undefined
+     * const exp = await aptos.getExpiration({name: "test.aptos"})
+     * // new Date(exp) would give you the date in question: 2021-01-01T00:00:00.000Z
+     * ```
+     *
+     * @param args.name - A string of the name to retrieve
+     *
+     * @returns number as a unix timestamp in milliseconds.
+     */
+    getExpiration(args: {
+        name: string;
+    }): Promise<number | undefined>;
+    /**
+     * Retrieve the target address of a domain or subdomain name. This is the
+     * address the name points to for use on chain. Note, the target address can
+     * point to addresses that are not the owner of the name
+     *
+     * ```ts
+     * const targetAddr = await aptos.getTargetAddress({name: "test.aptos"})
+     * // targetAddr = 0x123...
+     * ```
+     *
+     * @param args.name - A string of the name: primary, primary.apt, secondary.primary, secondary.primary.apt, etc.
+     *
+     * @returns MoveAddressType if the name has a target, undefined otherwise
+     */
+    getTargetAddress(args: {
+        name: string;
+    }): Promise<MoveAddressType | undefined>;
+    /**
+     * Sets the target address of a domain or subdomain name. This is the
+     * address the name points to for use on chain. Note, the target address can
+     * point to addresses that are not the owner of the name
+     *
+     * ```ts
+     * await aptos.setTargetAddress({sender: alice, name: "test.aptos", address: bob.accountAddress})
+     * const address = await aptos.getTargetAddress({name: "test.aptos"})
+     * // address = bob.accountAddress
+     * ```
+     *
+     * @param args.name - A string of the name: test.aptos.apt, test.apt, test, test.aptos, etc.
+     * @param args.address - A AccountAddressInput of the address to set the domain or subdomain to
+     *
+     * @returns SingleSignerTransaction
+     */
+    setTargetAddress(args: {
+        sender: Account$1;
+        name: string;
+        address: AccountAddressInput;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SingleSignerTransaction>;
+    /**
+     * Retrieve the primary name for an account. An account can have
+     * multiple names that target it, but only a single name that is primary. An
+     * account also may not have a primary name.
+     *
+     * ```ts
+     * const name = await aptos.getPrimaryName({address: alice.accountAddress})
+     * // name = test.aptos
+     * ```
+     *
+     * @param args.address - A AccountAddressInput (address) of the account
+     *
+     * @returns a string if the account has a primary name, undefined otherwise
+     */
+    getPrimaryName(args: {
+        address: AccountAddressInput;
+    }): Promise<string | undefined>;
+    /**
+     * Sets the primary name for the sender. An account can have
+     * multiple names that target it, but only a single name that is primary. An
+     * account also may not have a primary name.
+     *
+     * ```ts
+     * await aptos.setPrimaryName({sender: alice, name: "test.aptos"})
+     * const primaryName = await aptos.getPrimaryName({address: alice.accountAddress})
+     * // primaryName = test.aptos
+     * ```
+     *
+     * @param args.sender - The sender account
+     * @param args.name - A string of the name: test, test.apt, test.aptos, test.aptos.apt, etc.
+     *
+     * @returns SingleSignerTransaction
+     */
+    setPrimaryName(args: {
+        sender: Account$1;
+        name?: string;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SingleSignerTransaction>;
+    /**
+     * Registers a new name
+     *
+     * ```ts
+     * // An example of registering a subdomain name assuming def.apt is already registered
+     * // and belongs to the sender alice.
+     *  const txn = aptos.registerName({
+     *    sender: alice,
+     *    name: "test.aptos.apt",
+     *    expiration: {
+     *      policy: "subdomain:independent",
+     *      expirationDate: Date.now() + 30 * 24 * 60 * 60 * 1000,
+     *    },
+     *  });
+     * ```
+     *
+     * @param args.sender - The sender account
+     * @param args.name - A string of the name to register. This can be inclusive or exclusive of the .apt suffix.
+     * Examples include: "test", "test.apt", "test.aptos.apt", etc.
+     * @param args.expiration  - An object with the expiration policy of the name.
+     * @param args.expiration.policy - 'domain' | 'subdomain:follow-domain' | 'subdomain:independent'
+     * - domain: Years is required and the name will expire after the given number of years.
+     * - subdomain:follow-domain: The name will expire at the same time as the domain name.
+     * - subdomain:independent: The name will expire at the given date.
+     * @param args.expiration.expirationDate - An epoch number in milliseconds of
+     * the date when the subdomain will expire. Only applicable when the policy is
+     * set to 'subdomain:independent'.
+     * @param args.transferable  - Determines if the subdomain being minted is soul-bound. Applicable only to subdomains.
      * @param args.targetAddress optional - The address the domain name will resolve to. If not provided,
      * the sender's address will be used.
      * @param args.toAddress optional - The address to send the domain name to. If not provided,
      * the transaction will be sent to the router.
      *
-     * @returns InputSingleSignerTransaction
+     * @returns SingleSignerTransaction
+     */
+    registerName(args: Omit<RegisterNameParameters, "aptosConfig">): Promise<SingleSignerTransaction>;
+    /**
+     * Renews a domain name
+     *
+     * Note: If a domain name was minted with V1 of the contract, it will automatically be upgraded to V2 via this transaction.
+     *
+     * ```ts
+     * await aptos.renewDomain({sender: alice, name: "test"})
+     * // test.apt will be renewed for one year
+     * ```
+     *
+     * @param args.sender - The sender account
+     * @param args.name - A string of the domain the subdomain will be under. The signer must be the domain owner.
+     * Subdomains cannot be renewed.
+     * @param args.years - The number of years to renew the name. Currently only one year is permitted.
+     *
+     * @returns SingleSignerTransaction
+     */
+    renewDomain(args: {
+        sender: Account$1;
+        name: string;
+        years?: 1;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<SingleSignerTransaction>;
+    /**
+     * Fetches a single name from the indexer
+     * @param args.name - A string of the name to retrieve, e.g. "test.aptos.apt"
+     * or "test.apt" or "test". Can be inclusive or exclusive of the .apt suffix.
+     * Can be a subdomain.
+     *
+     * @returns A promise of an ANSName or undefined
+     */
+    getName(args: {
+        name: string;
+    }): Promise<GetANSNameResponse[0] | undefined>;
+    /**
+     * Fetches all  names for an account (both top level domains and subdomains)
+     *
+     * @param args
+     * @param args.accountAddress - A AccountAddressInput of the address to retrieve names for.
+     * @param args.options.offset - Optional, the offset to start from when fetching names
+     * @param args.options.limit - Optional, A number of the names to fetch per request
+     * @param args.options.orderBy - The order to sort the names by
+     * @param args.options.where - Additional filters to apply to the query
+     *
+     * @returns a promise of an array of ANSName
+     */
+    getAccountNames(args: GetAccountNamesArgs): Promise<GetANSNameResponse>;
+    /**
+     * Fetches all top level domain names for an account
+     *
+     * @param args
+     * @param args.accountAddress - A AccountAddressInput of the address to retrieve domain names for.
+     * @param args.options.offset - Optional, the offset to start from when fetching names
+     * @param args.options.limit - Optional, A number of the names to fetch per request
+     * @param args.options.orderBy - The order to sort the names by
+     * @param args.options.where - Additional filters to apply to the query
+     *
+     * @returns a promise of an array of ANSName
+     */
+    getAccountDomains(args: GetAccountDomainsArgs): Promise<GetANSNameResponse>;
+    /**
+     * Fetches all subdomains names for an account
+     *
+     * @param args
+     * @param args.accountAddress - A AccountAddressInput of the address to retrieve subdomains names for.
+     * @param args.options.offset - Optional, the offset to start from when fetching names
+     * @param args.options.limit - Optional, A number of the names to fetch per request
+     * @param args.options.orderBy - The order to sort the names by
+     * @param args.options.where - Additional filters to apply to the query
+     *
+     * @returns a promise of an array of ANSName
+     */
+    getAccountSubdomains(args: GetAccountSubdomainsArgs): Promise<GetANSNameResponse>;
+    /**
+     * Fetches all subdomains names for a given domain. Note, this will not return the domain itself.
+     *
+     * @param args
+     * @param args.domain - A string of the domain name: eg. "test.apt" or "test" (without the suffix of .apt)
+     * @param args.options.offset - Optional, the offset to start from when fetching names
+     * @param args.options.limit - Optional, A number of the names to fetch per request
+     * @param args.options.orderBy - The order to sort the names by
+     * @param args.options.where - Additional filters to apply to the query
+     *
+     * @returns a promise of an array of ANSName
      */
-    registerName(args: Omit<RegisterNameParameters, "aptosConfig">): Promise<InputSingleSignerTransaction>;
+    getDomainSubdomains(args: GetDomainSubdomainsArgs): Promise<GetANSNameResponse>;
 }
 
 /**
@@ -5301,31 +5768,35 @@ declare class Staking {
      * Queries current number of delegators in a pool.  Throws an error if the pool is not found.
      *
      * @param args.poolAddress Pool address
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns The number of delegators for the given pool
      */
     getNumberOfDelegators(args: {
         poolAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
     }): Promise<number>;
     /**
      * Queries current number of delegators in a pool.  Throws an error if the pool is not found.
      *
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns GetNumberOfDelegatorsForAllPoolsResponse response type
      */
     getNumberOfDelegatorsForAllPools(args?: {
-        options?: {
-            orderBy?: OrderBy<GetNumberOfDelegatorsResponse[0]>;
-        };
+        minimumLedgerVersion?: AnyNumber;
+        options?: OrderByArg<GetNumberOfDelegatorsResponse[0]>;
     }): Promise<GetNumberOfDelegatorsResponse>;
     /**
      * Queries delegated staking activities
      *
      * @param args.delegatorAddress Delegator address
      * @param args.poolAddress Pool address
+     * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
      * @returns GetDelegatedStakingActivitiesResponse response type
      */
     getDelegatedStakingActivities(args: {
         delegatorAddress: AccountAddressInput;
         poolAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
     }): Promise<GetDelegatedStakingActivitiesResponse>;
 }
 
@@ -5402,7 +5873,7 @@ declare class Transaction {
     waitForTransaction(args: {
         transactionHash: HexInput;
         options?: WaitForTransactionOptions;
-    }): Promise<TransactionResponse>;
+    }): Promise<CommittedTransactionResponse>;
     /**
      * Gives an estimate of the gas unit price required to get a
      * transaction on chain in a reasonable amount of time.
@@ -5419,62 +5890,42 @@ declare class Transaction {
      * ```
      */
     getGasPriceEstimation(): Promise<GasEstimation>;
+    /**
+     * Returns a signing message for a transaction.
+     *
+     * This allows a user to sign a transaction using their own preferred signing method, and
+     * then submit it to the network.
+     * @param args.transaction A raw transaction for signing elsewhere
+     */
+    getSigningMessage(args: {
+        transaction: AnyRawTransaction;
+    }): Uint8Array;
 }
 
 declare class TransactionSubmission {
     readonly config: AptosConfig;
     constructor(config: AptosConfig);
     /**
-     * We are defining function signatures, each with its specific input and output.
-     * These are the possible function signature for `generateTransaction` function.
-     * When we call `generateTransaction` function with the relevant type properties,
-     * Typescript can infer the return type based on the appropriate function overload.
-     */
-    generateTransaction(args: InputGenerateSingleSignerRawTransactionData): Promise<InputSingleSignerTransaction>;
-    generateTransaction(args: InputGenerateFeePayerRawTransactionData): Promise<InputFeePayerTransaction>;
-    generateTransaction(args: InputGenerateMultiAgentRawTransactionData): Promise<InputMultiAgentTransaction>;
-    generateTransaction(args: InputGenerateTransactionData): Promise<AnyRawTransaction>;
-    /**
-     * Sign a transaction that can later be submitted to chain
-     *
-     * @param args.signer The signer account to sign the transaction
-     * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
-     * @param args.asFeePayer optional. If the signer is also the fee payer
-     * ```
-     * {
-     *  rawTransaction: RawTransaction,
-     *  secondarySignerAddresses?: Array<AccountAddress>,
-     *  feePayerAddress?: AccountAddress
-     * }
-     * ```
+     * Batch transactions for a single account.
      *
-     * @return The signer AccountAuthenticator
-     */
-    signTransaction(args: {
-        signer: Account$1;
-        transaction: AnyRawTransaction;
-        asFeePayer?: boolean;
-    }): AccountAuthenticator;
-    /**
-     * Simulates a transaction before singing it.
+     * This function uses a transaction worker that receives payloads to be processed
+     * and submitted to chain.
+     * Note that this process is best for submitting multiple transactions that
+     * dont rely on each other, i.e batch funds, batch token mints, etc.
      *
-     * @param args.signerPublicKey The signer public key
-     * @param args.transaction The raw transaction to simulate
-     * @param args.secondarySignersPublicKeys optional. For when the transaction is a multi signers transaction
-     * @param args.feePayerPublicKey optional. For when the transaction is a fee payer (aka sponsored) transaction
-     * @param args.options optional. A config to simulate the transaction with
-     */
-    simulateTransaction(args: InputSimulateTransactionData): Promise<Array<UserTransactionResponse>>;
-    /**
-     * Submit transaction to chain
+     * If any worker failure, the functions throws an error.
      *
-     * @param args.transaction A aptos transaction type
-     * @param args.senderAuthenticator The account authenticator of the transaction sender
-     * @param args.secondarySignerAuthenticators optional. For when the transaction is a multi signers transaction
+     * @param args.sender The sender account to sign and submit the transaction
+     * @param args.data An array of transaction payloads
+     * @param args.options optional. Transaction generation configurations (excluding accountSequenceNumber)
      *
-     * @return PendingTransactionResponse
+     * @return void. Throws if any error
      */
-    submitTransaction(args: InputSubmitTransactionData): Promise<PendingTransactionResponse>;
+    batchTransactionsForSingleAccount(args: {
+        sender: Account$1;
+        data: InputGenerateTransactionPayloadData[];
+        options?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">;
+    }): Promise<void>;
     /**
      * Sign and submit a single signer transaction to chain
      *
@@ -5512,7 +5963,7 @@ declare class TransactionSubmission {
         metadataBytes: HexInput;
         moduleBytecode: Array<HexInput>;
         options?: InputGenerateTransactionOptions;
-    }): Promise<InputSingleSignerTransaction>;
+    }): Promise<SingleSignerTransaction>;
     /**
      * Rotate an account's auth key. After rotation, only the new private key can be used to sign txns for
      * the account.
@@ -5529,6 +5980,83 @@ declare class TransactionSubmission {
     }): Promise<TransactionResponse>;
 }
 
+/**
+ * A class to handle all `Build` transaction operations
+ */
+declare class Build {
+    readonly config: AptosConfig;
+    constructor(config: AptosConfig);
+    transaction(args: {
+        sender: AccountAddressInput;
+        data: InputGenerateTransactionPayloadData;
+        options?: InputGenerateTransactionOptions;
+        withFeePayer?: boolean;
+    }): Promise<SingleSignerTransaction>;
+    multiAgentTransaction(args: {
+        sender: AccountAddressInput;
+        data: InputGenerateTransactionPayloadData;
+        secondarySignerAddresses: AccountAddressInput[];
+        options?: InputGenerateTransactionOptions;
+        withFeePayer?: boolean;
+    }): Promise<MultiAgentTransaction>;
+}
+
+/**
+ * A class to handle all `Sign` transaction operations
+ */
+declare class Sign {
+    readonly config: AptosConfig;
+    constructor(config: AptosConfig);
+    transaction(args: {
+        signer: Account$1;
+        transaction: AnyRawTransaction;
+    }): AccountAuthenticator;
+    transactionAsFeePayer(args: {
+        signer: Account$1;
+        transaction: AnyRawTransaction;
+    }): AccountAuthenticator;
+}
+
+/**
+ * A class to handle all `Simulate` transaction operations
+ */
+declare class Simulate {
+    readonly config: AptosConfig;
+    constructor(config: AptosConfig);
+    transaction(args: {
+        signerPublicKey: PublicKey;
+        transaction: AnyRawTransaction;
+        feePayerPublicKey?: PublicKey;
+        options?: InputSimulateTransactionOptions;
+    }): Promise<Array<UserTransactionResponse>>;
+    multiAgentTransaction(args: {
+        signerPublicKey: PublicKey;
+        transaction: AnyRawTransaction;
+        secondarySignersPublicKeys: Array<PublicKey>;
+        feePayerPublicKey?: PublicKey;
+        options?: InputSimulateTransactionOptions;
+    }): Promise<Array<UserTransactionResponse>>;
+}
+
+/**
+ * A class to handle all `Submit` transaction operations
+ */
+declare class Submit {
+    readonly config: AptosConfig;
+    constructor(config: AptosConfig);
+    transaction(args: {
+        transaction: AnyRawTransaction;
+        senderAuthenticator: AccountAuthenticator;
+        feePayerAuthenticator?: AccountAuthenticator;
+    }): Promise<PendingTransactionResponse>;
+    multiAgentTransaction(args: {
+        transaction: AnyRawTransaction;
+        senderAuthenticator: AccountAuthenticator;
+        additionalSignersAuthenticators: Array<AccountAuthenticator>;
+        feePayerAuthenticator?: AccountAuthenticator;
+    }): Promise<PendingTransactionResponse>;
+}
+
 /**
  * This class is the main entry point into Aptos's
  * APIs and separates functionality into different namespaces.
@@ -5549,6 +6077,10 @@ declare class Aptos {
     readonly staking: Staking;
     readonly transaction: Transaction;
     readonly transactionSubmission: TransactionSubmission;
+    readonly build: Build;
+    readonly sign: Sign;
+    readonly simulate: Simulate;
+    readonly submit: Submit;
     constructor(settings?: AptosConfig);
 }
 interface Aptos extends Account, Coin, DigitalAsset, Event, Faucet, FungibleAsset, General, Staking, Transaction, ANS, TransactionSubmission {
@@ -5650,7 +6182,7 @@ type GetAptosRequestOptions = Omit<GetRequestOptions, "type">;
  */
 declare function get<Req extends {}, Res extends {}>(options: GetRequestOptions): Promise<AptosResponse<Req, Res>>;
 declare function getAptosFullNode<Req extends {}, Res extends {}>(options: GetAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
-declare function paginateWithCursor<Req extends Record<string, any>, Res extends any[]>(options: GetAptosRequestOptions): Promise<Res>;
+declare function paginateWithCursor<Req extends Record<string, any>, Res extends Array<{}>>(options: GetAptosRequestOptions): Promise<Res>;
 
 type PostRequestOptions = {
     /**
@@ -5702,182 +6234,228 @@ 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>>;
 
-declare function isBool(arg: SimpleEntryFunctionArgumentTypes): arg is boolean;
-declare function isString(arg: any): arg is string;
-declare function isNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number;
-declare function isLargeNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number | bigint | string;
-declare function isNull(arg: SimpleEntryFunctionArgumentTypes): arg is null | undefined;
-declare function isBcsBool(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is Bool;
-declare function isBcsAddress(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is AccountAddress;
-declare function isBcsString(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is MoveString;
-declare function isBcsFixedBytes(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is FixedBytes;
-declare function isBcsU8(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U8;
-declare function isBcsU16(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U16;
-declare function isBcsU32(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U32;
-declare function isBcsU64(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U64;
-declare function isBcsU128(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U128;
-declare function isBcsU256(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U256;
-declare function isScriptDataInput(arg: InputGenerateTransactionPayloadDataWithRemoteABI | InputGenerateTransactionPayloadData): arg is InputScriptData;
-declare function throwTypeMismatch(expectedType: string, position: number): void;
-/**
- * Finds first non-signer arg.
- *
- * A function is often defined with a `signer` or `&signer` arguments at the start, which are filled in
- * by signatures, and not by the caller.
- * @param functionAbi
- */
-declare function findFirstNonSignerArg(functionAbi: MoveFunction): number;
-declare function getFunctionParts(functionArg: MoveFunctionId): {
-    moduleAddress: string;
-    moduleName: string;
-    functionName: string;
-};
-
-/**
- * We are defining function signatures, each with its specific input and output.
- * These are the possible function signature for our `generateTransactionPayload` function.
- * When we call our `generateTransactionPayload` function with the relevant type properties,
- * Typescript can infer the return type based on the appropriate function overload.
- */
-declare function generateTransactionPayload(args: InputScriptData): Promise<TransactionPayloadScript>;
-declare function generateTransactionPayload(args: InputEntryFunctionDataWithRemoteABI): Promise<TransactionPayloadEntryFunction>;
-declare function generateTransactionPayload(args: InputMultiSigDataWithRemoteABI): Promise<TransactionPayloadMultisig>;
-declare function generateTransactionPayload(args: InputGenerateTransactionPayloadDataWithRemoteABI): Promise<AnyTransactionPayloadInstance>;
-declare function generateTransactionPayloadWithABI(args: InputEntryFunctionData, functionAbi: EntryFunctionABI): TransactionPayloadEntryFunction;
-declare function generateTransactionPayloadWithABI(args: InputMultiSigData, functionAbi: EntryFunctionABI): TransactionPayloadMultisig;
-/**
- * Generates a raw transaction
- *
- * @param args.aptosConfig AptosConfig
- * @param args.sender The transaction's sender account address as a hex input
- * @param args.payload The transaction payload - can create by using generateTransactionPayload()
- *
- * @returns RawTransaction
- */
-declare function generateRawTransaction(args: {
-    aptosConfig: AptosConfig;
-    sender: AccountAddressInput;
-    payload: AnyTransactionPayloadInstance;
-    options?: InputGenerateTransactionOptions;
-}): Promise<RawTransaction>;
-/**
- * We are defining function signatures, each with its specific input and output.
- * These are the possible function signature for our `generateTransaction` function.
- * When we call our `generateTransaction` function with the relevant type properties,
- * Typescript can infer the return type based on the appropriate function overload.
- */
-declare function buildTransaction(args: InputGenerateSingleSignerRawTransactionArgs): Promise<InputSingleSignerTransaction>;
-declare function buildTransaction(args: InputGenerateFeePayerRawTransactionArgs): Promise<InputFeePayerTransaction>;
-declare function buildTransaction(args: InputGenerateMultiAgentRawTransactionArgs): Promise<InputMultiAgentTransaction>;
-declare function buildTransaction(args: InputGenerateRawTransactionArgs): Promise<AnyRawTransaction>;
-/**
- * Simulate a transaction before signing and submit to chain
- *
- * @param args.transaction A aptos transaction type to sign
- * @param args.signerPublicKey The signer public key
- * @param args.secondarySignersPublicKeys optional. The secondary signers public keys if multi signers transaction
- * @param args.feePayerPublicKey optional. The fee payer public key is a fee payer (aka sponsored) transaction
- * @param args.options optional. SimulateTransactionOptions
- *
- * @returns A signed serialized transaction that can be simulated
- */
-declare function generateSignedTransactionForSimulation(args: InputSimulateTransactionData): Uint8Array;
-declare function getAuthenticatorForSimulation(publicKey: PublicKey): AccountAuthenticatorEd25519 | AccountAuthenticatorSingleKey;
-/**
- * Sign a transaction that can later be submitted to chain
- *
- * @param args.signer The signer account to sign the transaction
- * @param args.transaction A aptos transaction type to sign
- *
- * @return The signer AccountAuthenticator
- */
-declare function sign(args: {
-    signer: Account$1;
-    transaction: AnyRawTransaction;
-}): AccountAuthenticator;
-/**
- * Prepare a transaction to be submitted to chain
- *
- * @param args.transaction A aptos transaction type
- * @param args.senderAuthenticator The account authenticator of the transaction sender
- * @param args.secondarySignerAuthenticators optional. For when the transaction is a multi signers transaction
- *
- * @returns A SignedTransaction
- */
-declare function generateSignedTransaction(args: InputSubmitTransactionData): Uint8Array;
 /**
- * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction
- *
- * @param transaction A aptos transaction type
+ * A wrapper that handles and manages an account sequence number.
  *
- * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
- */
-declare function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance;
-/**
- * Generate a multi signers signed transaction that can be submitted to chain
+ * Submit up to `maximumInFlight` transactions per account in parallel with a timeout of `sleepTime`
+ * If local assumes `maximumInFlight` are in flight, determine the actual committed state from the network
+ * If there are less than `maximumInFlight` due to some being committed, adjust the window
+ * If `maximumInFlight` are in flight, wait `sleepTime` seconds before re-evaluating
+ * If ever waiting more than `maxWaitTime` restart the sequence number to the current on-chain state
  *
- * @param transaction MultiAgentRawTransaction | FeePayerRawTransaction
- * @param senderAuthenticator The account authenticator of the transaction sender
- * @param secondarySignerAuthenticators The extra signers account Authenticators
+ * Assumptions:
+ * Accounts are expected to be managed by a single AccountSequenceNumber and not used otherwise.
+ * They are initialized to the current on-chain state, so if there are already transactions in
+ * flight, they may take some time to reset.
+ * Accounts are automatically initialized if not explicitly
  *
- * @returns A SignedTransaction
+ * Notes:
+ * This is co-routine safe, that is many async tasks can be reading from this concurrently.
+ * The state of an account cannot be used across multiple AccountSequenceNumber services.
+ * The synchronize method will create a barrier that prevents additional nextSequenceNumber
+ * calls until it is complete.
+ * This only manages the distribution of sequence numbers it does not help handle transaction
+ * failures.
+ * If a transaction fails, you should call synchronize and wait for timeouts.
  */
-declare function generateMultiSignersSignedTransaction(transaction: MultiAgentRawTransaction | FeePayerRawTransaction, senderAuthenticator: AccountAuthenticator, feePayerAuthenticator?: AccountAuthenticator, additionalSignersAuthenticators?: Array<AccountAuthenticator>): Uint8Array;
-declare function getSigningMessage(rawTxn: AnyRawTransactionInstance): Uint8Array;
+
+declare class AccountSequenceNumber {
+    readonly aptosConfig: AptosConfig;
+    readonly account: Account$1;
+    lastUncommintedNumber: bigint | null;
+    currentNumber: bigint | null;
+    /**
+     * We want to guarantee that we preserve ordering of workers to requests.
+     *
+     * `lock` is used to try to prevent multiple coroutines from accessing a shared resource at the same time,
+     * which can result in race conditions and data inconsistency.
+     * This code actually doesn't do it though, since we aren't giving out a slot, it is still somewhat a race condition.
+     *
+     * The ideal solution is likely that each thread grabs the next number from a incremental integer.
+     * When they complete, they increment that number and that entity is able to enter the `lock`.
+     * That would guarantee ordering.
+     */
+    lock: boolean;
+    maxWaitTime: number;
+    maximumInFlight: number;
+    sleepTime: number;
+    constructor(aptosConfig: AptosConfig, account: Account$1, maxWaitTime: number, maximumInFlight: number, sleepTime: number);
+    /**
+     * Returns the next available sequence number for this account
+     *
+     * @returns next available sequence number
+     */
+    nextSequenceNumber(): Promise<bigint | null>;
+    /**
+     * Initializes this account with the sequence number on chain
+     */
+    initialize(): Promise<void>;
+    /**
+     * Updates this account sequence number with the one on-chain
+     *
+     * @returns on-chain sequence number for this account
+     */
+    update(): Promise<bigint>;
+    /**
+     * Synchronizes local sequence number with the seqeunce number on chain for this account.
+     *
+     * Poll the network until all submitted transactions have either been committed or until
+     * the maximum wait time has elapsed
+     */
+    synchronize(): Promise<void>;
+}
 
 /**
- * Convert type arguments to only type tags, allowing for string representations of type tags
+ * The AsyncQueue class is an async-aware data structure that provides a queue-like
+ * behavior for managing asynchronous tasks or operations.
+ * It allows to enqueue items and dequeue them asynchronously.
+ * This is not thread-safe but it is async concurrency safe and
+ * it does not guarantee ordering for those that call into and await on enqueue.
  */
-declare function standardizeTypeTags(typeArguments?: Array<TypeTag | string>): Array<TypeTag>;
+declare class AsyncQueue<T> {
+    readonly queue: T[];
+    private pendingDequeue;
+    private cancelled;
+    /**
+     * The enqueue method adds an item to the queue. If there are pending dequeued promises,
+     * in the pendingDequeue, it resolves the oldest promise with the enqueued item immediately.
+     * Otherwise, it adds the item to the queue.
+     *
+     * @param item T
+     */
+    enqueue(item: T): void;
+    /**
+     * The dequeue method returns a promise that resolves to the next item in the queue.
+     * If the queue is not empty, it resolves the promise immediately with the next item.
+     * Otherwise, it creates a new promise. The promise's resolve function is stored
+     * in the pendingDequeue with a unique counter value as the key.
+     * The newly created promise is then returned, and it will be resolved later when an item is enqueued.
+     *
+     * @returns Promise<T>
+     */
+    dequeue(): Promise<T>;
+    /**
+     * The isEmpty method returns whether the queue is empty or not.
+     *
+     * @returns boolean
+     */
+    isEmpty(): boolean;
+    /**
+     * The cancel method cancels all pending promises in the queue.
+     * It rejects the promises with a AsyncQueueCancelledError error,
+     * ensuring that any awaiting code can handle the cancellation appropriately.
+     */
+    cancel(): void;
+    /**
+     * The isCancelled method returns whether the queue is cancelled or not.
+     *
+     * @returns boolean
+     */
+    isCancelled(): boolean;
+    /**
+     * The pendingDequeueLength method returns the length of the pendingDequeue.
+     *
+     * @returns number
+     */
+    pendingDequeueLength(): number;
+}
+
 /**
- * Fetches the ABI for an entry function from the module
+ * TransactionWorker provides a simple framework for receiving payloads to be processed.
  *
- * @param moduleAddress
- * @param moduleName
- * @param functionName
- * @param aptosConfig
+ * Once one `start()` the process and pushes a new transaction, the worker acquires
+ * the current account's next sequence number (by using the AccountSequenceNumber class),
+ * generates a signed transaction and pushes an async submission process into the `outstandingTransactions` queue.
+ * At the same time, the worker processes transactions by reading the `outstandingTransactions` queue
+ * and submits the next transaction to chain, it
+ * 1) waits for resolution of the submission process or get pre-execution validation error
+ * and 2) waits for the resolution of the execution process or get an execution error.
+ * The worker fires events for any submission and/or execution success and/or failure.
  */
-declare function fetchEntryFunctionAbi(moduleAddress: string, moduleName: string, functionName: string, aptosConfig: AptosConfig): Promise<EntryFunctionABI>;
-/**
- * Converts a non-BCS encoded argument into BCS encoded, if necessary
- * @param functionName
- * @param functionAbi
- * @param arg
- * @param position
- */
-declare function convertArgument(functionName: string, functionAbi: EntryFunctionABI, arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes, position: number, genericTypeParams: Array<TypeTag>): EntryFunctionArgumentTypes;
 
-declare enum TypeTagParserErrorType {
-    InvalidTypeTag = "unknown type",
-    UnexpectedGenericType = "unexpected generic type",
-    UnexpectedTypeArgumentClose = "unexpected '>'",
-    UnexpectedWhitespaceCharacter = "unexpected whitespace character",
-    UnexpectedComma = "unexpected ','",
-    TypeArgumentCountMismatch = "type argument count doesn't match expected amount",
-    MissingTypeArgumentClose = "no matching '>' for '<'",
-    UnexpectedPrimitiveTypeArguments = "primitive types not expected to have type arguments",
-    UnexpectedVectorTypeArgumentCount = "vector type expected to have exactly one type argument",
-    UnexpectedStructFormat = "unexpected struct format, must be of the form 0xaddress::module_name::struct_name",
-    InvalidModuleNameCharacter = "module name must only contain alphanumeric or '_' characters",
-    InvalidStructNameCharacter = "struct name must only contain alphanumeric or '_' characters"
-}
-declare class TypeTagParserError extends Error {
-    constructor(typeTagStr: string, invalidReason: TypeTagParserErrorType);
+declare class TransactionWorker {
+    readonly aptosConfig: AptosConfig;
+    readonly account: Account$1;
+    readonly accountSequnceNumber: AccountSequenceNumber;
+    readonly taskQueue: AsyncQueue<() => Promise<void>>;
+    started: boolean;
+    /**
+     * transactions payloads waiting to be generated and signed
+     *
+     * TODO support entry function payload from ABI builder
+     */
+    transactionsQueue: AsyncQueue<[InputGenerateTransactionPayloadData, InputGenerateTransactionOptions | undefined]>;
+    /**
+     * signed transactions waiting to be submitted
+     */
+    outstandingTransactions: AsyncQueue<[Promise<PendingTransactionResponse>, bigint]>;
+    /**
+     * transactions that have been submitted to chain
+     */
+    sentTransactions: Array<[string, bigint, any]>;
+    /**
+     * transactions that have been committed to chain
+     */
+    executedTransactions: Array<[string, bigint, any]>;
+    /**
+     * Provides a simple framework for receiving payloads to be processed.
+     *
+     * @param aptosConfig - a config object
+     * @param sender - a sender as Account
+     * @param maxWaitTime - the max wait time to wait before resyncing the sequence number
+     * to the current on-chain state, default to 30
+     * @param maximumInFlight - submit up to `maximumInFlight` transactions per account.
+     * Mempool limits the number of transactions per account to 100, hence why we default to 100.
+     * @param sleepTime - If `maximumInFlight` are in flight, wait `sleepTime` seconds before re-evaluating, default to 10
+     */
+    constructor(aptosConfig: AptosConfig, account: Account$1, maxWaitTime?: number, maximumInFlight?: number, sleepTime?: number);
+    /**
+     * Gets the current account sequence number,
+     * generates the transaction with the account sequence number,
+     * adds the transaction to the outstanding transaction queue
+     * to be processed later.
+     */
+    submitNextTransaction(): Promise<void>;
+    /**
+     * Reads the outstanding transaction queue and submits the transaction to chain.
+     *
+     * If the transaction has fulfilled, it pushes the transaction to the processed
+     * transactions queue and fires a transactionsFulfilled event.
+     *
+     * If the transaction has failed, it pushes the transaction to the processed
+     * transactions queue with the failure reason and fires a transactionsFailed event.
+     */
+    processTransactions(): Promise<void>;
+    /**
+     * Once transaction has been sent to chain, we check for its execution status.
+     * @param sentTransaction transactions that were sent to chain and are now waiting to be executed
+     * @param sequenceNumber the account's sequence number that was sent with the transaction
+     */
+    checkTransaction(sentTransaction: PromiseFulfilledResult<PendingTransactionResponse>, sequenceNumber: bigint): Promise<void>;
+    /**
+     * Push transaction to the transactions queue
+     * @param payload Transaction payload
+     */
+    push(transactionData: InputGenerateTransactionPayloadData, options?: InputGenerateTransactionOptions): Promise<void>;
+    /**
+     * Generates a signed transaction that can be submitted to chain
+     * @param account an Aptos account
+     * @param sequenceNumber a sequence number the transaction will be generated with
+     * @returns
+     */
+    generateNextTransaction(account: Account$1, sequenceNumber: bigint): Promise<SingleSignerTransaction | undefined>;
+    /**
+     * Starts transaction submission and transaction processing.
+     */
+    run(): Promise<void>;
+    /**
+     * Starts the transaction management process.
+     */
+    start(): void;
+    /**
+     * Stops the the transaction management process.
+     */
+    stop(): void;
 }
-/**
- * All types are made of a few parts they're either:
- * 1. A simple type e.g. u8
- * 2. A standalone struct e.g. 0x1::account::Account
- * 3. A nested struct e.g. 0x1::coin::Coin<0x1234::coin::MyCoin>
- *
- * There are a few more special cases that need to be handled, however.
- * 1. Multiple generics e.g 0x1::pair::Pair<u8, u16>
- * 2. Spacing in the generics e.g. 0x1::pair::Pair< u8 , u16>
- * 3. Nested generics of different depths e.g. 0x1::pair::Pair<0x1::coin::Coin<0x1234::coin::MyCoin>, u8>
- * 4. Generics for types in ABIs are filled in with placeholders e.g T1, T2, T3
- */
-declare function parseTypeTag(typeStr: string, options?: {
-    allowGenerics?: boolean;
-}): TypeTag;
 
-export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_HARDENED_REGEX, Account$1 as Account, AccountAddress, AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountAuthenticatorVariant, AccountData, AccountEd25519Signature, AccountMultiEd25519Signature, AccountSecp256k1Signature, AccountSignature, AddressInvalidReason, AnyNumber, AnyPublicKeyVariant, AnyRawTransaction, AnyRawTransactionInstance, AnySignatureVariant, AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, AptosRequest, AptosResponse, AptosSettings, AuthenticationKey, AuthenticationKeyScheme, Block, BlockMetadataTransactionResponse, Bool, CKDPriv, ChainId, Client, ClientConfig, ClientRequest, ClientResponse, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_NETWORK, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, DecodedTableData, DeletedTableData, DeriveScheme, DerivedKeys, Deserializable, Deserializer, DirectWriteSet, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, EntryFunction, EntryFunctionABI, EntryFunctionArgument, EntryFunctionArgumentTypes, EntryFunctionBytes, EntryFunctionPayloadResponse, Event$1 as Event, EventGuid, FeePayerRawTransaction, FixedBytes, GasEstimation, GenerateAccount, GenerateAccountWithEd25519, GenerateAccountWithSingleSignerSecp256k1Key, GenesisPayload, GenesisTransactionResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedObjectsResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, GetRequestOptions, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, HARDENED_OFFSET, Hex, HexInput, HexInvalidReason, Identifier, InputEntryFunctionData, InputEntryFunctionDataWithRemoteABI, InputFeePayerTransaction, InputGenerateFeePayerRawTransactionArgs, InputGenerateFeePayerRawTransactionData, InputGenerateMultiAgentRawTransactionArgs, InputGenerateMultiAgentRawTransactionData, InputGenerateRawTransactionArgs, InputGenerateSingleSignerRawTransactionArgs, InputGenerateSingleSignerRawTransactionData, InputGenerateTransactionData, InputGenerateTransactionOptions, InputGenerateTransactionPayloadData, InputGenerateTransactionPayloadDataWithRemoteABI, InputMultiAgentTransaction, InputMultiSigData, InputMultiSigDataWithRemoteABI, InputScriptData, InputSimulateTransactionData, InputSimulateTransactionOptions, InputSingleSignerTransaction, InputSubmitTransactionData, InputViewRequestData, KeyType, LedgerInfo, LedgerVersion, MimeType, ModuleId, MoveAbility, MoveAddressType, MoveFunction, MoveFunctionGenericTypeParam, MoveFunctionId, MoveFunctionVisibility, MoveModule, MoveModuleBytecode, MoveModuleId, MoveObjectType, MoveOption, MoveOptionType, MoveResource, MoveScriptBytecode, MoveString, MoveStruct, MoveStructField, MoveStructId, MoveStructType, MoveType, MoveUint128Type, MoveUint16Type, MoveUint256Type, MoveUint32Type, MoveUint64Type, MoveUint8Type, MoveValue, MoveVector, MultiAgentRawTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiSig, MultisigPayloadResponse, MultisigTransactionPayload, Network, NetworkToChainId, NetworkToFaucetAPI, NetworkToIndexerAPI, NetworkToNetworkName, NetworkToNodeAPI, OrderBy, OrderByValue, PaginationArgs, ParsingError, ParsingResult, PendingTransactionResponse, PostAptosRequestOptions, PostRequestOptions, PrivateKey, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RoleType, RotationProofChallenge, Script, ScriptFunctionArgument, ScriptFunctionArgumentTypes, ScriptPayloadResponse, ScriptTransactionArgumentVariants, ScriptWriteSet, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, SimpleEntryFunctionArgumentTypes, StateCheckpointTransactionResponse, StructTag, TableItemRequest, TokenStandard, TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionAuthenticatorVariant, TransactionEd25519Signature, TransactionFeePayerSignature, TransactionMultiAgentSignature, TransactionMultiEd25519Signature, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultisig, TransactionPayloadResponse, TransactionPayloadScript, TransactionPayloadVariants, TransactionResponse, TransactionResponseType, TransactionSecp256k1Signature, TransactionSignature, TransactionVariants, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVariants, TypeTagVector, U128, U16, U256, U32, U64, U8, Uint128, Uint16, Uint256, Uint32, Uint64, Uint8, UserTransactionResponse, ViewRequest, WaitForTransactionOptions, WriteSet, WriteSetChange, WriteSetChangeDeleteModule, WriteSetChangeDeleteResource, WriteSetChangeDeleteTableItem, WriteSetChangeWriteModule, WriteSetChangeWriteResource, WriteSetChangeWriteTableItem, aptosCoinStructTag, aptosRequest, buildTransaction, convertArgument, deriveKey, deriveTransactionType, deserializeFromScriptArgument, ensureBoolean, fetchEntryFunctionAbi, findFirstNonSignerArg, generateMultiSignersSignedTransaction, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateTransactionPayload, generateTransactionPayloadWithABI, get, getAptosFullNode, getAuthenticatorForSimulation, getFunctionParts, getSigningMessage, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBool, isLargeNumber, isNull, isNumber, isScriptDataInput, isString, isValidBIP44Path, isValidHardenedPath, mnemonicToSeed, objectStructTag, optionStructTag, outOfRangeErrorMessage, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, request, sign, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch, validateNumberInRange };
+export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_HARDENED_REGEX, Account$1 as Account, AccountAddress, AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountAuthenticatorVariant, AccountData, AccountSequenceNumber, AccountSignature, AddressInvalidReason, AnyNumber, AnyPublicKey, AnyPublicKeyVariant, AnyRawTransaction, AnyRawTransactionInstance, AnySignature, AnySignatureVariant, AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, AptosRequest, AptosResponse, AptosSettings, AuthenticationKey, AuthenticationKeyScheme, Block, BlockMetadataTransactionResponse, Bool, CKDPriv, ChainId, Client, ClientConfig, ClientRequest, ClientResponse, CommittedTransactionResponse, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_NETWORK, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, DecodedTableData, DeletedTableData, DeriveScheme, DerivedKeys, Deserializable, Deserializer, DirectWriteSet, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, EntryFunction, EntryFunctionABI, EntryFunctionArgument, EntryFunctionArgumentTypes, EntryFunctionBytes, EntryFunctionPayloadResponse, Event$1 as Event, EventGuid, FeePayerRawTransaction, FixedBytes, GasEstimation, GenerateAccount, GenerateAccountWithEd25519, GenerateAccountWithSingleSignerSecp256k1Key, GenesisPayload, GenesisTransactionResponse, GetANSNameResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedObjectsResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, GetRequestOptions, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, HARDENED_OFFSET, Hex, HexInput, HexInvalidReason, Identifier, InputEntryFunctionData, InputEntryFunctionDataWithRemoteABI, InputGenerateMultiAgentRawTransactionArgs, InputGenerateMultiAgentRawTransactionData, InputGenerateRawTransactionArgs, InputGenerateSingleSignerRawTransactionArgs, InputGenerateSingleSignerRawTransactionData, InputGenerateTransactionData, InputGenerateTransactionOptions, InputGenerateTransactionPayloadData, InputGenerateTransactionPayloadDataWithRemoteABI, InputMultiSigData, InputMultiSigDataWithRemoteABI, InputScriptData, InputSimulateTransactionData, InputSimulateTransactionOptions, InputSubmitTransactionData, InputViewRequestData, KeyType, LedgerInfo, LedgerVersionArg, MimeType, ModuleId, MoveAbility, MoveAddressType, MoveFunction, MoveFunctionGenericTypeParam, MoveFunctionId, MoveFunctionVisibility, MoveModule, MoveModuleBytecode, MoveModuleId, MoveObjectType, MoveOption, MoveOptionType, MoveResource, MoveScriptBytecode, MoveString, MoveStruct, MoveStructField, MoveStructId, MoveStructType, MoveType, MoveUint128Type, MoveUint16Type, MoveUint256Type, MoveUint32Type, MoveUint64Type, MoveUint8Type, MoveValue, MoveVector, MultiAgentRawTransaction, MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiSig, MultisigPayloadResponse, MultisigTransactionPayload, Network, NetworkToChainId, NetworkToFaucetAPI, NetworkToIndexerAPI, NetworkToNetworkName, NetworkToNodeAPI, OrderBy, OrderByArg, OrderByValue, PaginationArgs, ParsingError, ParsingResult, PendingTransactionResponse, PostAptosRequestOptions, PostRequestOptions, PrivateKey, ProcessorType, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RoleType, RotationProofChallenge, Script, ScriptFunctionArgument, ScriptFunctionArgumentTypes, ScriptPayloadResponse, ScriptTransactionArgumentVariants, ScriptWriteSet, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, SimpleEntryFunctionArgumentTypes, SingleSignerTransaction, StateCheckpointTransactionResponse, StructTag, TableItemRequest, TokenStandard, TokenStandardArg, TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionAuthenticatorVariant, TransactionEd25519Signature, TransactionFeePayerSignature, TransactionMultiAgentSignature, TransactionMultiEd25519Signature, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultisig, TransactionPayloadResponse, TransactionPayloadScript, TransactionPayloadVariants, TransactionResponse, TransactionResponseType, TransactionSecp256k1Signature, TransactionSignature, TransactionVariants, TransactionWorker, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVariants, TypeTagVector, U128, U16, U256, U32, U64, U8, Uint128, Uint16, Uint256, Uint32, Uint64, Uint8, UserTransactionResponse, ViewRequest, WaitForTransactionOptions, WhereArg, WriteSet, WriteSetChange, WriteSetChangeDeleteModule, WriteSetChangeDeleteResource, WriteSetChangeDeleteTableItem, WriteSetChangeWriteModule, WriteSetChangeWriteResource, 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, mnemonicToSeed, objectStructTag, optionStructTag, outOfRangeErrorMessage, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, request, sign, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch, validateNumberInRange };