@aptos-labs/ts-sdk 1.13.2 → 1.13.3-zeta.1

package/dist/common/index.d.ts

@@ -3,6 +3,8 @@ import EventEmitter from 'eventemitter3';
 declare const NetworkToIndexerAPI: Record<string, string>;
 declare const NetworkToNodeAPI: Record<string, string>;
 declare const NetworkToFaucetAPI: Record<string, string>;
+declare const NetworkToPepperAPI: Record<string, string>;
+declare const NetworkToProverAPI: Record<string, string>;
 declare enum Network {
     MAINNET = "mainnet",
     TESTNET = "testnet",
@@ -867,11 +869,23 @@ declare enum AccountAuthenticatorVariant {
 }
 declare enum AnyPublicKeyVariant {
     Ed25519 = 0,
-    Secp256k1 = 1
+    Secp256k1 = 1,
+    Keyless = 3
 }
 declare enum AnySignatureVariant {
     Ed25519 = 0,
-    Secp256k1 = 1
+    Secp256k1 = 1,
+    Keyless = 3
+}
+declare enum EphemeralPublicKeyVariant {
+    Ed25519 = 0
+}
+declare enum EphemeralSignatureVariant {
+    Ed25519 = 0
+}
+declare enum EphemeralCertificate {
+    ZkProof = 0,
+    OpenIdSignature = 1
 }
 /**
  * BCS types
@@ -893,6 +907,8 @@ type AptosSettings = {
     readonly fullnode?: string;
     readonly faucet?: string;
     readonly indexer?: string;
+    readonly pepper?: string;
+    readonly prover?: string;
     readonly clientConfig?: ClientConfig;
     readonly client?: Client;
     readonly fullnodeConfig?: FullNodeConfig;
@@ -2154,6 +2170,8 @@ declare class Serializer {
      * // `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`;
      */
     serializeVector<T extends Serializable>(values: Array<T>): void;
+    serializeOption<T extends Serializable>(value?: T): void;
+    serializeOptionStr(value?: string): void;
 }
 declare function ensureBoolean(value: unknown): asserts value is boolean;
 declare const outOfRangeErrorMessage: (value: AnyNumber, min: AnyNumber, max: AnyNumber) => string;
@@ -3046,16 +3064,6 @@ declare class Ed25519PrivateKey extends Serializable implements PrivateKey {
      * @param mnemonics the mnemonic seed phrase
      */
     static fromDerivationPath(path: string, mnemonics: string): Ed25519PrivateKey;
-    /**
-     * A private inner function so we can separate from the main fromDerivationPath() method
-     * to add tests to verify we create the keys correctly.
-     *
-     * @param path the BIP44 path
-     * @param seed the seed phrase created by the mnemonics
-     * @param offset the offset used for key derivation, defaults to 0x80000000
-     * @returns
-     */
-    private static fromDerivationPathInner;
     /**
      * Derive the Ed25519PublicKey for this private key.
      *
@@ -3123,6 +3131,7 @@ type DerivedKeys = {
  */
 declare const APTOS_HARDENED_REGEX: RegExp;
 declare const APTOS_BIP44_REGEX: RegExp;
+declare const APTOS_BIP44_DEFAULT_DERIVATION_PATH = "m/44'/637'/0'/0'/0'";
 /**
  * A list of supported key types and associated seeds
  */
@@ -3172,6 +3181,13 @@ declare const CKDPriv: ({ key, chainCode }: DerivedKeys, index: number) => Deriv
  * @param path
  */
 declare const splitPath: (path: string) => Array<string>;
+/**
+ * @param path the BIP44 path
+ * @param seed the seed phrase created by the mnemonics
+ * @param offset the offset used for key derivation, defaults to 0x80000000
+ * @returns
+ */
+declare function fromDerivationPath(path: string, hashSeed: HexInput, seed: Uint8Array, offset?: number): Uint8Array;
 /**
  * Normalizes the mnemonic by removing extra whitespace and making it lowercase
  * @param mnemonic the mnemonic seed phrase
@@ -3378,8 +3394,9 @@ declare class MultiKey extends AccountPublicKey {
     createBitmap(args: {
         bits: number[];
     }): Uint8Array;
+    getIndex(publicKey: PublicKey): number;
 }
-declare class MultiKeySignature extends Signature {
+declare class MultiSignature extends Signature {
     /**
      * Number of bytes in the bitmap representing who signed the transaction (32-bits)
      */
@@ -3431,7 +3448,266 @@ declare class MultiKeySignature extends Signature {
     }): Uint8Array;
     toUint8Array(): Uint8Array;
     serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MultiKeySignature;
+    static deserialize(deserializer: Deserializer): MultiSignature;
+}
+
+/**
+ * Represents ephemeral keys and signatures for Aptos Keyless accounts.
+ *
+ * TODO
+ */
+declare class EphemeralPublicKey extends PublicKey {
+    /**
+     * Reference to the inner public key
+     */
+    readonly publicKey: PublicKey;
+    readonly variant: EphemeralPublicKeyVariant;
+    constructor(publicKey: PublicKey);
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the public key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the public key
+     */
+    toString(): string;
+    /**
+     * Verifies a signed data with a public key
+     *
+     * @param args.message message
+     * @param args.signature The signature
+     * @returns true if the signature is valid
+     */
+    verifySignature(args: {
+        message: HexInput;
+        signature: EphemeralSignature;
+    }): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): EphemeralPublicKey;
+    static isPublicKey(publicKey: PublicKey): publicKey is EphemeralPublicKey;
+    isEd25519(): this is Ed25519PublicKey;
+}
+declare class EphemeralSignature extends Signature {
+    readonly signature: Signature;
+    constructor(signature: Signature);
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the public key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the public key
+     */
+    toString(): string;
+    static fromHex(hexInput: HexInput): EphemeralSignature;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): EphemeralSignature;
+}
+
+declare const EPK_HORIZON_SECS = 10000000;
+declare const MAX_AUD_VAL_BYTES = 120;
+declare const MAX_UID_KEY_BYTES = 30;
+declare const MAX_UID_VAL_BYTES = 330;
+declare const MAX_ISS_VAL_BYTES = 120;
+declare const MAX_EXTRA_FIELD_BYTES = 350;
+declare const MAX_JWT_HEADER_B64_BYTES = 300;
+declare const MAX_COMMITED_EPK_BYTES = 93;
+/**
+ * Represents the KeylessPublicKey public key
+ *
+ * KeylessPublicKey authentication key is represented in the SDK as `AnyPublicKey`.
+ */
+declare class KeylessPublicKey extends AccountPublicKey {
+    static readonly ADDRESS_SEED_LENGTH: number;
+    readonly iss: string;
+    readonly addressSeed: Uint8Array;
+    constructor(iss: string, addressSeed: HexInput);
+    authKey(): AuthenticationKey;
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the public key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the public key
+     */
+    toString(): string;
+    /**
+     * Verifies a signed data with a public key
+     *
+     * @param args.message message
+     * @param args.signature The signature
+     * @returns true if the signature is valid
+     */
+    verifySignature(args: {
+        message: HexInput;
+        signature: KeylessSignature;
+    }): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): KeylessPublicKey;
+    static load(deserializer: Deserializer): KeylessPublicKey;
+    static isPublicKey(publicKey: PublicKey): publicKey is KeylessPublicKey;
+    static create(args: {
+        iss: string;
+        uidKey: string;
+        uidVal: string;
+        aud: string;
+        pepper: HexInput;
+    }): KeylessPublicKey;
+}
+declare function computeAddressSeed(args: {
+    uidKey: string;
+    uidVal: string;
+    aud: string;
+    pepper: HexInput;
+}): Uint8Array;
+declare class OpenIdSignatureOrZkProof extends Signature {
+    readonly signature: Signature;
+    constructor(signature: Signature);
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the public key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the public key
+     */
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): OpenIdSignatureOrZkProof;
+}
+declare class Groth16Zkp extends Serializable {
+    a: Uint8Array;
+    b: Uint8Array;
+    c: Uint8Array;
+    constructor(args: {
+        a: HexInput;
+        b: HexInput;
+        c: HexInput;
+    });
+    toUint8Array(): Uint8Array;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Groth16Zkp;
+}
+declare class SignedGroth16Signature extends Signature {
+    readonly proof: Groth16Zkp;
+    readonly expHorizonSecs: bigint;
+    readonly extraField?: string;
+    readonly overrideAudVal?: string;
+    readonly trainingWheelsSignature?: EphemeralSignature;
+    constructor(args: {
+        proof: Groth16Zkp;
+        expHorizonSecs?: bigint;
+        extraField?: string;
+        overrideAudVal?: string;
+        trainingWheelsSignature?: EphemeralSignature;
+    });
+    /**
+     * Get the signature in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the signature
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the signature as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the signature
+     */
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): SignedGroth16Signature;
+    static load(deserializer: Deserializer): SignedGroth16Signature;
+}
+/**
+ * A OpenId signature which contains the private inputs to an OIDB proof.
+ */
+declare class OpenIdSignature extends Signature {
+    readonly jwtSignature: string;
+    readonly jwtPayloadJson: string;
+    readonly uidKey: string;
+    readonly epkBlinder: Uint8Array;
+    readonly pepper: Uint8Array;
+    readonly overrideAudValue?: string;
+    /**
+     * Create a new Signature instance from a Uint8Array or String.
+     *
+     * @param hexInput A HexInput (string or Uint8Array)
+     */
+    constructor(args: {
+        jwtSignature: string;
+        jwtPayloadJson: string;
+        uidKey?: string;
+        epkBlinder: Uint8Array;
+        pepper: Uint8Array;
+        overrideAudValue?: string;
+    });
+    /**
+     * Get the signature in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the signature
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the signature as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the signature
+     */
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): OpenIdSignature;
+    static load(deserializer: Deserializer): OpenIdSignature;
+    static isSignature(signature: Signature): signature is OpenIdSignature;
+}
+/**
+ * A signature of a message signed via OIDC that uses proofs or the jwt token to authenticate.
+ */
+declare class KeylessSignature extends Signature {
+    readonly openIdSignatureOrZkProof: OpenIdSignatureOrZkProof;
+    readonly jwtHeader: string;
+    readonly expiryDateSecs: bigint | number;
+    readonly ephemeralPublicKey: EphemeralPublicKey;
+    readonly ephemeralSignature: EphemeralSignature;
+    /**
+     * Create a new Signature instance from a Uint8Array or String.
+     *
+     * @param hexInput A HexInput (string or Uint8Array)
+     */
+    constructor(args: {
+        jwtHeader: string;
+        openIdSignatureOrZkProof: OpenIdSignatureOrZkProof;
+        expiryDateSecs: bigint | number;
+        ephemeralPublicKey: EphemeralPublicKey;
+        ephemeralSignature: EphemeralSignature;
+    });
+    /**
+     * Get the signature in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the signature
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the signature as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the signature
+     */
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): KeylessSignature;
+    static load(deserializer: Deserializer): KeylessSignature;
+    static isSignature(signature: Signature): signature is KeylessSignature;
 }
 
 /**
@@ -3624,370 +3900,58 @@ declare class AccountAuthenticatorSingleKey extends AccountAuthenticator {
  */
 declare class AccountAuthenticatorMultiKey extends AccountAuthenticator {
     readonly public_keys: MultiKey;
-    readonly signatures: Array<AnySignature>;
-    readonly signatures_bitmap: Uint8Array;
-    constructor(public_keys: MultiKey, signatures: Array<AnySignature>, signatures_bitmap: Uint8Array);
+    readonly signatures: MultiSignature;
+    constructor(public_keys: MultiKey, signatures: MultiSignature);
     serialize(serializer: Serializer): void;
     static load(deserializer: Deserializer): AccountAuthenticatorMultiKey;
 }
 
-interface SingleKeySignerConstructorArgs {
-    privateKey: PrivateKey;
-    address?: AccountAddressInput;
-}
-interface SingleKeySignerGenerateArgs {
-    scheme?: SigningSchemeInput;
-}
-type SingleKeySignerFromDerivationPathArgs = SingleKeySignerGenerateArgs & {
-    path: string;
-    mnemonic: string;
-};
-interface VerifySingleKeySignatureArgs {
-    message: HexInput;
-    signature: AnySignature;
-}
 /**
- * Signer implementation for the SingleKey authentication scheme.
- * This extends a SingleKeyAccount by adding signing capabilities through a valid private key.
- * Currently, the only supported signature schemes are Ed25519 and Secp256k1.
- *
- * Note: Generating a signer instance does not create the account on-chain.
+ * Type of API endpoint for request routing
  */
-declare class SingleKeyAccount implements Account$1 {
-    /**
-     * Private key associated with the account
-     */
-    readonly privateKey: PrivateKey;
-    readonly publicKey: AnyPublicKey;
-    readonly accountAddress: AccountAddress;
-    readonly signingScheme = SigningScheme.SingleKey;
-    constructor(args: SingleKeySignerConstructorArgs);
-    /**
-     * Derives an account from a randomly generated private key.
-     * Default generation is using an Ed25519 key
-     * @returns Account with the given signature scheme
-     */
-    static generate(args?: SingleKeySignerGenerateArgs): SingleKeyAccount;
-    /**
-     * Derives an account with bip44 path and mnemonics,
-     * Default to using an Ed25519 signature scheme.
-     *
-     * @param args.scheme The signature scheme to derive the private key with
-     * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
-     * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
-     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
-     * @param args.mnemonic the mnemonic seed phrase of the account
-     */
-    static fromDerivationPath(args: SingleKeySignerFromDerivationPathArgs): SingleKeyAccount;
-    verifySignature(args: VerifySingleKeySignatureArgs): boolean;
-    signWithAuthenticator(message: HexInput): AccountAuthenticatorSingleKey;
-    sign(message: HexInput): AnySignature;
+declare enum AptosApiType {
+    FULLNODE = "Fullnode",
+    INDEXER = "Indexer",
+    FAUCET = "Faucet",
+    PEPPER = "Pepper",
+    PROVER = "Prover"
 }
-
 /**
- * Arguments for creating an `Ed25519Account` from an `Ed25519PrivateKey`.
- * This is the default input type when passing an `Ed25519PrivateKey`.
- * In order to use the SingleKey authentication scheme, `legacy` needs to be explicitly set to false.
+ * 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.
  */
-interface CreateEd25519AccountFromPrivateKeyArgs {
-    privateKey: Ed25519PrivateKey;
-    address?: AccountAddressInput;
-    legacy?: true;
-}
+declare const DEFAULT_MAX_GAS_AMOUNT = 200000;
 /**
- * Arguments for creating an `SingleKeyAccount` from an `Ed25519PrivateKey`.
- * The `legacy` argument needs to be explicitly set to false in order to
- * use the `SingleKey` authentication scheme.
+ * 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.
  */
-interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs {
-    privateKey: Ed25519PrivateKey;
-    address?: AccountAddressInput;
-    legacy: false;
-}
+declare const DEFAULT_TXN_EXP_SEC_FROM_NOW = 20;
 /**
- * Arguments for creating an `SingleKeyAccount` from any supported private key
- * that is not an `Ed25519PrivateKey`.
- * The `legacy` argument defaults to false and cannot be explicitly set to true.
+ * 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.
  */
-interface CreateSingleKeyAccountFromPrivateKeyArgs {
-    privateKey: Exclude<PrivateKey, Ed25519PrivateKey>;
-    address?: AccountAddressInput;
-    legacy?: false;
-}
+declare const DEFAULT_TXN_TIMEOUT_SEC = 20;
 /**
- * Arguments for creating an opaque `Account` from any supported private key.
- * This is used when the private key type is not known at compilation time.
+ * The default gas currency for the network.
  */
-interface CreateAccountFromPrivateKeyArgs {
-    privateKey: PrivateKey;
-    address?: AccountAddressInput;
-    legacy?: boolean;
-}
+declare const APTOS_COIN = "0x1::aptos_coin::AptosCoin";
+declare const RAW_TRANSACTION_SALT = "APTOS::RawTransaction";
+declare const RAW_TRANSACTION_WITH_DATA_SALT = "APTOS::RawTransactionWithData";
 /**
- * Arguments for generating an `Ed25519Account`.
- * This is the input type used by default.
- */
-interface GenerateEd25519AccountArgs {
-    scheme?: SigningSchemeInput.Ed25519;
-    legacy?: true;
-}
-/**
- * Arguments for generating an `SingleKeyAccount` with ah underlying `Ed25519PrivateKey`.
- * The `legacy` argument needs to be explicitly set to false,
- * otherwise an `Ed25519Account` will be returned instead.
- */
-interface GenerateEd25519SingleKeyAccountArgs {
-    scheme?: SigningSchemeInput.Ed25519;
-    legacy: false;
-}
-/**
- * Arguments for generating an `SingleKeyAccount` with any supported private key
- * that is not an `Ed25519PrivateKey`.
- * The `legacy` argument defaults to false and cannot be explicitly set to true.
- */
-interface GenerateSingleKeyAccountArgs {
-    scheme: Exclude<SigningSchemeInput, SigningSchemeInput.Ed25519>;
-    legacy?: false;
-}
-/**
- * Arguments for generating an opaque `Account`.
- * This is used when the input signature scheme is not known at compilation time.
- */
-interface GenerateAccountArgs {
-    scheme?: SigningSchemeInput;
-    legacy?: boolean;
-}
-/**
- * Arguments for deriving a private key from a mnemonic phrase and a BIP44 path.
- */
-interface PrivateKeyFromDerivationPathArgs {
-    path: string;
-    mnemonic: string;
-}
-/**
- * Interface for a generic Aptos account.
- *
- * The interface is defined as abstract class to provide a single entrypoint for account generation,
- * either through `Account.generate()` or `Account.fromDerivationPath`.
- * Despite this being an abstract class, it should be treated as an interface and enforced using
- * the `implements` keyword.
- *
- * Note: Generating an account instance does not create the account on-chain.
- */
-declare abstract class Account$1 {
-    /**
-     * Private key associated with the account.
-     * Note: this will be removed in the next major release,
-     *  as not all accounts have a private key.
-     */
-    abstract readonly privateKey: PrivateKey;
-    /**
-     * Public key associated with the account
-     */
-    abstract readonly publicKey: AccountPublicKey;
-    /**
-     * Account address associated with the account
-     */
-    abstract readonly accountAddress: AccountAddress;
-    /**
-     * Signing scheme used to sign transactions
-     */
-    abstract signingScheme: SigningScheme;
-    /**
-     * Derives an account from a randomly generated private key.
-     * @param args.scheme The signature scheme to use, to generate the private key
-     * @param args.legacy Whether to use a legacy authentication scheme, when applicable
-     * @returns An account compatible with the provided signature scheme
-     */
-    static generate(args?: GenerateEd25519AccountArgs): Ed25519Account;
-    static generate(args: GenerateEd25519SingleKeyAccountArgs): SingleKeyAccount;
-    static generate(args: GenerateSingleKeyAccountArgs): SingleKeyAccount;
-    static generate(args: GenerateAccountArgs): Account$1;
-    /**
-     * Creates an account from the provided private key.
-     *
-     * @param args.privateKey a valid private key
-     * @param args.address the account's address. If not provided, it will be derived from the public key.
-     * @param args.legacy Whether to use a legacy authentication scheme, when applicable
-     */
-    static fromPrivateKey(args: CreateEd25519AccountFromPrivateKeyArgs): Ed25519Account;
-    static fromPrivateKey(args: CreateEd25519SingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
-    static fromPrivateKey(args: CreateSingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
-    static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs): Account$1;
-    /**
-     * @deprecated use `fromPrivateKey` instead.
-     * Instantiates an account given a private key and a specified account address.
-     * This is primarily used to instantiate an `Account` that has had its authentication key rotated.
-     *
-     * @param args.privateKey PrivateKey - the underlying private key for the account
-     * @param args.address AccountAddress - The account address the `Account` will sign for
-     * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
-     * to generating a Legacy Ed25519 keypair
-     *
-     * @returns Account
-     */
-    static fromPrivateKeyAndAddress(args: CreateAccountFromPrivateKeyArgs): Account$1;
-    /**
-     * Derives an account with bip44 path and mnemonics
-     *
-     * @param args.scheme The signature scheme to derive the private key with
-     * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
-     * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
-     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
-     * @param args.mnemonic the mnemonic seed phrase of the account
-     */
-    static fromDerivationPath(args: GenerateEd25519AccountArgs & PrivateKeyFromDerivationPathArgs): Ed25519Account;
-    static fromDerivationPath(args: GenerateEd25519SingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;
-    static fromDerivationPath(args: GenerateSingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;
-    static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs): Account$1;
-    /**
-     * @deprecated use `publicKey.authKey()` instead.
-     * This key enables account owners to rotate their private key(s)
-     * associated with the account without changing the address that hosts their account.
-     * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}
-     *
-     * @param args.publicKey PublicKey - public key of the account
-     * @returns The authentication key for the associated account
-     */
-    static authKey(args: {
-        publicKey: AccountPublicKey;
-    }): AuthenticationKey;
-    /**
-     * Sign a message using the available signing capabilities.
-     * @param message the signing message, as binary input
-     * @return the AccountAuthenticator containing the signature, together with the account's public key
-     */
-    abstract signWithAuthenticator(message: HexInput): AccountAuthenticator;
-    /**
-     * Sign the given message with the private key.
-     * @param message in HexInput format
-     * @returns AccountSignature
-     */
-    abstract sign(message: HexInput): Signature;
-    /**
-     * @param args.message raw message data in HexInput format
-     * @param args.signature signed message signature
-     */
-    verifySignature(args: VerifySignatureArgs): boolean;
-}
-
-interface Ed25519SignerConstructorArgs {
-    privateKey: Ed25519PrivateKey;
-    address?: AccountAddressInput;
-}
-interface Ed25519SignerFromDerivationPathArgs {
-    path: string;
-    mnemonic: string;
-}
-interface VerifyEd25519SignatureArgs {
-    message: HexInput;
-    signature: Ed25519Signature;
-}
-/**
- * Signer implementation for the Ed25519 authentication scheme.
- * This extends an {@link Ed25519Account} by adding signing capabilities through an {@link Ed25519PrivateKey}.
- *
- * Note: Generating a signer instance does not create the account on-chain.
- */
-declare class Ed25519Account implements Account$1 {
-    /**
-     * Private key associated with the account
-     */
-    readonly privateKey: Ed25519PrivateKey;
-    readonly publicKey: Ed25519PublicKey;
-    readonly accountAddress: AccountAddress;
-    readonly signingScheme = SigningScheme.Ed25519;
-    constructor(args: Ed25519SignerConstructorArgs);
-    /**
-     * Derives a signer from a randomly generated private key
-     */
-    static generate(): Ed25519Account;
-    /**
-     * Derives an account with bip44 path and mnemonics
-     *
-     * @param args.path the BIP44 derive hardened path e.g. m/44'/637'/0'/0'/0'
-     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
-     * @param args.mnemonic the mnemonic seed phrase of the account
-     */
-    static fromDerivationPath(args: Ed25519SignerFromDerivationPathArgs): Ed25519Account;
-    verifySignature(args: VerifyEd25519SignatureArgs): boolean;
-    signWithAuthenticator(message: HexInput): AccountAuthenticatorEd25519;
-    sign(message: HexInput): Ed25519Signature;
-}
-
-/**
- * Creates an object address from creator address and seed
- *
- * @param creatorAddress The object creator account address
- * @param seed The seed in either Uint8Array | string type
- *
- * @returns The object account address
- */
-declare const createObjectAddress: (creatorAddress: AccountAddress, seed: Uint8Array | string) => AccountAddress;
-/**
- * Creates an resource address from creator address and seed
- *
- * @param creatorAddress The creator account address
- * @param seed The seed in either Uint8Array | string type
- *
- * @returns The resource account address
- */
-declare const createResourceAddress: (creatorAddress: AccountAddress, seed: Uint8Array | string) => AccountAddress;
-/**
- * Creates a token object address from creator address, collection name and token name
- *
- * @param creatorAddress The token creator account address
- * @param collectionName The collection name
- * @param tokenName The token name
- *
- * @returns The token account address
- */
-declare const createTokenAddress: (creatorAddress: AccountAddress, collectionName: string, tokenName: string) => AccountAddress;
-
-/**
- * Type of API endpoint for request routing
- */
-declare enum AptosApiType {
-    FULLNODE = "Fullnode",
-    INDEXER = "Indexer",
-    FAUCET = "Faucet"
-}
-/**
- * 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://api.mainnet.aptoslabs.com/v1/graphql}
+ * 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://api.mainnet.aptoslabs.com/v1/graphql}
  */
 declare enum ProcessorType {
     ACCOUNT_TRANSACTION_PROCESSOR = "account_transactions_processor",
@@ -4023,6 +3987,14 @@ declare class AptosConfig {
      * The optional hardcoded faucet URL to send requests to instead of using the network
      */
     readonly faucet?: string;
+    /**
+     * The optional hardcoded pepper service URL to send requests to instead of using the network
+     */
+    readonly pepper?: string;
+    /**
+     * The optional hardcoded prover service URL to send requests to instead of using the network
+     */
+    readonly prover?: string;
     /**
      * The optional hardcoded indexer URL to send requests to instead of using the network
      */
@@ -4055,1156 +4027,1607 @@ declare class AptosConfig {
      * @internal
      */
     getRequestUrl(apiType: AptosApiType): string;
+    /**
+     * Checks if the URL is a known pepper service endpoint
+     *
+     * @internal
+     * */
+    isPepperServiceRequest(url: string): boolean;
+    /**
+     * Checks if the URL is a known prover service endpoint
+     *
+     * @internal
+     * */
+    isProverServiceRequest(url: string): boolean;
 }
 
 /**
- * A class to query all `Account` related queries on Aptos.
+ * Representation of a ChainId that can serialized and deserialized
  */
-declare class Account {
-    readonly config: AptosConfig;
-    constructor(config: AptosConfig);
-    /**
-     * Queries the current state for an Aptos account given its account address
-     *
-     * @param args.accountAddress Aptos account address
-     *
-     * @returns The account data
-     *
-     * @example An example of the returned account
-     * ```
-     * {
-     *    sequence_number: "1",
-     *    authentication_key: "0x5307b5f4bc67829097a8ba9b43dba3b88261eeccd1f709d9bde240fc100fbb69"
-     * }
-     * ```
+declare class ChainId extends Serializable {
+    readonly chainId: number;
+    constructor(chainId: number);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): ChainId;
+}
+
+/**
+ * Representation of an Identifier that can serialized and deserialized.
+ * We use Identifier to represent the module "name" in "ModuleId" and
+ * the "function name" in "EntryFunction"
+ */
+declare class Identifier extends Serializable {
+    identifier: string;
+    constructor(identifier: string);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Identifier;
+}
+
+/**
+ * Representation of a ModuleId that can serialized and deserialized
+ * ModuleId means the module address (e.g "0x1") and the module name (e.g "coin")
+ */
+declare class ModuleId extends Serializable {
+    readonly address: AccountAddress;
+    readonly name: Identifier;
+    /**
+     * Full name of a module.
+     * @param address The account address. e.g "0x1"
+     * @param name The module name under the "address". e.g "coin"
      */
-    getAccountInfo(args: {
-        accountAddress: AccountAddressInput;
-    }): Promise<AccountData>;
+    constructor(address: AccountAddress, name: Identifier);
     /**
-     * Queries for all modules in an account given an account address
-     *
-     * Note: In order to get all account modules, this function may call the API
-     * multiple times as it auto paginates.
-     *
-     * @param args.accountAddress Aptos account address
-     * @param args.options.offset The number module to start returning results from
-     * @param args.options.limit The number of results to return
-     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
-     *
-     * @returns Account modules
+     * Converts a string literal to a ModuleId
+     * @param moduleId String literal in format "account_address::module_name", e.g. "0x1::coin"
+     * @returns ModuleId
      */
-    getAccountModules(args: {
-        accountAddress: AccountAddressInput;
-        options?: PaginationArgs & LedgerVersionArg;
-    }): Promise<MoveModuleBytecode[]>;
+    static fromStr(moduleId: MoveModuleId): ModuleId;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): ModuleId;
+}
+
+declare abstract class TypeTag extends Serializable {
+    abstract serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): TypeTag;
+    abstract toString(): string;
+    isBool(): this is TypeTagBool;
+    isAddress(): this is TypeTagAddress;
+    isGeneric(): this is TypeTagGeneric;
+    isSigner(): this is TypeTagSigner;
+    isVector(): this is TypeTagVector;
+    isStruct(): this is TypeTagStruct;
+    isU8(): this is TypeTagU8;
+    isU16(): this is TypeTagU16;
+    isU32(): this is TypeTagU32;
+    isU64(): this is TypeTagU64;
+    isU128(): this is TypeTagU128;
+    isU256(): this is TypeTagU256;
+}
+declare class TypeTagBool extends TypeTag {
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static load(_deserializer: Deserializer): TypeTagBool;
+}
+declare class TypeTagU8 extends TypeTag {
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static load(_deserializer: Deserializer): TypeTagU8;
+}
+declare class TypeTagU16 extends TypeTag {
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static load(_deserializer: Deserializer): TypeTagU16;
+}
+declare class TypeTagU32 extends TypeTag {
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static load(_deserializer: Deserializer): TypeTagU32;
+}
+declare class TypeTagU64 extends TypeTag {
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static load(_deserializer: Deserializer): TypeTagU64;
+}
+declare class TypeTagU128 extends TypeTag {
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static load(_deserializer: Deserializer): TypeTagU128;
+}
+declare class TypeTagU256 extends TypeTag {
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static load(_deserializer: Deserializer): TypeTagU256;
+}
+declare class TypeTagAddress extends TypeTag {
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static load(_deserializer: Deserializer): TypeTagAddress;
+}
+declare class TypeTagSigner extends TypeTag {
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static load(_deserializer: Deserializer): TypeTagSigner;
+}
+declare class TypeTagReference extends TypeTag {
+    readonly value: TypeTag;
+    toString(): `&${string}`;
+    constructor(value: TypeTag);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TypeTagReference;
+}
+/**
+ * Generics are used for type parameters in entry functions.  However,
+ * they are not actually serialized into a real type, so they cannot be
+ * used as a type directly.
+ */
+declare class TypeTagGeneric extends TypeTag {
+    readonly value: number;
+    toString(): `T${number}`;
+    constructor(value: number);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TypeTagGeneric;
+}
+declare class TypeTagVector extends TypeTag {
+    readonly value: TypeTag;
+    toString(): `vector<${string}>`;
+    constructor(value: TypeTag);
+    static u8(): TypeTagVector;
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TypeTagVector;
+}
+declare class TypeTagStruct extends TypeTag {
+    readonly value: StructTag;
+    toString(): `0x${string}::${string}::${string}`;
+    constructor(value: StructTag);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TypeTagStruct;
+    isTypeTag(address: AccountAddress, moduleName: string, structName: string): boolean;
+    isString(): boolean;
+    isOption(): boolean;
+    isObject(): boolean;
+}
+declare class StructTag extends Serializable {
+    readonly address: AccountAddress;
+    readonly moduleName: Identifier;
+    readonly name: Identifier;
+    readonly typeArgs: Array<TypeTag>;
+    constructor(address: AccountAddress, module_name: Identifier, name: Identifier, type_args: Array<TypeTag>);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): StructTag;
+}
+declare function aptosCoinStructTag(): StructTag;
+declare function stringStructTag(): StructTag;
+declare function optionStructTag(typeArg: TypeTag): StructTag;
+declare function objectStructTag(typeArg: TypeTag): StructTag;
+
+/**
+ * Deserialize a Script Transaction Argument
+ */
+declare function deserializeFromScriptArgument(deserializer: Deserializer): TransactionArgument;
+/**
+ * Representation of the supported Transaction Payload
+ * that can serialized and deserialized
+ */
+declare abstract class TransactionPayload extends Serializable {
     /**
-     * Queries for a specific account module given account address and module name
-     *
-     * @param args.accountAddress Aptos account address
-     * @param args.moduleName The name of the module
-     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+     * Serialize a Transaction Payload
+     */
+    abstract serialize(serializer: Serializer): void;
+    /**
+     * Deserialize a Transaction Payload
+     */
+    static deserialize(deserializer: Deserializer): TransactionPayload;
+}
+/**
+ * Representation of a Transaction Payload Script that can serialized and deserialized
+ */
+declare class TransactionPayloadScript extends TransactionPayload {
+    readonly script: Script;
+    constructor(script: Script);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionPayloadScript;
+}
+/**
+ * Representation of a Transaction Payload Entry Function that can serialized and deserialized
+ */
+declare class TransactionPayloadEntryFunction extends TransactionPayload {
+    readonly entryFunction: EntryFunction;
+    constructor(entryFunction: EntryFunction);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionPayloadEntryFunction;
+}
+/**
+ * Representation of a Transaction Payload Multi-sig that can serialized and deserialized
+ */
+declare class TransactionPayloadMultiSig extends TransactionPayload {
+    readonly multiSig: MultiSig;
+    constructor(multiSig: MultiSig);
+    serialize(serializer: Serializer): void;
+    static load(deserializer: Deserializer): TransactionPayloadMultiSig;
+}
+/**
+ * Representation of a EntryFunction that can serialized and deserialized
+ */
+declare class EntryFunction {
+    readonly module_name: ModuleId;
+    readonly function_name: Identifier;
+    readonly type_args: Array<TypeTag>;
+    readonly args: Array<EntryFunctionArgument>;
+    /**
+     * Contains the payload to run a function within a module.
+     * @param module_name Fully qualified module name in format "account_address::module_name" e.g. "0x1::coin"
+     * @param function_name The function name. e.g "transfer"
+     * @param type_args Type arguments that move function requires.
      *
-     * @returns Account module
+     * @example
+     * A coin transfer function has one type argument "CoinType".
+     * ```
+     * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
+     * ```
+     * @param args arguments to the move function.
      *
      * @example
-     * const module = await aptos.getAccountModule({accountAddress:"0x456"})
-     * // An example of an account module response
+     * A coin transfer function has three arguments "from", "to" and "amount".
      * ```
-     * {
-     *    bytecode: "0xa11ceb0b0600000006010002030206050807070f0d081c200",
-     *    abi: { address: "0x1" }
-     * }
+     * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
      * ```
      */
-    getAccountModule(args: {
-        accountAddress: AccountAddressInput;
-        moduleName: string;
-        options?: LedgerVersionArg;
-    }): Promise<MoveModuleBytecode>;
+    constructor(module_name: ModuleId, function_name: Identifier, type_args: Array<TypeTag>, args: Array<EntryFunctionArgument>);
     /**
-     * Queries account transactions given an account address
+     * A helper function to build a EntryFunction payload from raw primitive values
      *
-     * Note: In order to get all account transactions, this function may call the API
-     * multiple times as it auto paginates.
+     * @param module_id Fully qualified module name in format "AccountAddress::module_id" e.g. "0x1::coin"
+     * @param function_name Function name
+     * @param type_args Type arguments that move function requires.
      *
      * @example
-     * const transactions = await aptos.getAccountTransactions({accountAddress:"0x456"})
-     *
-     * @param args.accountAddress Aptos account address
-     * @param args.options.offset The number transaction to start returning results from
-     * @param args.options.limit The number of results to return
-     *
-     * @returns The account transactions
-     */
-    getAccountTransactions(args: {
-        accountAddress: AccountAddressInput;
-        options?: PaginationArgs;
-    }): Promise<TransactionResponse[]>;
-    /**
-     * Queries all account resources given an account address
-     *
-     * Note: In order to get all account resources, this function may call the API
-     * multiple times as it auto paginates.
+     * A coin transfer function has one type argument "CoinType".
+     * ```
+     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
+     * ```
+     * @param args Arguments to the move function.
      *
      * @example
-     * const resources = await aptos.getAccountResources({accountAddress:"0x456"})
-     *
-     * @param args.accountAddress Aptos account address
-     * @param args.options.offset The number resource to start returning results from
-     * @param args.options.limit The number of results to return
-     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
-     * @returns Account resources
+     * A coin transfer function has three arguments "from", "to" and "amount".
+     * ```
+     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
+     * ```
+     * @returns EntryFunction
      */
-    getAccountResources(args: {
-        accountAddress: AccountAddressInput;
-        options?: PaginationArgs & LedgerVersionArg;
-    }): Promise<MoveResource[]>;
+    static build(module_id: MoveModuleId, function_name: string, type_args: Array<TypeTag>, args: Array<EntryFunctionArgument>): EntryFunction;
+    serialize(serializer: Serializer): void;
     /**
-     * Queries a specific account resource given account address and resource type. Note that the default is `any` in order
-     * to allow for ease of accessing properties of the object.
-     *
-     * @type The typed output of the resource
-     * @param args.accountAddress Aptos account address
-     * @param args.resourceType String representation of an on-chain Move struct type, i.e "0x1::aptos_coin::AptosCoin"
-     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
-     *
-     * @returns Account resource
+     * Deserializes an entry function payload with the arguments represented as EntryFunctionBytes instances.
+     * @see EntryFunctionBytes
      *
-     * @example
-     * const resource = await aptos.getAccountResource({accountAddress:"0x456"})
+     * NOTE: When you deserialize an EntryFunction payload with this method, the entry function
+     * arguments are populated into the deserialized instance as type-agnostic, raw fixed bytes
+     * in the form of the EntryFunctionBytes class.
      *
-     */
-    getAccountResource<T extends {} = any>(args: {
-        accountAddress: AccountAddressInput;
-        resourceType: MoveStructId;
-        options?: LedgerVersionArg;
-    }): Promise<T>;
-    /**
-     * Looks up the account address for a given authentication key
+     * In order to correctly deserialize these arguments as their actual type representations, you
+     * must know the types of the arguments beforehand and deserialize them yourself individually.
      *
-     * This handles both if the account's authentication key has been rotated or not.
+     * One way you could achieve this is by using the ABIs for an entry function and deserializing each
+     * argument as its given, corresponding type.
      *
-     * @example
-     * const accountAddress = await aptos.lookupOriginalAccountAddress({authenticationKey:account.accountAddress})
+     * @param deserializer
+     * @returns A deserialized EntryFunction payload for a transaction.
      *
-     * @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;
-        minimumLedgerVersion?: AnyNumber;
-        options?: LedgerVersionArg;
-    }): Promise<AccountAddress>;
+    static deserialize(deserializer: Deserializer): EntryFunction;
+}
+/**
+ * Representation of a Script that can serialized and deserialized
+ */
+declare class Script {
     /**
-     * Queries the current count of tokens owned by an account
-     *
-     * @example
-     * const tokensCount = await aptos.getAccountTokensCount({accountAddress:"0x456"})
-     *
-     * @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
+     * The move module bytecode
      */
-    getAccountTokensCount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
+    readonly bytecode: Uint8Array;
     /**
-     * Queries the account's current owned tokens.
-     *
-     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
-     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
-     *
-     * @example
-     * const accountOwnedTokens = await aptos.getAccountOwnedTokens({accountAddress:"0x456"})
-     *
-     * @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.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
+     * The type arguments that the bytecode function requires.
      */
-    getAccountOwnedTokens(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;
-    }): Promise<GetAccountOwnedTokensQueryResponse>;
+    readonly type_args: Array<TypeTag>;
     /**
-     * Queries all current tokens of a specific collection that an account owns by the collection address
-     *
-     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
-     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
-     *
-     * @example
-     * const accountOwnedTokens = await aptos.getAccountOwnedTokensFromCollectionAddress({accountAddress:"0x123", collectionAddress:"0x456"})
-     *
-     * @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.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
+     * The arguments that the bytecode function requires.
      */
-    getAccountOwnedTokensFromCollectionAddress(args: {
-        accountAddress: AccountAddressInput;
-        collectionAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;
-    }): Promise<GetAccountOwnedTokensFromCollectionResponse>;
+    readonly args: Array<ScriptFunctionArgument>;
     /**
-     * Queries for all collections that an account currently has tokens for.
+     * Scripts contain the Move bytecodes payload that can be submitted to Aptos chain for execution.
      *
-     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
-     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
+     * @param bytecode The move module bytecode
+     * @param type_args The type arguments that the bytecode function requires.
      *
      * @example
-     * const accountCollectionsWithOwnedTokens = await aptos.getAccountCollectionsWithOwnedTokens({accountAddress:"0x123"})
-     *
-     * @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.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;
-        minimumLedgerVersion?: AnyNumber;
-        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;
-    }): Promise<GetAccountCollectionsWithOwnedTokenResponse>;
-    /**
-     * Queries the current count of transactions submitted by an account
+     * A coin transfer function has one type argument "CoinType".
+     * ```
+     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
+     * ```
+     * @param args The arguments that the bytecode function requires.
      *
      * @example
-     * const accountTransactionsCount = await aptos.getAccountTransactionsCount({accountAddress:"0x123"})
-     *
-     * @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
+     * A coin transfer function has three arguments "from", "to" and "amount".
+     * ```
+     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
+     * ```
      */
-    getAccountTransactionsCount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
+    constructor(bytecode: Uint8Array, type_args: Array<TypeTag>, args: Array<ScriptFunctionArgument>);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Script;
+}
+/**
+ * Representation of a MultiSig that can serialized and deserialized
+ */
+declare class MultiSig {
+    readonly multisig_address: AccountAddress;
+    readonly transaction_payload?: MultiSigTransactionPayload;
     /**
-     * Queries an account's coins data
+     * Contains the payload to run a multi-sig account transaction.
      *
-     * @example
-     * const accountCoinsData = await aptos.getAccountCoinsData({accountAddress:"0x123"})
+     * @param multisig_address The multi-sig account address the transaction will be executed as.
      *
-     * @param args.accountAddress The account address we want to get the coins data for
-     * @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
+     * @param transaction_payload The payload of the multi-sig transaction. This is optional when executing a multi-sig
+     *  transaction whose payload is already stored on chain.
      */
-    getAccountCoinsData(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetAccountCoinsDataResponse[0]> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
-    }): Promise<GetAccountCoinsDataResponse>;
+    constructor(multisig_address: AccountAddress, transaction_payload?: MultiSigTransactionPayload);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MultiSig;
+}
+/**
+ * Representation of a MultiSig Transaction Payload from `multisig_account.move`
+ * that can be serialized and deserialized
+
+ * This class exists right now to represent an extensible transaction payload class for
+ * transactions used in `multisig_account.move`. Eventually, this class will be able to
+ * support script payloads when the `multisig_account.move` module supports them.
+ */
+declare class MultiSigTransactionPayload extends Serializable {
+    readonly transaction_payload: EntryFunction;
     /**
-     * Queries the current count of an account's coins aggregated
-     *
-     * @example
-     * const accountCoinsCount = await aptos.getAccountCoinsCount({accountAddress:"0x123"})
+     * Contains the payload to run a multi-sig account transaction.
      *
-     * @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
+     * @param transaction_payload The payload of the multi-sig transaction.
+     * This can only be EntryFunction for now but,
+     * Script might be supported in the future.
      */
-    getAccountCoinsCount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
-    /**
-     * Queries the account's APT amount
-     *
-     * @example
-     * const accountAPTAmount = await aptos.getAccountAPTAmount({accountAddress:"0x123"})
-     *
-     * @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
-     */
-    getAccountAPTAmount(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
+    constructor(transaction_payload: EntryFunction);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MultiSigTransactionPayload;
+}
+
+/**
+ * Representation of a Raw Transaction that can serialized and deserialized
+ */
+declare class RawTransaction extends Serializable {
+    readonly sender: AccountAddress;
+    readonly sequence_number: bigint;
+    readonly payload: TransactionPayload;
+    readonly max_gas_amount: bigint;
+    readonly gas_unit_price: bigint;
+    readonly expiration_timestamp_secs: bigint;
+    readonly chain_id: ChainId;
     /**
-     * Queries the account's coin amount by the coin type
-     *
-     * @example
-     * const accountCoinAmount = await aptos.getAccountCoinAmount({accountAddress:"0x123", coinType:"0x1::aptos_coin::AptosCoin"})
+     * RawTransactions contain the metadata and payloads that can be submitted to Aptos chain for execution.
+     * RawTransactions must be signed before Aptos chain can execute them.
      *
-     * @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
+     * @param sender The sender Account Address
+     * @param sequence_number Sequence number of this transaction. This must match the sequence number stored in
+     *   the sender's account at the time the transaction executes.
+     * @param payload Instructions for the Aptos Blockchain, including publishing a module,
+     *   execute an entry function or execute a script payload.
+     * @param max_gas_amount Maximum total gas to spend for this transaction. The account must have more
+     *   than this gas or the transaction will be discarded during validation.
+     * @param gas_unit_price Price to be paid per gas unit.
+     * @param expiration_timestamp_secs The blockchain timestamp at which the blockchain would discard this transaction.
+     * @param chain_id The chain ID of the blockchain that this transaction is intended to be run on.
      */
-    getAccountCoinAmount(args: {
-        accountAddress: AccountAddressInput;
-        coinType: MoveStructId;
-        minimumLedgerVersion?: AnyNumber;
-    }): Promise<number>;
+    constructor(sender: AccountAddress, sequence_number: bigint, payload: TransactionPayload, max_gas_amount: bigint, gas_unit_price: bigint, expiration_timestamp_secs: bigint, chain_id: ChainId);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): RawTransaction;
+}
+/**
+ * Representation of a Raw Transaction With Data that can serialized and deserialized
+ */
+declare abstract class RawTransactionWithData extends Serializable {
     /**
-     * Queries an account's owned objects
-     *
-     * @example
-     * const accountOwnedObjects = await aptos.getAccountOwnedObjects({accountAddress:"0x123"})
-     *
-     * @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
+     * Serialize a Raw Transaction With Data
      */
-    getAccountOwnedObjects(args: {
-        accountAddress: AccountAddressInput;
-        minimumLedgerVersion?: AnyNumber;
-        options?: PaginationArgs & OrderByArg<GetAccountOwnedObjectsResponse[0]>;
-    }): Promise<GetAccountOwnedObjectsResponse>;
+    abstract serialize(serializer: Serializer): void;
     /**
-     * Derives an account by providing a private key.
-     * This functions resolves the provided private key type and derives the public key from it.
-     *
-     * If the privateKey is a Secp256k1 type, it derives the account using the derived public key and
-     * auth key using the SingleKey scheme locally.
-     *
-     * If the privateKey is a ED25519 type, it looks up the authentication key on chain, and uses it to resolve
-     * whether it is a Legacy ED25519 key or a Unified ED25519 key. It then derives the account based
-     * on that.
-     *
-     * @example
-     * const account = await aptos.deriveAccountFromPrivateKey({privateKey:new Ed25519PrivateKey("0x123")})
-     *
-     * @param args.privateKey An account private key
-     * @returns Account type
+     * Deserialize a Raw Transaction With Data
      */
-    deriveAccountFromPrivateKey(args: {
-        privateKey: PrivateKey;
-    }): Promise<Account$1>;
-}
-
-/**
- * Representation of a ChainId that can serialized and deserialized
- */
-declare class ChainId extends Serializable {
-    readonly chainId: number;
-    constructor(chainId: number);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): ChainId;
+    static deserialize(deserializer: Deserializer): RawTransactionWithData;
 }
-
 /**
- * Representation of an Identifier that can serialized and deserialized.
- * We use Identifier to represent the module "name" in "ModuleId" and
- * the "function name" in "EntryFunction"
+ * Representation of a Multi Agent Transaction that can serialized and deserialized
  */
-declare class Identifier extends Serializable {
-    identifier: string;
-    constructor(identifier: string);
+declare class MultiAgentRawTransaction extends RawTransactionWithData {
+    /**
+     * The raw transaction
+     */
+    readonly raw_txn: RawTransaction;
+    /**
+     * The secondary signers on this transaction
+     */
+    readonly secondary_signer_addresses: Array<AccountAddress>;
+    constructor(raw_txn: RawTransaction, secondary_signer_addresses: Array<AccountAddress>);
     serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): Identifier;
+    static load(deserializer: Deserializer): MultiAgentRawTransaction;
 }
-
 /**
- * Representation of a ModuleId that can serialized and deserialized
- * ModuleId means the module address (e.g "0x1") and the module name (e.g "coin")
+ * Representation of a Fee Payer Transaction that can serialized and deserialized
  */
-declare class ModuleId extends Serializable {
-    readonly address: AccountAddress;
-    readonly name: Identifier;
+declare class FeePayerRawTransaction extends RawTransactionWithData {
     /**
-     * Full name of a module.
-     * @param address The account address. e.g "0x1"
-     * @param name The module name under the "address". e.g "coin"
+     * The raw transaction
      */
-    constructor(address: AccountAddress, name: Identifier);
+    readonly raw_txn: RawTransaction;
     /**
-     * Converts a string literal to a ModuleId
-     * @param moduleId String literal in format "account_address::module_name", e.g. "0x1::coin"
-     * @returns ModuleId
+     * The secondary signers on this transaction - optional and can be empty
      */
-    static fromStr(moduleId: MoveModuleId): ModuleId;
+    readonly secondary_signer_addresses: Array<AccountAddress>;
+    /**
+     * The fee payer account address
+     */
+    readonly fee_payer_address: AccountAddress;
+    constructor(raw_txn: RawTransaction, secondary_signer_addresses: Array<AccountAddress>, fee_payer_address: AccountAddress);
     serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): ModuleId;
+    static load(deserializer: Deserializer): FeePayerRawTransaction;
 }
 
-declare abstract class TypeTag extends Serializable {
-    abstract serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): TypeTag;
-    abstract toString(): string;
-    isBool(): this is TypeTagBool;
-    isAddress(): this is TypeTagAddress;
-    isGeneric(): this is TypeTagGeneric;
-    isSigner(): this is TypeTagSigner;
-    isVector(): this is TypeTagVector;
-    isStruct(): this is TypeTagStruct;
-    isU8(): this is TypeTagU8;
-    isU16(): this is TypeTagU16;
-    isU32(): this is TypeTagU32;
-    isU64(): this is TypeTagU64;
-    isU128(): this is TypeTagU128;
-    isU256(): this is TypeTagU256;
-}
-declare class TypeTagBool extends TypeTag {
-    toString(): string;
+/**
+ * Representation of the challenge which is needed to sign by owner of the account
+ * to rotate the authentication key.
+ */
+declare class RotationProofChallenge extends Serializable {
+    readonly accountAddress: AccountAddress;
+    readonly moduleName: MoveString;
+    readonly structName: MoveString;
+    readonly originator: AccountAddress;
+    readonly currentAuthKey: AccountAddress;
+    readonly newPublicKey: MoveVector<U8>;
+    readonly sequenceNumber: U64;
+    constructor(args: {
+        sequenceNumber: AnyNumber;
+        originator: AccountAddress;
+        currentAuthKey: AccountAddress;
+        newPublicKey: PublicKey;
+    });
     serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagBool;
 }
-declare class TypeTagU8 extends TypeTag {
-    toString(): string;
-    serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagU8;
+
+declare abstract class TransactionAuthenticator extends Serializable {
+    abstract serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): TransactionAuthenticator;
 }
-declare class TypeTagU16 extends TypeTag {
-    toString(): string;
+/**
+ * Transaction authenticator Ed25519 for a single signer transaction
+ *
+ * @param public_key Client's public key.
+ * @param signature Ed25519 signature of a raw transaction.
+ * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
+ * for details about generating a signature.
+ */
+declare class TransactionAuthenticatorEd25519 extends TransactionAuthenticator {
+    readonly public_key: Ed25519PublicKey;
+    readonly signature: Ed25519Signature;
+    constructor(public_key: Ed25519PublicKey, signature: Ed25519Signature);
     serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagU16;
+    static load(deserializer: Deserializer): TransactionAuthenticatorEd25519;
 }
-declare class TypeTagU32 extends TypeTag {
-    toString(): string;
+/**
+ * Transaction authenticator Ed25519 for a multi signers transaction
+ *
+ * @param public_key Client's public key.
+ * @param signature Multi Ed25519 signature of a raw transaction.
+ *
+ */
+declare class TransactionAuthenticatorMultiEd25519 extends TransactionAuthenticator {
+    readonly public_key: MultiEd25519PublicKey;
+    readonly signature: MultiEd25519Signature;
+    constructor(public_key: MultiEd25519PublicKey, signature: MultiEd25519Signature);
     serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagU32;
+    static load(deserializer: Deserializer): TransactionAuthenticatorMultiEd25519;
 }
-declare class TypeTagU64 extends TypeTag {
-    toString(): string;
+/**
+ * Transaction authenticator for a multi-agent transaction
+ *
+ * @param sender Sender account authenticator
+ * @param secondary_signer_addresses Secondary signers address
+ * @param secondary_signers Secondary signers account authenticators
+ *
+ */
+declare class TransactionAuthenticatorMultiAgent extends TransactionAuthenticator {
+    readonly sender: AccountAuthenticator;
+    readonly secondary_signer_addresses: Array<AccountAddress>;
+    readonly secondary_signers: Array<AccountAuthenticator>;
+    constructor(sender: AccountAuthenticator, secondary_signer_addresses: Array<AccountAddress>, secondary_signers: Array<AccountAuthenticator>);
     serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagU64;
-}
-declare class TypeTagU128 extends TypeTag {
-    toString(): string;
-    serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagU128;
-}
-declare class TypeTagU256 extends TypeTag {
-    toString(): string;
-    serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagU256;
-}
-declare class TypeTagAddress extends TypeTag {
-    toString(): string;
-    serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagAddress;
-}
-declare class TypeTagSigner extends TypeTag {
-    toString(): string;
-    serialize(serializer: Serializer): void;
-    static load(_deserializer: Deserializer): TypeTagSigner;
-}
-declare class TypeTagReference extends TypeTag {
-    readonly value: TypeTag;
-    toString(): `&${string}`;
-    constructor(value: TypeTag);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TypeTagReference;
+    static load(deserializer: Deserializer): TransactionAuthenticatorMultiAgent;
 }
 /**
- * Generics are used for type parameters in entry functions.  However,
- * they are not actually serialized into a real type, so they cannot be
- * used as a type directly.
+ * Transaction authenticator for a fee payer transaction
+ *
+ * @param sender Sender account authenticator
+ * @param secondary_signer_addresses Secondary signers address
+ * @param secondary_signers Secondary signers account authenticators
+ * @param fee_payer Object of the fee payer account address and the fee payer authentication
+ *
  */
-declare class TypeTagGeneric extends TypeTag {
-    readonly value: number;
-    toString(): `T${number}`;
-    constructor(value: number);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TypeTagGeneric;
-}
-declare class TypeTagVector extends TypeTag {
-    readonly value: TypeTag;
-    toString(): `vector<${string}>`;
-    constructor(value: TypeTag);
-    static u8(): TypeTagVector;
+declare class TransactionAuthenticatorFeePayer extends TransactionAuthenticator {
+    readonly sender: AccountAuthenticator;
+    readonly secondary_signer_addresses: Array<AccountAddress>;
+    readonly secondary_signers: Array<AccountAuthenticator>;
+    readonly fee_payer: {
+        address: AccountAddress;
+        authenticator: AccountAuthenticator;
+    };
+    constructor(sender: AccountAuthenticator, secondary_signer_addresses: Array<AccountAddress>, secondary_signers: Array<AccountAuthenticator>, fee_payer: {
+        address: AccountAddress;
+        authenticator: AccountAuthenticator;
+    });
     serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TypeTagVector;
+    static load(deserializer: Deserializer): TransactionAuthenticatorMultiAgent;
 }
-declare class TypeTagStruct extends TypeTag {
-    readonly value: StructTag;
-    toString(): `0x${string}::${string}::${string}`;
-    constructor(value: StructTag);
+/**
+ * Single Sender authenticator for a single signer transaction
+ *
+ * @param sender AccountAuthenticator
+ */
+declare class TransactionAuthenticatorSingleSender extends TransactionAuthenticator {
+    readonly sender: AccountAuthenticator;
+    constructor(sender: AccountAuthenticator);
     serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TypeTagStruct;
-    isTypeTag(address: AccountAddress, moduleName: string, structName: string): boolean;
-    isString(): boolean;
-    isOption(): boolean;
-    isObject(): boolean;
+    static load(deserializer: Deserializer): TransactionAuthenticatorSingleSender;
 }
-declare class StructTag extends Serializable {
-    readonly address: AccountAddress;
-    readonly moduleName: Identifier;
-    readonly name: Identifier;
-    readonly typeArgs: Array<TypeTag>;
-    constructor(address: AccountAddress, module_name: Identifier, name: Identifier, type_args: Array<TypeTag>);
+
+declare class SignedTransaction extends Serializable {
+    readonly raw_txn: RawTransaction;
+    readonly authenticator: TransactionAuthenticator;
+    /**
+     * A SignedTransaction consists of a raw transaction and an authenticator. The authenticator
+     * contains a client's public key and the signature of the raw transaction.
+     *
+     * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
+     *
+     * @param raw_txn
+     * @param authenticator Contains a client's public key and the signature of the raw transaction.
+     * Authenticator has 3 flavors: single signature, multi-signature and multi-agent.
+     * @see {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs} for details.
+     */
+    constructor(raw_txn: RawTransaction, authenticator: TransactionAuthenticator);
     serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): StructTag;
+    static deserialize(deserializer: Deserializer): SignedTransaction;
 }
-declare function aptosCoinStructTag(): StructTag;
-declare function stringStructTag(): StructTag;
-declare function optionStructTag(typeArg: TypeTag): StructTag;
-declare function objectStructTag(typeArg: TypeTag): StructTag;
 
 /**
- * Deserialize a Script Transaction Argument
- */
-declare function deserializeFromScriptArgument(deserializer: Deserializer): TransactionArgument;
-/**
- * Representation of the supported Transaction Payload
- * that can serialized and deserialized
+ * Representation of a SimpleTransaction that can serialized and deserialized
  */
-declare abstract class TransactionPayload extends Serializable {
-    /**
-     * Serialize a Transaction Payload
-     */
-    abstract serialize(serializer: Serializer): void;
+declare class SimpleTransaction extends Serializable {
+    rawTransaction: RawTransaction;
+    feePayerAddress?: AccountAddress | undefined;
+    readonly secondarySignerAddresses: undefined;
     /**
-     * Deserialize a Transaction Payload
+     * SimpleTransaction represents a simple transaction type of a single signer that
+     * can be submitted to Aptos chain for execution.
+     *
+     * SimpleTransaction metadata contains the Raw Transaction and an optional
+     * sponsor Account Address to pay the gas fees.
+     *
+     * @param rawTransaction The Raw Tranasaction
+     * @param feePayerAddress The sponsor Account Address
      */
-    static deserialize(deserializer: Deserializer): TransactionPayload;
+    constructor(rawTransaction: RawTransaction, feePayerAddress?: AccountAddress);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): SimpleTransaction;
 }
+
 /**
- * Representation of a Transaction Payload Script that can serialized and deserialized
+ * Representation of a Raw Transaction that can serialized and deserialized
  */
-declare class TransactionPayloadScript extends TransactionPayload {
-    readonly script: Script;
-    constructor(script: Script);
+declare class MultiAgentTransaction extends Serializable {
+    rawTransaction: RawTransaction;
+    feePayerAddress?: AccountAddress | undefined;
+    secondarySignerAddresses: AccountAddress[];
+    /**
+     * SimpleTransaction represents a simple transaction type of a single signer that
+     * can be submitted to Aptos chain for execution.
+     *
+     * SimpleTransaction metadata contains the Raw Transaction and an optional
+     * sponsor Account Address to pay the gas fees.
+     *
+     * @param rawTransaction The Raw Tranasaction
+     * @param feePayerAddress The sponsor Account Address
+     */
+    constructor(rawTransaction: RawTransaction, secondarySignerAddresses: AccountAddress[], feePayerAddress?: AccountAddress);
     serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionPayloadScript;
+    static deserialize(deserializer: Deserializer): MultiAgentTransaction;
 }
+
 /**
- * Representation of a Transaction Payload Entry Function that can serialized and deserialized
+ * Entry function arguments to be used when building a raw transaction using remote ABI
  */
-declare class TransactionPayloadEntryFunction extends TransactionPayload {
-    readonly entryFunction: EntryFunction;
-    constructor(entryFunction: EntryFunction);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionPayloadEntryFunction;
-}
+type SimpleEntryFunctionArgumentTypes = boolean | number | bigint | string | null | undefined | Uint8Array | ArrayBuffer | Array<SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes>;
 /**
- * Representation of a Transaction Payload Multi-sig that can serialized and deserialized
+ * Entry function arguments to be used when building a raw transaction using BCS serialized arguments
  */
-declare class TransactionPayloadMultiSig extends TransactionPayload {
-    readonly multiSig: MultiSig;
-    constructor(multiSig: MultiSig);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionPayloadMultiSig;
-}
+type EntryFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveVector<EntryFunctionArgumentTypes> | MoveOption<EntryFunctionArgumentTypes> | MoveString | FixedBytes;
 /**
- * Representation of a EntryFunction that can serialized and deserialized
+ * Script function arguments to be used when building a raw transaction using BCS serialized arguments
  */
-declare class EntryFunction {
-    readonly module_name: ModuleId;
-    readonly function_name: Identifier;
-    readonly type_args: Array<TypeTag>;
-    readonly args: Array<EntryFunctionArgument>;
-    /**
-     * Contains the payload to run a function within a module.
-     * @param module_name Fully qualified module name in format "account_address::module_name" e.g. "0x1::coin"
-     * @param function_name The function name. e.g "transfer"
-     * @param type_args Type arguments that move function requires.
-     *
-     * @example
-     * A coin transfer function has one type argument "CoinType".
-     * ```
-     * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-     * ```
-     * @param args arguments to the move function.
-     *
-     * @example
-     * A coin transfer function has three arguments "from", "to" and "amount".
-     * ```
-     * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-     * ```
-     */
-    constructor(module_name: ModuleId, function_name: Identifier, type_args: Array<TypeTag>, args: Array<EntryFunctionArgument>);
-    /**
-     * A helper function to build a EntryFunction payload from raw primitive values
-     *
-     * @param module_id Fully qualified module name in format "AccountAddress::module_id" e.g. "0x1::coin"
-     * @param function_name Function name
-     * @param type_args Type arguments that move function requires.
-     *
-     * @example
-     * A coin transfer function has one type argument "CoinType".
-     * ```
-     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
-     * ```
-     * @param args Arguments to the move function.
-     *
-     * @example
-     * A coin transfer function has three arguments "from", "to" and "amount".
-     * ```
-     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
-     * ```
-     * @returns EntryFunction
-     */
-    static build(module_id: MoveModuleId, function_name: string, type_args: Array<TypeTag>, args: Array<EntryFunctionArgument>): EntryFunction;
-    serialize(serializer: Serializer): void;
-    /**
-     * Deserializes an entry function payload with the arguments represented as EntryFunctionBytes instances.
-     * @see EntryFunctionBytes
-     *
-     * NOTE: When you deserialize an EntryFunction payload with this method, the entry function
-     * arguments are populated into the deserialized instance as type-agnostic, raw fixed bytes
-     * in the form of the EntryFunctionBytes class.
-     *
-     * In order to correctly deserialize these arguments as their actual type representations, you
-     * must know the types of the arguments beforehand and deserialize them yourself individually.
-     *
-     * One way you could achieve this is by using the ABIs for an entry function and deserializing each
-     * argument as its given, corresponding type.
-     *
-     * @param deserializer
-     * @returns A deserialized EntryFunction payload for a transaction.
-     *
-     */
-    static deserialize(deserializer: Deserializer): EntryFunction;
-}
+type ScriptFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveVector<U8> | MoveString | FixedBytes;
 /**
- * Representation of a Script that can serialized and deserialized
+ * Type that holds all raw transaction instances Aptos SDK supports
  */
-declare class Script {
-    /**
-     * The move module bytecode
-     */
-    readonly bytecode: Uint8Array;
-    /**
-     * The type arguments that the bytecode function requires.
-     */
-    readonly type_args: Array<TypeTag>;
-    /**
-     * The arguments that the bytecode function requires.
-     */
-    readonly args: Array<ScriptFunctionArgument>;
-    /**
-     * Scripts contain the Move bytecodes payload that can be submitted to Aptos chain for execution.
-     *
-     * @param bytecode The move module bytecode
-     * @param type_args The type arguments that the bytecode function requires.
-     *
-     * @example
-     * A coin transfer function has one type argument "CoinType".
-     * ```
-     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
-     * ```
-     * @param args The arguments that the bytecode function requires.
-     *
-     * @example
-     * A coin transfer function has three arguments "from", "to" and "amount".
-     * ```
-     * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
-     * ```
-     */
-    constructor(bytecode: Uint8Array, type_args: Array<TypeTag>, args: Array<ScriptFunctionArgument>);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): Script;
-}
+type AnyRawTransactionInstance = RawTransaction | MultiAgentRawTransaction | FeePayerRawTransaction;
 /**
- * Representation of a MultiSig that can serialized and deserialized
+ * Optional options to set when generating a transaction
  */
-declare class MultiSig {
-    readonly multisig_address: AccountAddress;
-    readonly transaction_payload?: MultiSigTransactionPayload;
-    /**
-     * Contains the payload to run a multi-sig account transaction.
-     *
-     * @param multisig_address The multi-sig account address the transaction will be executed as.
-     *
-     * @param transaction_payload The payload of the multi-sig transaction. This is optional when executing a multi-sig
-     *  transaction whose payload is already stored on chain.
-     */
-    constructor(multisig_address: AccountAddress, transaction_payload?: MultiSigTransactionPayload);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MultiSig;
-}
+type InputGenerateTransactionOptions = {
+    maxGasAmount?: number;
+    gasUnitPrice?: number;
+    expireTimestamp?: number;
+    accountSequenceNumber?: AnyNumber;
+};
 /**
- * Representation of a MultiSig Transaction Payload from `multisig_account.move`
- * that can be serialized and deserialized
-
- * This class exists right now to represent an extensible transaction payload class for
- * transactions used in `multisig_account.move`. Eventually, this class will be able to
- * support script payloads when the `multisig_account.move` module supports them.
+ * The generated transaction payload type that was produces from `generateTransactionPayload()` function.
  */
-declare class MultiSigTransactionPayload extends Serializable {
-    readonly transaction_payload: EntryFunction;
-    /**
-     * Contains the payload to run a multi-sig account transaction.
-     *
-     * @param transaction_payload The payload of the multi-sig transaction.
-     * This can only be EntryFunction for now but,
-     * Script might be supported in the future.
-     */
-    constructor(transaction_payload: EntryFunction);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MultiSigTransactionPayload;
-}
-
+type AnyTransactionPayloadInstance = TransactionPayloadEntryFunction | TransactionPayloadScript | TransactionPayloadMultiSig;
 /**
- * Representation of a Raw Transaction that can serialized and deserialized
+ * Unified type for the data needed to generate a transaction payload of types:
+ * Entry Function | Script | Multi Sig
  */
-declare class RawTransaction extends Serializable {
-    readonly sender: AccountAddress;
-    readonly sequence_number: bigint;
-    readonly payload: TransactionPayload;
-    readonly max_gas_amount: bigint;
-    readonly gas_unit_price: bigint;
-    readonly expiration_timestamp_secs: bigint;
-    readonly chain_id: ChainId;
-    /**
-     * RawTransactions contain the metadata and payloads that can be submitted to Aptos chain for execution.
-     * RawTransactions must be signed before Aptos chain can execute them.
-     *
-     * @param sender The sender Account Address
-     * @param sequence_number Sequence number of this transaction. This must match the sequence number stored in
-     *   the sender's account at the time the transaction executes.
-     * @param payload Instructions for the Aptos Blockchain, including publishing a module,
-     *   execute an entry function or execute a script payload.
-     * @param max_gas_amount Maximum total gas to spend for this transaction. The account must have more
-     *   than this gas or the transaction will be discarded during validation.
-     * @param gas_unit_price Price to be paid per gas unit.
-     * @param expiration_timestamp_secs The blockchain timestamp at which the blockchain would discard this transaction.
-     * @param chain_id The chain ID of the blockchain that this transaction is intended to be run on.
-     */
-    constructor(sender: AccountAddress, sequence_number: bigint, payload: TransactionPayload, max_gas_amount: bigint, gas_unit_price: bigint, expiration_timestamp_secs: bigint, chain_id: ChainId);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): RawTransaction;
-}
+type InputGenerateTransactionPayloadData = InputEntryFunctionData | InputScriptData | InputMultiSigData;
+type InputGenerateTransactionPayloadDataWithRemoteABI = InputScriptData | InputEntryFunctionDataWithRemoteABI | InputMultiSigDataWithRemoteABI;
 /**
- * Representation of a Raw Transaction With Data that can serialized and deserialized
+ * The data needed to generate an Entry Function payload
  */
-declare abstract class RawTransactionWithData extends Serializable {
-    /**
-     * Serialize a Raw Transaction With Data
-     */
-    abstract serialize(serializer: Serializer): void;
-    /**
-     * Deserialize a Raw Transaction With Data
-     */
-    static deserialize(deserializer: Deserializer): RawTransactionWithData;
+type InputEntryFunctionData = {
+    function: MoveFunctionId;
+    typeArguments?: Array<TypeTag | string>;
+    functionArguments: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
+    abi?: EntryFunctionABI;
+};
+type InputGenerateTransactionPayloadDataWithABI = InputEntryFunctionDataWithABI | InputMultiSigDataWithABI;
+type InputEntryFunctionDataWithABI = Omit<InputEntryFunctionData, "abi"> & {
+    abi: EntryFunctionABI;
+};
+type InputMultiSigDataWithABI = {
+    multisigAddress: AccountAddressInput;
+} & InputEntryFunctionDataWithABI;
+type InputEntryFunctionDataWithRemoteABI = InputEntryFunctionData & {
+    aptosConfig: AptosConfig;
+};
+/**
+ * The data needed to generate a Multi Sig payload
+ */
+type InputMultiSigData = {
+    multisigAddress: AccountAddressInput;
+} & InputEntryFunctionData;
+/**
+ * The data needed to generate a Multi Sig payload
+ */
+type InputMultiSigDataWithRemoteABI = {
+    multisigAddress: AccountAddressInput;
+} & InputEntryFunctionDataWithRemoteABI;
+/**
+ * The data needed to generate a Script payload
+ */
+type InputScriptData = {
+    bytecode: HexInput;
+    typeArguments?: Array<TypeTag>;
+    functionArguments: Array<ScriptFunctionArgumentTypes>;
+};
+/**
+ * The data needed to generate a View Function payload
+ */
+type InputViewFunctionData = {
+    function: MoveFunctionId;
+    typeArguments?: Array<TypeTag | string>;
+    functionArguments?: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
+    abi?: ViewFunctionABI;
+};
+/**
+ * Data needed to generate a view function payload and fetch the remote ABI
+ */
+type InputViewFunctionDataWithRemoteABI = InputViewFunctionData & {
+    aptosConfig: AptosConfig;
+};
+/**
+ * Data needed to generate a view function, with an already fetched ABI
+ */
+type InputViewFunctionDataWithABI = InputViewFunctionData & {
+    abi: ViewFunctionABI;
+};
+/**
+ * Data need for a generic function ABI, both view and entry
+ */
+type FunctionABI = {
+    typeParameters: Array<MoveFunctionGenericTypeParam>;
+    parameters: Array<TypeTag>;
+};
+/**
+ * Interface of an Entry function's ABI.
+ *
+ * This is used to provide type checking and simple input conversion on ABI based transaction submission.
+ */
+type EntryFunctionABI = FunctionABI & {
+    signers?: number;
+};
+/**
+ * Interface of an View function's ABI.
+ *
+ * This is used to provide type checking and simple input conversion on ABI based transaction submission.
+ */
+type ViewFunctionABI = FunctionABI & {
+    returnTypes: Array<TypeTag>;
+};
+/**
+ * Interface of the arguments to generate a single signer transaction.
+ * Used to provide to `generateTransaction()` method in the transaction builder flow
+ */
+interface InputGenerateSingleSignerRawTransactionArgs {
+    aptosConfig: AptosConfig;
+    sender: AccountAddressInput;
+    payload: AnyTransactionPayloadInstance;
+    options?: InputGenerateTransactionOptions;
+    feePayerAddress?: AccountAddressInput;
 }
 /**
- * Representation of a Multi Agent Transaction that can serialized and deserialized
+ * Interface of the arguments to generate a multi-agent transaction.
+ * Used to provide to `generateTransaction()` method in the transaction builder flow
  */
-declare class MultiAgentRawTransaction extends RawTransactionWithData {
-    /**
-     * The raw transaction
-     */
-    readonly raw_txn: RawTransaction;
-    /**
-     * The secondary signers on this transaction
-     */
-    readonly secondary_signer_addresses: Array<AccountAddress>;
-    constructor(raw_txn: RawTransaction, secondary_signer_addresses: Array<AccountAddress>);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): MultiAgentRawTransaction;
+interface InputGenerateMultiAgentRawTransactionArgs {
+    aptosConfig: AptosConfig;
+    sender: AccountAddressInput;
+    payload: AnyTransactionPayloadInstance;
+    secondarySignerAddresses: AccountAddressInput[];
+    options?: InputGenerateTransactionOptions;
+    feePayerAddress?: AccountAddressInput;
 }
 /**
- * Representation of a Fee Payer Transaction that can serialized and deserialized
+ * Unified type that holds all the interfaces to generate different transaction types
  */
-declare class FeePayerRawTransaction extends RawTransactionWithData {
+type InputGenerateRawTransactionArgs = InputGenerateSingleSignerRawTransactionArgs | InputGenerateMultiAgentRawTransactionArgs;
+/**
+ * Unified type that holds all the return interfaces when generating different transaction types
+ */
+type AnyRawTransaction = SimpleTransaction | MultiAgentTransaction;
+type InputSimulateTransactionData = {
     /**
-     * The raw transaction
+     * The transaction to simulate, probably generated by `generateTransaction()`
      */
-    readonly raw_txn: RawTransaction;
+    transaction: AnyRawTransaction;
     /**
-     * The secondary signers on this transaction - optional and can be empty
+     * For a single signer transaction
      */
-    readonly secondary_signer_addresses: Array<AccountAddress>;
+    signerPublicKey: PublicKey;
     /**
-     * The fee payer account address
+     * For a fee payer or multi-agent transaction that requires additional signers in
      */
-    readonly fee_payer_address: AccountAddress;
-    constructor(raw_txn: RawTransaction, secondary_signer_addresses: Array<AccountAddress>, fee_payer_address: AccountAddress);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): FeePayerRawTransaction;
-}
-
-/**
- * Representation of a SimpleTransaction that can serialized and deserialized
- */
-declare class SimpleTransaction extends Serializable {
-    rawTransaction: RawTransaction;
-    feePayerAddress?: AccountAddress | undefined;
-    readonly secondarySignerAddresses: undefined;
+    secondarySignersPublicKeys?: Array<PublicKey>;
     /**
-     * SimpleTransaction represents a simple transaction type of a single signer that
-     * can be submitted to Aptos chain for execution.
-     *
-     * SimpleTransaction metadata contains the Raw Transaction and an optional
-     * sponsor Account Address to pay the gas fees.
-     *
-     * @param rawTransaction The Raw Tranasaction
-     * @param feePayerAddress The sponsor Account Address
+     * For a fee payer transaction (aka Sponsored Transaction)
      */
-    constructor(rawTransaction: RawTransaction, feePayerAddress?: AccountAddress);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): SimpleTransaction;
-}
-
+    feePayerPublicKey?: PublicKey;
+    options?: InputSimulateTransactionOptions;
+};
+type InputSimulateTransactionOptions = {
+    estimateGasUnitPrice?: boolean;
+    estimateMaxGasAmount?: boolean;
+    estimatePrioritizedGasUnitPrice?: boolean;
+};
 /**
- * Representation of the challenge which is needed to sign by owner of the account
- * to rotate the authentication key.
+ * Interface that holds the user data input when generating a single signer transaction
  */
-declare class RotationProofChallenge extends Serializable {
-    readonly accountAddress: AccountAddress;
-    readonly moduleName: MoveString;
-    readonly structName: MoveString;
-    readonly originator: AccountAddress;
-    readonly currentAuthKey: AccountAddress;
-    readonly newPublicKey: MoveVector<U8>;
-    readonly sequenceNumber: U64;
-    constructor(args: {
-        sequenceNumber: AnyNumber;
-        originator: AccountAddress;
-        currentAuthKey: AccountAddress;
-        newPublicKey: PublicKey;
-    });
-    serialize(serializer: Serializer): void;
-}
-
-declare abstract class TransactionAuthenticator extends Serializable {
-    abstract serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): TransactionAuthenticator;
+interface InputGenerateSingleSignerRawTransactionData {
+    sender: AccountAddressInput;
+    data: InputGenerateTransactionPayloadData;
+    options?: InputGenerateTransactionOptions;
+    withFeePayer?: boolean;
+    secondarySignerAddresses?: undefined;
 }
 /**
- * Transaction authenticator Ed25519 for a single signer transaction
- *
- * @param public_key Client's public key.
- * @param signature Ed25519 signature of a raw transaction.
- * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
- * for details about generating a signature.
+ * Interface that holds the user data input when generating a multi-agent transaction
  */
-declare class TransactionAuthenticatorEd25519 extends TransactionAuthenticator {
-    readonly public_key: Ed25519PublicKey;
-    readonly signature: Ed25519Signature;
-    constructor(public_key: Ed25519PublicKey, signature: Ed25519Signature);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionAuthenticatorEd25519;
+interface InputGenerateMultiAgentRawTransactionData {
+    sender: AccountAddressInput;
+    data: InputGenerateTransactionPayloadData;
+    secondarySignerAddresses: AccountAddressInput[];
+    options?: InputGenerateTransactionOptions;
+    withFeePayer?: boolean;
 }
 /**
- * Transaction authenticator Ed25519 for a multi signers transaction
- *
- * @param public_key Client's public key.
- * @param signature Multi Ed25519 signature of a raw transaction.
- *
+ * Unified type that holds all the user data input interfaces when generating different transaction types
  */
-declare class TransactionAuthenticatorMultiEd25519 extends TransactionAuthenticator {
-    readonly public_key: MultiEd25519PublicKey;
-    readonly signature: MultiEd25519Signature;
-    constructor(public_key: MultiEd25519PublicKey, signature: MultiEd25519Signature);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionAuthenticatorMultiEd25519;
-}
+type InputGenerateTransactionData = InputGenerateSingleSignerRawTransactionData | InputGenerateMultiAgentRawTransactionData;
 /**
- * Transaction authenticator for a multi-agent transaction
- *
- * @param sender Sender account authenticator
- * @param secondary_signer_addresses Secondary signers address
- * @param secondary_signers Secondary signers account authenticators
- *
+ * Interface that holds the user data input when submitting a transaction
  */
-declare class TransactionAuthenticatorMultiAgent extends TransactionAuthenticator {
-    readonly sender: AccountAuthenticator;
-    readonly secondary_signer_addresses: Array<AccountAddress>;
-    readonly secondary_signers: Array<AccountAuthenticator>;
-    constructor(sender: AccountAuthenticator, secondary_signer_addresses: Array<AccountAddress>, secondary_signers: Array<AccountAuthenticator>);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionAuthenticatorMultiAgent;
+interface InputSubmitTransactionData {
+    transaction: AnyRawTransaction;
+    senderAuthenticator: AccountAuthenticator;
+    feePayerAuthenticator?: AccountAuthenticator;
+    additionalSignersAuthenticators?: Array<AccountAuthenticator>;
 }
-/**
- * Transaction authenticator for a fee payer transaction
- *
- * @param sender Sender account authenticator
- * @param secondary_signer_addresses Secondary signers address
- * @param secondary_signers Secondary signers account authenticators
- * @param fee_payer Object of the fee payer account address and the fee payer authentication
- *
- */
-declare class TransactionAuthenticatorFeePayer extends TransactionAuthenticator {
-    readonly sender: AccountAuthenticator;
-    readonly secondary_signer_addresses: Array<AccountAddress>;
-    readonly secondary_signers: Array<AccountAuthenticator>;
-    readonly fee_payer: {
-        address: AccountAddress;
-        authenticator: AccountAuthenticator;
-    };
-    constructor(sender: AccountAuthenticator, secondary_signer_addresses: Array<AccountAddress>, secondary_signers: Array<AccountAuthenticator>, fee_payer: {
-        address: AccountAddress;
-        authenticator: AccountAuthenticator;
-    });
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionAuthenticatorMultiAgent;
+
+interface SingleKeySignerConstructorArgs {
+    privateKey: PrivateKey;
+    address?: AccountAddressInput;
+}
+interface SingleKeySignerGenerateArgs {
+    scheme?: SigningSchemeInput;
+}
+type SingleKeySignerFromDerivationPathArgs = SingleKeySignerGenerateArgs & {
+    path: string;
+    mnemonic: string;
+};
+interface VerifySingleKeySignatureArgs {
+    message: HexInput;
+    signature: AnySignature;
 }
 /**
- * Single Sender authenticator for a single signer transaction
+ * Signer implementation for the SingleKey authentication scheme.
+ * This extends a SingleKeyAccount by adding signing capabilities through a valid private key.
+ * Currently, the only supported signature schemes are Ed25519 and Secp256k1.
  *
- * @param sender AccountAuthenticator
+ * Note: Generating a signer instance does not create the account on-chain.
  */
-declare class TransactionAuthenticatorSingleSender extends TransactionAuthenticator {
-    readonly sender: AccountAuthenticator;
-    constructor(sender: AccountAuthenticator);
-    serialize(serializer: Serializer): void;
-    static load(deserializer: Deserializer): TransactionAuthenticatorSingleSender;
-}
-
-declare class SignedTransaction extends Serializable {
-    readonly raw_txn: RawTransaction;
-    readonly authenticator: TransactionAuthenticator;
+declare class SingleKeyAccount implements Account$1 {
     /**
-     * A SignedTransaction consists of a raw transaction and an authenticator. The authenticator
-     * contains a client's public key and the signature of the raw transaction.
-     *
-     * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
-     *
-     * @param raw_txn
-     * @param authenticator Contains a client's public key and the signature of the raw transaction.
-     * Authenticator has 3 flavors: single signature, multi-signature and multi-agent.
-     * @see {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs} for details.
+     * Private key associated with the account
      */
-    constructor(raw_txn: RawTransaction, authenticator: TransactionAuthenticator);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): SignedTransaction;
-}
-
-/**
- * Representation of a Raw Transaction that can serialized and deserialized
- */
-declare class MultiAgentTransaction extends Serializable {
-    rawTransaction: RawTransaction;
-    feePayerAddress?: AccountAddress | undefined;
-    secondarySignerAddresses: AccountAddress[];
+    readonly privateKey: PrivateKey;
+    readonly publicKey: AnyPublicKey;
+    readonly accountAddress: AccountAddress;
+    readonly signingScheme = SigningScheme.SingleKey;
+    constructor(args: SingleKeySignerConstructorArgs);
     /**
-     * SimpleTransaction represents a simple transaction type of a single signer that
-     * can be submitted to Aptos chain for execution.
-     *
-     * SimpleTransaction metadata contains the Raw Transaction and an optional
-     * sponsor Account Address to pay the gas fees.
+     * Derives an account from a randomly generated private key.
+     * Default generation is using an Ed25519 key
+     * @returns Account with the given signature scheme
+     */
+    static generate(args?: SingleKeySignerGenerateArgs): SingleKeyAccount;
+    /**
+     * Derives an account with bip44 path and mnemonics,
+     * Default to using an Ed25519 signature scheme.
      *
-     * @param rawTransaction The Raw Tranasaction
-     * @param feePayerAddress The sponsor Account Address
+     * @param args.scheme The signature scheme to derive the private key with
+     * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
+     * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
+     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
+     * @param args.mnemonic the mnemonic seed phrase of the account
      */
-    constructor(rawTransaction: RawTransaction, secondarySignerAddresses: AccountAddress[], feePayerAddress?: AccountAddress);
-    serialize(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): MultiAgentTransaction;
+    static fromDerivationPath(args: SingleKeySignerFromDerivationPathArgs): SingleKeyAccount;
+    verifySignature(args: VerifySingleKeySignatureArgs): boolean;
+    signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey;
+    sign(message: HexInput): AnySignature;
+    signTransaction(transaction: AnyRawTransaction): AnySignature;
 }
 
 /**
- * Entry function arguments to be used when building a raw transaction using remote ABI
+ * Arguments for creating an `Ed25519Account` from an `Ed25519PrivateKey`.
+ * This is the default input type when passing an `Ed25519PrivateKey`.
+ * In order to use the SingleKey authentication scheme, `legacy` needs to be explicitly set to false.
  */
-type SimpleEntryFunctionArgumentTypes = boolean | number | bigint | string | null | undefined | Uint8Array | ArrayBuffer | Array<SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes>;
+interface CreateEd25519AccountFromPrivateKeyArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+    legacy?: true;
+}
 /**
- * Entry function arguments to be used when building a raw transaction using BCS serialized arguments
+ * Arguments for creating an `SingleKeyAccount` from an `Ed25519PrivateKey`.
+ * The `legacy` argument needs to be explicitly set to false in order to
+ * use the `SingleKey` authentication scheme.
  */
-type EntryFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveVector<EntryFunctionArgumentTypes> | MoveOption<EntryFunctionArgumentTypes> | MoveString | FixedBytes;
+interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+    legacy: false;
+}
 /**
- * Script function arguments to be used when building a raw transaction using BCS serialized arguments
+ * Arguments for creating an `SingleKeyAccount` from any supported private key
+ * that is not an `Ed25519PrivateKey`.
+ * The `legacy` argument defaults to false and cannot be explicitly set to true.
  */
-type ScriptFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveVector<U8> | MoveString | FixedBytes;
+interface CreateSingleKeyAccountFromPrivateKeyArgs {
+    privateKey: Exclude<PrivateKey, Ed25519PrivateKey>;
+    address?: AccountAddressInput;
+    legacy?: false;
+}
 /**
- * Type that holds all raw transaction instances Aptos SDK supports
+ * Arguments for creating an opaque `Account` from any supported private key.
+ * This is used when the private key type is not known at compilation time.
  */
-type AnyRawTransactionInstance = RawTransaction | MultiAgentRawTransaction | FeePayerRawTransaction;
-/**
- * Optional options to set when generating a transaction
- */
-type InputGenerateTransactionOptions = {
-    maxGasAmount?: number;
-    gasUnitPrice?: number;
-    expireTimestamp?: number;
-    accountSequenceNumber?: AnyNumber;
-};
-/**
- * The generated transaction payload type that was produces from `generateTransactionPayload()` function.
- */
-type AnyTransactionPayloadInstance = TransactionPayloadEntryFunction | TransactionPayloadScript | TransactionPayloadMultiSig;
-/**
- * Unified type for the data needed to generate a transaction payload of types:
- * Entry Function | Script | Multi Sig
- */
-type InputGenerateTransactionPayloadData = InputEntryFunctionData | InputScriptData | InputMultiSigData;
-type InputGenerateTransactionPayloadDataWithRemoteABI = InputScriptData | InputEntryFunctionDataWithRemoteABI | InputMultiSigDataWithRemoteABI;
-/**
- * The data needed to generate an Entry Function payload
- */
-type InputEntryFunctionData = {
-    function: MoveFunctionId;
-    typeArguments?: Array<TypeTag | string>;
-    functionArguments: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
-    abi?: EntryFunctionABI;
-};
-type InputGenerateTransactionPayloadDataWithABI = InputEntryFunctionDataWithABI | InputMultiSigDataWithABI;
-type InputEntryFunctionDataWithABI = Omit<InputEntryFunctionData, "abi"> & {
-    abi: EntryFunctionABI;
-};
-type InputMultiSigDataWithABI = {
-    multisigAddress: AccountAddressInput;
-} & InputEntryFunctionDataWithABI;
-type InputEntryFunctionDataWithRemoteABI = InputEntryFunctionData & {
-    aptosConfig: AptosConfig;
-};
-/**
- * The data needed to generate a Multi Sig payload
- */
-type InputMultiSigData = {
-    multisigAddress: AccountAddressInput;
-} & InputEntryFunctionData;
-/**
- * The data needed to generate a Multi Sig payload
- */
-type InputMultiSigDataWithRemoteABI = {
-    multisigAddress: AccountAddressInput;
-} & InputEntryFunctionDataWithRemoteABI;
+interface CreateAccountFromPrivateKeyArgs {
+    privateKey: PrivateKey;
+    address?: AccountAddressInput;
+    legacy?: boolean;
+}
 /**
- * The data needed to generate a Script payload
+ * Arguments for generating an `Ed25519Account`.
+ * This is the input type used by default.
  */
-type InputScriptData = {
-    bytecode: HexInput;
-    typeArguments?: Array<TypeTag>;
-    functionArguments: Array<ScriptFunctionArgumentTypes>;
-};
+interface GenerateEd25519AccountArgs {
+    scheme?: SigningSchemeInput.Ed25519;
+    legacy?: true;
+}
 /**
- * The data needed to generate a View Function payload
+ * Arguments for generating an `SingleKeyAccount` with ah underlying `Ed25519PrivateKey`.
+ * The `legacy` argument needs to be explicitly set to false,
+ * otherwise an `Ed25519Account` will be returned instead.
  */
-type InputViewFunctionData = {
-    function: MoveFunctionId;
-    typeArguments?: Array<TypeTag | string>;
-    functionArguments?: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
-    abi?: ViewFunctionABI;
-};
+interface GenerateEd25519SingleKeyAccountArgs {
+    scheme?: SigningSchemeInput.Ed25519;
+    legacy: false;
+}
 /**
- * Data needed to generate a view function payload and fetch the remote ABI
+ * Arguments for generating an `SingleKeyAccount` with any supported private key
+ * that is not an `Ed25519PrivateKey`.
+ * The `legacy` argument defaults to false and cannot be explicitly set to true.
  */
-type InputViewFunctionDataWithRemoteABI = InputViewFunctionData & {
-    aptosConfig: AptosConfig;
-};
+interface GenerateSingleKeyAccountArgs {
+    scheme: Exclude<SigningSchemeInput, SigningSchemeInput.Ed25519>;
+    legacy?: false;
+}
 /**
- * Data needed to generate a view function, with an already fetched ABI
+ * Arguments for generating an opaque `Account`.
+ * This is used when the input signature scheme is not known at compilation time.
  */
-type InputViewFunctionDataWithABI = InputViewFunctionData & {
-    abi: ViewFunctionABI;
-};
+interface GenerateAccountArgs {
+    scheme?: SigningSchemeInput;
+    legacy?: boolean;
+}
 /**
- * Data need for a generic function ABI, both view and entry
+ * Arguments for deriving a private key from a mnemonic phrase and a BIP44 path.
  */
-type FunctionABI = {
-    typeParameters: Array<MoveFunctionGenericTypeParam>;
-    parameters: Array<TypeTag>;
-};
+interface PrivateKeyFromDerivationPathArgs {
+    path: string;
+    mnemonic: string;
+}
 /**
- * Interface of an Entry function's ABI.
+ * Interface for a generic Aptos account.
  *
- * This is used to provide type checking and simple input conversion on ABI based transaction submission.
+ * The interface is defined as abstract class to provide a single entrypoint for account generation,
+ * either through `Account.generate()` or `Account.fromDerivationPath`.
+ * Despite this being an abstract class, it should be treated as an interface and enforced using
+ * the `implements` keyword.
+ *
+ * Note: Generating an account instance does not create the account on-chain.
  */
-type EntryFunctionABI = FunctionABI & {
-    signers?: number;
-};
+declare abstract class Account$1 {
+    /**
+     * Public key associated with the account
+     */
+    abstract readonly publicKey: AccountPublicKey;
+    /**
+     * Account address associated with the account
+     */
+    abstract readonly accountAddress: AccountAddress;
+    /**
+     * Signing scheme used to sign transactions
+     */
+    abstract signingScheme: SigningScheme;
+    /**
+     * Derives an account from a randomly generated private key.
+     * @param args.scheme The signature scheme to use, to generate the private key
+     * @param args.legacy Whether to use a legacy authentication scheme, when applicable
+     * @returns An account compatible with the provided signature scheme
+     */
+    static generate(args?: GenerateEd25519AccountArgs): Ed25519Account;
+    static generate(args: GenerateEd25519SingleKeyAccountArgs): SingleKeyAccount;
+    static generate(args: GenerateSingleKeyAccountArgs): SingleKeyAccount;
+    static generate(args: GenerateAccountArgs): Account$1;
+    /**
+     * Creates an account from the provided private key.
+     *
+     * @param args.privateKey a valid private key
+     * @param args.address the account's address. If not provided, it will be derived from the public key.
+     * @param args.legacy Whether to use a legacy authentication scheme, when applicable
+     */
+    static fromPrivateKey(args: CreateEd25519AccountFromPrivateKeyArgs): Ed25519Account;
+    static fromPrivateKey(args: CreateEd25519SingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
+    static fromPrivateKey(args: CreateSingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
+    static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs): Account$1;
+    /**
+     * @deprecated use `fromPrivateKey` instead.
+     * Instantiates an account given a private key and a specified account address.
+     * This is primarily used to instantiate an `Account` that has had its authentication key rotated.
+     *
+     * @param args.privateKey PrivateKey - the underlying private key for the account
+     * @param args.address AccountAddress - The account address the `Account` will sign for
+     * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
+     * to generating a Legacy Ed25519 keypair
+     *
+     * @returns Account
+     */
+    static fromPrivateKeyAndAddress(args: CreateAccountFromPrivateKeyArgs): Account$1;
+    /**
+     * Derives an account with bip44 path and mnemonics
+     *
+     * @param args.scheme The signature scheme to derive the private key with
+     * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
+     * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
+     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
+     * @param args.mnemonic the mnemonic seed phrase of the account
+     */
+    static fromDerivationPath(args: GenerateEd25519AccountArgs & PrivateKeyFromDerivationPathArgs): Ed25519Account;
+    static fromDerivationPath(args: GenerateEd25519SingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;
+    static fromDerivationPath(args: GenerateSingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;
+    static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs): Account$1;
+    /**
+     * @deprecated use `publicKey.authKey()` instead.
+     * This key enables account owners to rotate their private key(s)
+     * associated with the account without changing the address that hosts their account.
+     * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}
+     *
+     * @param args.publicKey PublicKey - public key of the account
+     * @returns The authentication key for the associated account
+     */
+    static authKey(args: {
+        publicKey: AccountPublicKey;
+    }): AuthenticationKey;
+    /**
+     * Sign a transaction using the available signing capabilities.
+     * @param transaction the raw transaction
+     * @return the AccountAuthenticator containing the signature og the transaction, together with the account's public key
+     */
+    abstract signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticator;
+    /**
+     * Sign the given message with the private key.
+     * @param message in HexInput format
+     * @returns AccountSignature
+     */
+    abstract sign(message: HexInput): Signature;
+    abstract signTransaction(transaction: AnyRawTransaction): Signature;
+    /**
+     * @param args.message raw message data in HexInput format
+     * @param args.signature signed message signature
+     */
+    verifySignature(args: VerifySignatureArgs): boolean;
+}
+
+interface Ed25519SignerConstructorArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+}
+interface Ed25519SignerFromDerivationPathArgs {
+    path: string;
+    mnemonic: string;
+}
+interface VerifyEd25519SignatureArgs {
+    message: HexInput;
+    signature: Ed25519Signature;
+}
 /**
- * Interface of an View function's ABI.
+ * Signer implementation for the Ed25519 authentication scheme.
+ * This extends an {@link Ed25519Account} by adding signing capabilities through an {@link Ed25519PrivateKey}.
  *
- * This is used to provide type checking and simple input conversion on ABI based transaction submission.
+ * Note: Generating a signer instance does not create the account on-chain.
  */
-type ViewFunctionABI = FunctionABI & {
-    returnTypes: Array<TypeTag>;
+declare class Ed25519Account implements Account$1 {
+    /**
+     * Private key associated with the account
+     */
+    readonly privateKey: Ed25519PrivateKey;
+    readonly publicKey: Ed25519PublicKey;
+    readonly accountAddress: AccountAddress;
+    readonly signingScheme = SigningScheme.Ed25519;
+    constructor(args: Ed25519SignerConstructorArgs);
+    /**
+     * Derives a signer from a randomly generated private key
+     */
+    static generate(): Ed25519Account;
+    /**
+     * Derives an account with bip44 path and mnemonics
+     *
+     * @param args.path the BIP44 derive hardened path e.g. m/44'/637'/0'/0'/0'
+     * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
+     * @param args.mnemonic the mnemonic seed phrase of the account
+     */
+    static fromDerivationPath(args: Ed25519SignerFromDerivationPathArgs): Ed25519Account;
+    verifySignature(args: VerifyEd25519SignatureArgs): boolean;
+    signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorEd25519;
+    sign(message: HexInput): Ed25519Signature;
+    signTransaction(transaction: AnyRawTransaction): Ed25519Signature;
+}
+
+declare class EphemeralKeyPair extends Serializable {
+    readonly blinder: Uint8Array;
+    readonly expiryDateSecs: bigint | number;
+    readonly nonce: string;
+    private privateKey;
+    private publicKey;
+    constructor(args: {
+        privateKey: PrivateKey;
+        expiryDateSecs?: bigint | number;
+        blinder?: HexInput;
+    });
+    getPublicKey(): EphemeralPublicKey;
+    isExpired(): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): EphemeralKeyPair;
+    static fromBytes(bytes: Uint8Array): EphemeralKeyPair;
+    static generate(args?: {
+        scheme: SigningSchemeInput;
+    }): EphemeralKeyPair;
+    generateNonce(): string;
+    /**
+     * Sign the given message with the private key.
+     *   *
+     * @param data in HexInput format
+     * @returns EphemeralSignature
+     */
+    sign(data: HexInput): EphemeralSignature;
+}
+
+type ProofFetchSuccess = {
+    status: "Success";
 };
-/**
- * Interface of the arguments to generate a single signer transaction.
- * Used to provide to `generateTransaction()` method in the transaction builder flow
- */
-interface InputGenerateSingleSignerRawTransactionArgs {
-    aptosConfig: AptosConfig;
-    sender: AccountAddressInput;
-    payload: AnyTransactionPayloadInstance;
-    options?: InputGenerateTransactionOptions;
-    feePayerAddress?: AccountAddressInput;
+type ProofFetchFailure = {
+    status: "Failed";
+    error: string;
+};
+type ProofFetchStatus = ProofFetchSuccess | ProofFetchFailure;
+type ProofFetchCallback = (status: ProofFetchStatus) => Promise<void>;
+interface ProofFetchEvents {
+    proofFetchFinish: (status: ProofFetchStatus) => void;
+}
+declare class KeylessAccount implements Account$1 {
+    static readonly PEPPER_LENGTH: number;
+    static readonly SLIP_0010_SEED: string;
+    publicKey: KeylessPublicKey;
+    ephemeralKeyPair: EphemeralKeyPair;
+    uidKey: string;
+    uidVal: string;
+    aud: string;
+    pepper: Uint8Array;
+    accountAddress: AccountAddress;
+    proof: SignedGroth16Signature | undefined;
+    proofOrPromise: SignedGroth16Signature | Promise<SignedGroth16Signature>;
+    signingScheme: SigningScheme;
+    jwt: string;
+    emitter: EventEmitter<ProofFetchEvents>;
+    constructor(args: {
+        address?: AccountAddress;
+        ephemeralKeyPair: EphemeralKeyPair;
+        iss: string;
+        uidKey: string;
+        uidVal: string;
+        aud: string;
+        pepper: HexInput;
+        proofOrFetcher: SignedGroth16Signature | Promise<SignedGroth16Signature>;
+        proofFetchCallback?: ProofFetchCallback;
+        jwt: string;
+    });
+    init(promise: Promise<SignedGroth16Signature>): Promise<void>;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): KeylessAccount;
+    isExpired(): boolean;
+    bcsToBytes(): Uint8Array;
+    bcsToHex(): Hex;
+    signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey;
+    waitForProofFetch(): Promise<void>;
+    sign(data: HexInput): Signature;
+    signTransaction(transaction: AnyRawTransaction): Signature;
+    signWithOpenIdSignature(data: HexInput): Signature;
+    verifySignature(args: {
+        message: HexInput;
+        signature: Signature;
+    }): boolean;
+    static fromBytes(bytes: Uint8Array): KeylessAccount;
+    static fromJWTAndProof(args: {
+        proof: SignedGroth16Signature | Promise<SignedGroth16Signature>;
+        jwt: string;
+        ephemeralKeyPair: EphemeralKeyPair;
+        pepper: HexInput;
+        uidKey?: string;
+        proofFetchCallback?: ProofFetchCallback;
+    }): KeylessAccount;
+    static fromDerivationPath(path: string, seed: Uint8Array): Uint8Array;
 }
-/**
- * Interface of the arguments to generate a multi-agent transaction.
- * Used to provide to `generateTransaction()` method in the transaction builder flow
- */
-interface InputGenerateMultiAgentRawTransactionArgs {
-    aptosConfig: AptosConfig;
-    sender: AccountAddressInput;
-    payload: AnyTransactionPayloadInstance;
-    secondarySignerAddresses: AccountAddressInput[];
-    options?: InputGenerateTransactionOptions;
-    feePayerAddress?: AccountAddressInput;
+
+declare class MultiKeyAccount implements Account$1 {
+    /**
+     * Public key associated with the account
+     */
+    readonly publicKey: MultiKey;
+    /**
+     * Account address associated with the account
+     */
+    readonly accountAddress: AccountAddress;
+    /**
+     * Signing scheme used to sign transactions
+     */
+    readonly signingScheme: SigningScheme;
+    signers: Account$1[];
+    signaturesBitmap: Uint8Array;
+    /**
+     * constructor for Account
+     *
+     * Need to update this to use the new crypto library if new schemes are added.
+     *
+     * @param args.privateKey PrivateKey - private key of the account
+     * @param args.address AccountAddress - address of the account
+     * @param args.legacy optional. If set to false, the keypair authentication keys will be derived with a unified scheme.
+     * Defaults to deriving an authentication key with the legacy scheme.
+     *
+     * This method is private because it should only be called by the factory static methods.
+     * @returns Account
+     */
+    constructor(args: {
+        multiKey: MultiKey;
+        signers: Account$1[];
+    });
+    static fromPublicKeysAndSigners(args: {
+        publicKeys: PublicKey[];
+        signaturesRequired: number;
+        signers: Account$1[];
+    }): MultiKeyAccount;
+    static isMultiKeySigner(account: Account$1): account is MultiKeyAccount;
+    signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorMultiKey;
+    waitForProofFetch(): Promise<void>;
+    /**
+     * Sign the given message with the private key.
+     *
+     * TODO: Add sign transaction or specific types
+     *
+     * @param data in HexInput format
+     * @returns Signature
+     */
+    sign(data: HexInput): MultiSignature;
+    signTransaction(transaction: AnyRawTransaction): MultiSignature;
+    /**
+     * Verify the given message and signature with the public key.
+     *
+     * @param args.message raw message data in HexInput format
+     * @param args.signature signed message Signature
+     * @returns
+     */
+    verifySignature(args: {
+        message: HexInput;
+        signature: Signature;
+    }): boolean;
 }
+
 /**
- * Unified type that holds all the interfaces to generate different transaction types
- */
-type InputGenerateRawTransactionArgs = InputGenerateSingleSignerRawTransactionArgs | InputGenerateMultiAgentRawTransactionArgs;
-/**
- * Unified type that holds all the return interfaces when generating different transaction types
+ * A class to query all `Account` related queries on Aptos.
  */
-type AnyRawTransaction = SimpleTransaction | MultiAgentTransaction;
-type InputSimulateTransactionData = {
+declare class Account {
+    readonly config: AptosConfig;
+    constructor(config: AptosConfig);
+    /**
+     * Queries the current state for an Aptos account given its account address
+     *
+     * @param args.accountAddress Aptos account address
+     *
+     * @returns The account data
+     *
+     * @example An example of the returned account
+     * ```
+     * {
+     *    sequence_number: "1",
+     *    authentication_key: "0x5307b5f4bc67829097a8ba9b43dba3b88261eeccd1f709d9bde240fc100fbb69"
+     * }
+     * ```
+     */
+    getAccountInfo(args: {
+        accountAddress: AccountAddressInput;
+    }): Promise<AccountData>;
+    /**
+     * Queries for all modules in an account given an account address
+     *
+     * Note: In order to get all account modules, this function may call the API
+     * multiple times as it auto paginates.
+     *
+     * @param args.accountAddress Aptos account address
+     * @param args.options.offset The number module to start returning results from
+     * @param args.options.limit The number of results to return
+     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+     *
+     * @returns Account modules
+     */
+    getAccountModules(args: {
+        accountAddress: AccountAddressInput;
+        options?: PaginationArgs & LedgerVersionArg;
+    }): Promise<MoveModuleBytecode[]>;
+    /**
+     * Queries for a specific account module given account address and module name
+     *
+     * @param args.accountAddress Aptos account address
+     * @param args.moduleName The name of the module
+     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+     *
+     * @returns Account module
+     *
+     * @example
+     * const module = await aptos.getAccountModule({accountAddress:"0x456"})
+     * // An example of an account module response
+     * ```
+     * {
+     *    bytecode: "0xa11ceb0b0600000006010002030206050807070f0d081c200",
+     *    abi: { address: "0x1" }
+     * }
+     * ```
+     */
+    getAccountModule(args: {
+        accountAddress: AccountAddressInput;
+        moduleName: string;
+        options?: LedgerVersionArg;
+    }): Promise<MoveModuleBytecode>;
+    /**
+     * Queries account transactions given an account address
+     *
+     * Note: In order to get all account transactions, this function may call the API
+     * multiple times as it auto paginates.
+     *
+     * @example
+     * const transactions = await aptos.getAccountTransactions({accountAddress:"0x456"})
+     *
+     * @param args.accountAddress Aptos account address
+     * @param args.options.offset The number transaction to start returning results from
+     * @param args.options.limit The number of results to return
+     *
+     * @returns The account transactions
+     */
+    getAccountTransactions(args: {
+        accountAddress: AccountAddressInput;
+        options?: PaginationArgs;
+    }): Promise<TransactionResponse[]>;
+    /**
+     * Queries all account resources given an account address
+     *
+     * Note: In order to get all account resources, this function may call the API
+     * multiple times as it auto paginates.
+     *
+     * @example
+     * const resources = await aptos.getAccountResources({accountAddress:"0x456"})
+     *
+     * @param args.accountAddress Aptos account address
+     * @param args.options.offset The number resource to start returning results from
+     * @param args.options.limit The number of results to return
+     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+     * @returns Account resources
+     */
+    getAccountResources(args: {
+        accountAddress: AccountAddressInput;
+        options?: PaginationArgs & LedgerVersionArg;
+    }): Promise<MoveResource[]>;
+    /**
+     * Queries a specific account resource given account address and resource type. Note that the default is `any` in order
+     * to allow for ease of accessing properties of the object.
+     *
+     * @type The typed output of the resource
+     * @param args.accountAddress Aptos account address
+     * @param args.resourceType String representation of an on-chain Move struct type, i.e "0x1::aptos_coin::AptosCoin"
+     * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+     *
+     * @returns Account resource
+     *
+     * @example
+     * const resource = await aptos.getAccountResource({accountAddress:"0x456"})
+     *
+     */
+    getAccountResource<T extends {} = any>(args: {
+        accountAddress: AccountAddressInput;
+        resourceType: MoveStructId;
+        options?: LedgerVersionArg;
+    }): Promise<T>;
+    /**
+     * Looks up the account address for a given authentication key
+     *
+     * This handles both if the account's authentication key has been rotated or not.
+     *
+     * @example
+     * const accountAddress = await aptos.lookupOriginalAccountAddress({authenticationKey:account.accountAddress})
+     *
+     * @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;
+        minimumLedgerVersion?: AnyNumber;
+        options?: LedgerVersionArg;
+    }): Promise<AccountAddress>;
+    /**
+     * Queries the current count of tokens owned by an account
+     *
+     * @example
+     * const tokensCount = await aptos.getAccountTokensCount({accountAddress:"0x456"})
+     *
+     * @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>;
     /**
-     * The transaction to simulate, probably generated by `generateTransaction()`
+     * Queries the account's current owned tokens.
+     *
+     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
+     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
+     *
+     * @example
+     * const accountOwnedTokens = await aptos.getAccountOwnedTokens({accountAddress:"0x456"})
+     *
+     * @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.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
      */
-    transaction: AnyRawTransaction;
+    getAccountOwnedTokens(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;
+    }): Promise<GetAccountOwnedTokensQueryResponse>;
     /**
-     * For a single signer transaction
+     * Queries all current tokens of a specific collection that an account owns by the collection address
+     *
+     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
+     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
+     *
+     * @example
+     * const accountOwnedTokens = await aptos.getAccountOwnedTokensFromCollectionAddress({accountAddress:"0x123", collectionAddress:"0x456"})
+     *
+     * @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.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
      */
-    signerPublicKey: PublicKey;
+    getAccountOwnedTokensFromCollectionAddress(args: {
+        accountAddress: AccountAddressInput;
+        collectionAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;
+    }): Promise<GetAccountOwnedTokensFromCollectionResponse>;
     /**
-     * For a fee payer or multi-agent transaction that requires additional signers in
+     * Queries for all collections that an account currently has tokens for.
+     *
+     * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.
+     * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
+     *
+     * @example
+     * const accountCollectionsWithOwnedTokens = await aptos.getAccountCollectionsWithOwnedTokens({accountAddress:"0x123"})
+     *
+     * @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.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
      */
-    secondarySignersPublicKeys?: Array<PublicKey>;
+    getAccountCollectionsWithOwnedTokens(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+        options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;
+    }): Promise<GetAccountCollectionsWithOwnedTokenResponse>;
     /**
-     * For a fee payer transaction (aka Sponsored Transaction)
+     * Queries the current count of transactions submitted by an account
+     *
+     * @example
+     * const accountTransactionsCount = await aptos.getAccountTransactionsCount({accountAddress:"0x123"})
+     *
+     * @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
      */
-    feePayerPublicKey?: PublicKey;
-    options?: InputSimulateTransactionOptions;
-};
-type InputSimulateTransactionOptions = {
-    estimateGasUnitPrice?: boolean;
-    estimateMaxGasAmount?: boolean;
-    estimatePrioritizedGasUnitPrice?: boolean;
-};
-/**
- * Interface that holds the user data input when generating a single signer transaction
- */
-interface InputGenerateSingleSignerRawTransactionData {
-    sender: AccountAddressInput;
-    data: InputGenerateTransactionPayloadData;
-    options?: InputGenerateTransactionOptions;
-    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;
-    withFeePayer?: boolean;
-}
-/**
- * Unified type that holds all the user data input interfaces when generating different transaction types
- */
-type InputGenerateTransactionData = InputGenerateSingleSignerRawTransactionData | InputGenerateMultiAgentRawTransactionData;
-/**
- * Interface that holds the user data input when submitting a transaction
- */
-interface InputSubmitTransactionData {
-    transaction: AnyRawTransaction;
-    senderAuthenticator: AccountAuthenticator;
-    feePayerAuthenticator?: AccountAuthenticator;
-    additionalSignersAuthenticators?: Array<AccountAuthenticator>;
+    getAccountTransactionsCount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
+    /**
+     * Queries an account's coins data
+     *
+     * @example
+     * const accountCoinsData = await aptos.getAccountCoinsData({accountAddress:"0x123"})
+     *
+     * @param args.accountAddress The account address we want to get the coins data for
+     * @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;
+        minimumLedgerVersion?: AnyNumber;
+        options?: PaginationArgs & OrderByArg<GetAccountCoinsDataResponse[0]> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
+    }): Promise<GetAccountCoinsDataResponse>;
+    /**
+     * Queries the current count of an account's coins aggregated
+     *
+     * @example
+     * const accountCoinsCount = await aptos.getAccountCoinsCount({accountAddress:"0x123"})
+     *
+     * @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 the account's APT amount
+     *
+     * @example
+     * const accountAPTAmount = await aptos.getAccountAPTAmount({accountAddress:"0x123"})
+     *
+     * @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
+     */
+    getAccountAPTAmount(args: {
+        accountAddress: AccountAddressInput;
+        minimumLedgerVersion?: AnyNumber;
+    }): Promise<number>;
+    /**
+     * Queries the account's coin amount by the coin type
+     *
+     * @example
+     * const accountCoinAmount = await aptos.getAccountCoinAmount({accountAddress:"0x123", coinType:"0x1::aptos_coin::AptosCoin"})
+     *
+     * @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
+     *
+     * @example
+     * const accountOwnedObjects = await aptos.getAccountOwnedObjects({accountAddress:"0x123"})
+     *
+     * @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.
+     * This functions resolves the provided private key type and derives the public key from it.
+     *
+     * If the privateKey is a Secp256k1 type, it derives the account using the derived public key and
+     * auth key using the SingleKey scheme locally.
+     *
+     * If the privateKey is a ED25519 type, it looks up the authentication key on chain, and uses it to resolve
+     * whether it is a Legacy ED25519 key or a Unified ED25519 key. It then derives the account based
+     * on that.
+     *
+     * @example
+     * const account = await aptos.deriveAccountFromPrivateKey({privateKey:new Ed25519PrivateKey("0x123")})
+     *
+     * @param args.privateKey An account private key
+     * @returns Account type
+     */
+    deriveAccountFromPrivateKey(args: {
+        privateKey: PrivateKey;
+    }): Promise<Account$1>;
 }
 
 /**
@@ -5992,18 +6415,6 @@ declare function buildTransaction(args: InputGenerateMultiAgentRawTransactionArg
  */
 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
  *
@@ -6025,14 +6436,15 @@ declare function hashValues(input: (Uint8Array | string)[]): Uint8Array;
  */
 declare function generateUserTransactionHash(args: InputSubmitTransactionData): string;
 /**
- * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction
+ * Generate a multi signers signed transaction that can be submitted to chain
  *
- * @param transaction A aptos transaction type
+ * @param transaction MultiAgentRawTransaction | FeePayerRawTransaction
+ * @param senderAuthenticator The account authenticator of the transaction sender
+ * @param secondarySignerAuthenticators The extra signers account Authenticators
  *
- * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
+ * @returns A SignedTransaction
  */
-declare function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance;
-declare function generateSigningMessage(transaction: AnyRawTransaction): Uint8Array;
+declare function generateMultiSignersSignedTransaction(transaction: MultiAgentRawTransaction | FeePayerRawTransaction, senderAuthenticator: AccountAuthenticator, feePayerAuthenticator?: AccountAuthenticator, additionalSignersAuthenticators?: Array<AccountAuthenticator>): Uint8Array;
 
 /**
  * Convert type arguments to only type tags, allowing for string representations of type tags
@@ -6074,6 +6486,18 @@ declare function fetchViewFunctionAbi(moduleAddress: string, moduleName: string,
 declare function convertArgument(functionName: string, functionAbi: FunctionABI, arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes, position: number, genericTypeParams: Array<TypeTag>): EntryFunctionArgumentTypes;
 declare function checkOrConvertArgument(arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes, param: TypeTag, position: number, genericTypeParams: Array<TypeTag>): EntryFunctionArgumentTypes;
 
+/**
+ * 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;
+declare function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array;
+declare function generateSigningMessageForSerializable(obj: Serializable): Uint8Array;
+declare function generateSigningMessageForTransaction(transaction: AnyRawTransaction): Uint8Array;
+
 declare enum TypeTagParserErrorType {
     InvalidTypeTag = "unknown type",
     UnexpectedGenericType = "unexpected generic type",
@@ -7377,6 +7801,32 @@ declare class Transaction {
     }): Promise<PendingTransactionResponse>;
 }
 
+/**
+ * A class to query all `OIDB` related queries on Aptos.
+ */
+declare class Keyless {
+    readonly config: AptosConfig;
+    constructor(config: AptosConfig);
+    /**
+     * TODO
+     *
+     * @param args.jwt jwt token
+     * @returns The pepper
+     */
+    getPepper(args: {
+        jwt: string;
+        ephemeralKeyPair: EphemeralKeyPair;
+    }): Promise<Uint8Array>;
+    deriveKeylessAccount(args: {
+        jwt: string;
+        ephemeralKeyPair: EphemeralKeyPair;
+        uidKey?: string;
+        pepper?: HexInput;
+        extraFieldKey?: string;
+        proofFetchCallback?: ProofFetchCallback;
+    }): Promise<KeylessAccount>;
+}
+
 /**
  * This class is the main entry point into Aptos's
  * APIs and separates functionality into different namespaces.
@@ -7400,9 +7850,10 @@ declare class Aptos {
     readonly general: General;
     readonly staking: Staking;
     readonly transaction: Transaction;
+    readonly keyless: Keyless;
     constructor(settings?: AptosConfig);
 }
-interface Aptos extends Account, ANS, Coin, DigitalAsset, Event, Faucet, FungibleAsset, General, Staking, Omit<Transaction, "build" | "simulate" | "submit" | "batch"> {
+interface Aptos extends Account, ANS, Coin, DigitalAsset, Event, Faucet, FungibleAsset, General, Keyless, Staking, Omit<Transaction, "build" | "simulate" | "submit" | "batch"> {
 }
 
 /**
@@ -7513,6 +7964,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 getAptosPepperService<Req extends {}, Res extends {}>(options: GetAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
 declare function paginateWithCursor<Req extends Record<string, any>, Res extends Array<{}>>(options: GetAptosRequestOptions): Promise<Res>;
 
 type PostRequestOptions = {
@@ -7564,5 +8016,7 @@ declare function post<Req extends {}, Res extends {}>(options: PostRequestOption
 declare function postAptosFullNode<Req extends {}, Res extends {}>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
 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 postAptosPepperService<Req extends {}, Res extends {}>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
+declare function postAptosProvingService<Req extends {}, Res extends {}>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>>;
 
-export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_HARDENED_REGEX, Account$1 as Account, AccountAddress, type AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountAuthenticatorVariant, type AccountData, AccountPublicKey, AccountSequenceNumber, type AccountSignature, AddressInvalidReason, type AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, AnySignatureVariant, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, type AptosRequest, type AptosResponse, type AptosSettings, AuthenticationKey, type AuthenticationKeyScheme, type Block, type BlockMetadataTransactionResponse, Bool, CKDPriv, ChainId, type Client, type ClientConfig, type ClientHeadersType, type ClientRequest, type ClientResponse, type CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DecodedTableData, type DeletedTableData, DeriveScheme, type DerivedKeys, type Deserializable, type DeserializableClass, Deserializer, type DirectWriteSet, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, type EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, type EntryFunctionPayloadResponse, type Event$1 as Event, type EventGuid, type ExecutionFinishEventData, type FailureEventData, type FaucetConfig, FeePayerRawTransaction, FixedBytes, type FullNodeConfig, type FunctionABI, type GasEstimation, type GenerateAccount, type GenerateAccountArgs, type GenerateAccountWithEd25519, type GenerateAccountWithSingleSignerSecp256k1Key, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, type GenesisPayload, type GenesisTransactionResponse, type GetANSNameResponse, type GetAccountCoinsDataResponse, type GetAccountCollectionsWithOwnedTokenResponse, type GetAccountOwnedObjectsResponse, type GetAccountOwnedTokensFromCollectionResponse, type GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, type GetChainTopUserTransactionsResponse, type GetCollectionDataResponse, type GetCurrentFungibleAssetBalancesResponse, type GetCurrentTokenOwnershipResponse, type GetDelegatedStakingActivitiesResponse, type GetEventsResponse, type GetFungibleAssetActivitiesResponse, type GetFungibleAssetMetadataResponse, type GetNumberOfDelegatorsResponse, type GetOwnedTokensResponse, type GetProcessorStatusResponse, type GetRequestOptions, type GetTokenActivityResponse, type GetTokenDataResponse, type GraphqlQuery, HARDENED_OFFSET, Hex, type HexInput, HexInvalidReason, Identifier, type IndexerConfig, type InputEntryFunctionData, type InputEntryFunctionDataWithABI, type InputEntryFunctionDataWithRemoteABI, type InputGenerateMultiAgentRawTransactionArgs, type InputGenerateMultiAgentRawTransactionData, type InputGenerateRawTransactionArgs, type InputGenerateSingleSignerRawTransactionArgs, type InputGenerateSingleSignerRawTransactionData, type InputGenerateTransactionData, type InputGenerateTransactionOptions, type InputGenerateTransactionPayloadData, type InputGenerateTransactionPayloadDataWithABI, type InputGenerateTransactionPayloadDataWithRemoteABI, type InputMultiSigData, type InputMultiSigDataWithABI, type InputMultiSigDataWithRemoteABI, type InputScriptData, type InputSimulateTransactionData, type InputSimulateTransactionOptions, type InputSubmitTransactionData, type InputViewFunctionData, type InputViewFunctionDataWithABI, type InputViewFunctionDataWithRemoteABI, KeyType, type LedgerInfo, type LedgerVersionArg, MimeType, ModuleId, MoveAbility, type MoveAddressType, type MoveFunction, type MoveFunctionGenericTypeParam, type MoveFunctionId, MoveFunctionVisibility, type MoveModule, type MoveModuleBytecode, type MoveModuleId, type MoveObjectType, MoveOption, type MoveOptionType, type MoveResource, type MoveScriptBytecode, MoveString, type MoveStruct, type MoveStructField, type MoveStructId, type MoveStructType, type MoveType, type MoveUint128Type, type MoveUint16Type, type MoveUint256Type, type MoveUint32Type, type MoveUint64Type, type MoveUint8Type, type MoveValue, MoveVector, MultiAgentRawTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeySignature, MultiSig, MultiSigTransactionPayload, type MultisigPayloadResponse, Network, NetworkToChainId, NetworkToFaucetAPI, NetworkToIndexerAPI, NetworkToNetworkName, NetworkToNodeAPI, type OrderBy, type OrderByArg, type OrderByValue, type PaginationArgs, ParsingError, type ParsingResult, type PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, type PrivateKey, type PrivateKeyFromDerivationPathArgs, ProcessorType, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RoleType, RotationProofChallenge, Script, type ScriptFunctionArgument, type ScriptFunctionArgumentTypes, type ScriptPayloadResponse, ScriptTransactionArgumentVariants, type ScriptWriteSet, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, type StateCheckpointTransactionResponse, StructTag, type SuccessEventData, type TableItemRequest, type TokenStandard, type TokenStandardArg, type TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionAuthenticatorVariant, type TransactionEd25519Signature, type TransactionFeePayerSignature, type TransactionMultiAgentSignature, type TransactionMultiEd25519Signature, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, type TransactionPayloadResponse, TransactionPayloadScript, TransactionPayloadVariants, type TransactionResponse, TransactionResponseType, type TransactionSecp256k1Signature, type TransactionSignature, TransactionVariants, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVariants, TypeTagVector, U128, U16, U256, U32, U64, U8, type Uint128, type Uint16, type Uint256, type Uint32, type Uint64, type Uint8, type UserTransactionResponse, type ValidatorTransactionResponse, type VerifyEd25519SignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewFunctionABI, type WaitForTransactionOptions, type WhereArg, type WriteSet, type WriteSetChange, type WriteSetChangeDeleteModule, type WriteSetChangeDeleteResource, type WriteSetChangeDeleteTableItem, type WriteSetChangeWriteModule, type WriteSetChangeWriteResource, type WriteSetChangeWriteTableItem, aptosCoinStructTag, aptosRequest, buildTransaction, checkOrConvertArgument, convertArgument, createObjectAddress, createResourceAddress, createTokenAddress, deriveKey, deriveTransactionType, deserializeFromScriptArgument, ensureBoolean, fetchEntryFunctionAbi, fetchFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAuthenticatorForSimulation, getFunctionParts, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBlockMetadataTransactionResponse, isBool, isEd25519Signature, isEncodedEntryFunctionArgument, isFeePayerSignature, isGenesisTransactionResponse, isLargeNumber, isMultiAgentSignature, isMultiEd25519Signature, isNull, isNumber, isPendingTransactionResponse, isScriptDataInput, isSecp256k1Signature, isStateCheckpointTransactionResponse, isString, isUserTransactionResponse, isValidBIP44Path, isValidHardenedPath, isValidatorTransactionResponse, mnemonicToSeed, normalizeBundle, objectStructTag, optionStructTag, outOfRangeErrorMessage, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, promiseFulfilledStatus, request, sign, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch, validateNumberInRange };
+export { APTOS_BIP44_DEFAULT_DERIVATION_PATH, APTOS_BIP44_REGEX, APTOS_COIN, APTOS_HARDENED_REGEX, Account$1 as Account, AccountAddress, type AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountAuthenticatorVariant, type AccountData, AccountPublicKey, AccountSequenceNumber, type AccountSignature, AddressInvalidReason, type AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, AnySignatureVariant, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, type AptosRequest, type AptosResponse, type AptosSettings, AuthenticationKey, type AuthenticationKeyScheme, type Block, type BlockMetadataTransactionResponse, Bool, CKDPriv, ChainId, type Client, type ClientConfig, type ClientHeadersType, type ClientRequest, type ClientResponse, type CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DecodedTableData, type DeletedTableData, DeriveScheme, type DerivedKeys, type Deserializable, type DeserializableClass, Deserializer, type DirectWriteSet, EPK_HORIZON_SECS, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, type EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, type EntryFunctionPayloadResponse, EphemeralCertificate, EphemeralKeyPair, EphemeralPublicKey, EphemeralPublicKeyVariant, EphemeralSignature, EphemeralSignatureVariant, type Event$1 as Event, type EventGuid, type ExecutionFinishEventData, type FailureEventData, type FaucetConfig, FeePayerRawTransaction, FixedBytes, type FullNodeConfig, type FunctionABI, type GasEstimation, type GenerateAccount, type GenerateAccountArgs, type GenerateAccountWithEd25519, type GenerateAccountWithSingleSignerSecp256k1Key, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, type GenesisPayload, type GenesisTransactionResponse, type GetANSNameResponse, type GetAccountCoinsDataResponse, type GetAccountCollectionsWithOwnedTokenResponse, type GetAccountOwnedObjectsResponse, type GetAccountOwnedTokensFromCollectionResponse, type GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, type GetChainTopUserTransactionsResponse, type GetCollectionDataResponse, type GetCurrentFungibleAssetBalancesResponse, type GetCurrentTokenOwnershipResponse, type GetDelegatedStakingActivitiesResponse, type GetEventsResponse, type GetFungibleAssetActivitiesResponse, type GetFungibleAssetMetadataResponse, type GetNumberOfDelegatorsResponse, type GetOwnedTokensResponse, type GetProcessorStatusResponse, type GetRequestOptions, type GetTokenActivityResponse, type GetTokenDataResponse, type GraphqlQuery, Groth16Zkp, HARDENED_OFFSET, Hex, type HexInput, HexInvalidReason, Identifier, type IndexerConfig, type InputEntryFunctionData, type InputEntryFunctionDataWithABI, type InputEntryFunctionDataWithRemoteABI, type InputGenerateMultiAgentRawTransactionArgs, type InputGenerateMultiAgentRawTransactionData, type InputGenerateRawTransactionArgs, type InputGenerateSingleSignerRawTransactionArgs, type InputGenerateSingleSignerRawTransactionData, type InputGenerateTransactionData, type InputGenerateTransactionOptions, type InputGenerateTransactionPayloadData, type InputGenerateTransactionPayloadDataWithABI, type InputGenerateTransactionPayloadDataWithRemoteABI, type InputMultiSigData, type InputMultiSigDataWithABI, type InputMultiSigDataWithRemoteABI, type InputScriptData, type InputSimulateTransactionData, type InputSimulateTransactionOptions, type InputSubmitTransactionData, type InputViewFunctionData, type InputViewFunctionDataWithABI, type InputViewFunctionDataWithRemoteABI, KeyType, KeylessAccount, KeylessPublicKey, KeylessSignature, type LedgerInfo, type LedgerVersionArg, MAX_AUD_VAL_BYTES, MAX_COMMITED_EPK_BYTES, MAX_EXTRA_FIELD_BYTES, MAX_ISS_VAL_BYTES, MAX_JWT_HEADER_B64_BYTES, MAX_UID_KEY_BYTES, MAX_UID_VAL_BYTES, MimeType, ModuleId, MoveAbility, type MoveAddressType, type MoveFunction, type MoveFunctionGenericTypeParam, type MoveFunctionId, MoveFunctionVisibility, type MoveModule, type MoveModuleBytecode, type MoveModuleId, type MoveObjectType, MoveOption, type MoveOptionType, type MoveResource, type MoveScriptBytecode, MoveString, type MoveStruct, type MoveStructField, type MoveStructId, type MoveStructType, type MoveType, type MoveUint128Type, type MoveUint16Type, type MoveUint256Type, type MoveUint32Type, type MoveUint64Type, type MoveUint8Type, type MoveValue, MoveVector, MultiAgentRawTransaction, MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeyAccount, MultiSig, MultiSigTransactionPayload, MultiSignature, type MultisigPayloadResponse, Network, NetworkToChainId, NetworkToFaucetAPI, NetworkToIndexerAPI, NetworkToNetworkName, NetworkToNodeAPI, NetworkToPepperAPI, NetworkToProverAPI, OpenIdSignature, OpenIdSignatureOrZkProof, type OrderBy, type OrderByArg, type OrderByValue, type PaginationArgs, ParsingError, type ParsingResult, type PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, type PrivateKey, type PrivateKeyFromDerivationPathArgs, ProcessorType, type ProofFetchCallback, type ProofFetchEvents, type ProofFetchFailure, type ProofFetchStatus, type ProofFetchSuccess, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RoleType, RotationProofChallenge, Script, type ScriptFunctionArgument, type ScriptFunctionArgumentTypes, type ScriptPayloadResponse, ScriptTransactionArgumentVariants, type ScriptWriteSet, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedGroth16Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, type StateCheckpointTransactionResponse, StructTag, type SuccessEventData, type TableItemRequest, type TokenStandard, type TokenStandardArg, type TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionAuthenticatorVariant, type TransactionEd25519Signature, type TransactionFeePayerSignature, type TransactionMultiAgentSignature, type TransactionMultiEd25519Signature, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, type TransactionPayloadResponse, TransactionPayloadScript, TransactionPayloadVariants, type TransactionResponse, TransactionResponseType, type TransactionSecp256k1Signature, type TransactionSignature, TransactionVariants, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVariants, TypeTagVector, U128, U16, U256, U32, U64, U8, type Uint128, type Uint16, type Uint256, type Uint32, type Uint64, type Uint8, type UserTransactionResponse, type ValidatorTransactionResponse, type VerifyEd25519SignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewFunctionABI, type WaitForTransactionOptions, type WhereArg, type WriteSet, type WriteSetChange, type WriteSetChangeDeleteModule, type WriteSetChangeDeleteResource, type WriteSetChangeDeleteTableItem, type WriteSetChangeWriteModule, type WriteSetChangeWriteResource, type WriteSetChangeWriteTableItem, aptosCoinStructTag, aptosRequest, buildTransaction, checkOrConvertArgument, computeAddressSeed, convertArgument, deriveKey, deriveTransactionType, deserializeFromScriptArgument, ensureBoolean, fetchEntryFunctionAbi, fetchFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, fromDerivationPath, generateMultiSignersSignedTransaction, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateSigningMessageForSerializable, generateSigningMessageForTransaction, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAptosPepperService, getAuthenticatorForSimulation, getFunctionParts, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBlockMetadataTransactionResponse, isBool, isEd25519Signature, isEncodedEntryFunctionArgument, isFeePayerSignature, isGenesisTransactionResponse, isLargeNumber, isMultiAgentSignature, isMultiEd25519Signature, isNull, isNumber, isPendingTransactionResponse, isScriptDataInput, isSecp256k1Signature, isStateCheckpointTransactionResponse, isString, isUserTransactionResponse, isValidBIP44Path, isValidHardenedPath, isValidatorTransactionResponse, mnemonicToSeed, normalizeBundle, objectStructTag, optionStructTag, outOfRangeErrorMessage, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, postAptosPepperService, postAptosProvingService, promiseFulfilledStatus, request, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch, validateNumberInRange };