@aptos-labs/ts-sdk 1.16.0 → 1.17.0-zeta.1

package/dist/common/index.d.ts

@@ -1,5 +1,5 @@
-import { S as Serializable, T as TransactionArgument, H as HexInput, a as Serializer, D as Deserializer, E as EntryFunctionArgument, U as Uint8, b as Uint16, c as Uint32, A as AnyNumber, d as Deserializable, e as Hex, f as AuthenticationKeyScheme, g as AccountAddress, h as AnyPublicKeyVariant, N as Network, C as Client, i as ClientConfig, F as FullNodeConfig, I as IndexerConfig, j as FaucetConfig, k as AptosSettings, M as MoveModuleId, l as ScriptFunctionArgument, m as MoveFunctionId, n as AccountAddressInput, o as MoveFunctionGenericTypeParam, p as SigningSchemeInput, q as SigningScheme, r as AccountData, P as PaginationArgs, L as LedgerVersionArg, s as MoveModuleBytecode, t as TransactionResponse, u as MoveResource, v as MoveStructId, w as TokenStandardArg, O as OrderByArg, G as GetAccountOwnedTokensQueryResponse, x as GetAccountOwnedTokensFromCollectionResponse, y as GetAccountCollectionsWithOwnedTokenResponse, z as GetAccountCoinsDataResponse, W as WhereArg, B as GetAccountOwnedObjectsResponse, J as GetCollectionDataResponse, K as GetTokenDataResponse, Q as GetCurrentTokenOwnershipResponse, R as GetOwnedTokensResponse, V as GetTokenActivityResponse, X as GetEventsResponse, Y as WaitForTransactionOptions, Z as UserTransactionResponse, _ as MoveFunction, $ as GetFungibleAssetMetadataResponse, a0 as GetFungibleAssetActivitiesResponse, a1 as GetCurrentFungibleAssetBalancesResponse, a2 as LedgerInfo, a3 as Block, a4 as MoveValue, a5 as GetChainTopUserTransactionsResponse, a6 as GraphqlQuery, a7 as GetProcessorStatusResponse, a8 as GetANSNameResponse, a9 as GetNumberOfDelegatorsResponse, aa as GetDelegatedStakingActivitiesResponse, ab as PendingTransactionResponse, ac as CommittedTransactionResponse, ad as GasEstimation, ae as TableItemRequest, af as GetTableItemsDataResponse, ag as GetTableItemsMetadataResponse, ah as AptosRequest, ai as ClientRequest, aj as ClientResponse, ak as MimeType } from './accountAddress-ccLvlUQe.js';
-export { ax as AccountAuthenticatorVariant, bc as AccountSignature, ao as AddressInvalidReason, ay as AnySignatureVariant, aL as BlockMetadataTransactionResponse, aC as ClientHeadersType, aV as DecodedTableData, aW as DeletedTableData, bz as DeriveScheme, bf as DirectWriteSet, aY as EntryFunctionPayloadResponse, bh as Event, bg as EventGuid, bC as GenerateAccount, bA as GenerateAccountWithEd25519, bB as GenerateAccountWithSingleSignerSecp256k1Key, a$ as GenesisPayload, aK as GenesisTransactionResponse, ar as HexInvalidReason, bu as MoveAbility, bo as MoveAddressType, bt as MoveFunctionVisibility, bw as MoveModule, bp as MoveObjectType, bq as MoveOptionType, b0 as MoveScriptBytecode, bx as MoveStruct, bv as MoveStructField, br as MoveStructType, bs as MoveType, bm as MoveUint128Type, bj as MoveUint16Type, bn as MoveUint256Type, bk as MoveUint32Type, bl as MoveUint64Type, bi as MoveUint8Type, a_ as MultisigPayloadResponse, bJ as NetworkToChainId, bI as NetworkToFaucetAPI, bG as NetworkToIndexerAPI, bK as NetworkToNetworkName, bH as NetworkToNodeAPI, bD as OrderBy, bE as OrderByValue, ap as ParsingError, aq as ParsingResult, by as RoleType, aZ as ScriptPayloadResponse, at as ScriptTransactionArgumentVariants, be as ScriptWriteSet, aM as StateCheckpointTransactionResponse, bF as TokenStandard, aw as TransactionAuthenticatorVariant, b7 as TransactionEd25519Signature, bb as TransactionFeePayerSignature, ba as TransactionMultiAgentSignature, b9 as TransactionMultiEd25519Signature, aX as TransactionPayloadResponse, au as TransactionPayloadVariants, aD as TransactionResponseType, b8 as TransactionSecp256k1Signature, b1 as TransactionSignature, av as TransactionVariants, as as TypeTagVariants, aA as Uint128, aB as Uint256, az as Uint64, aN as ValidatorTransactionResponse, bd as WriteSet, aO as WriteSetChange, aP as WriteSetChangeDeleteModule, aQ as WriteSetChangeDeleteResource, aR as WriteSetChangeDeleteTableItem, aS as WriteSetChangeWriteModule, aT as WriteSetChangeWriteResource, aU as WriteSetChangeWriteTableItem, al as ensureBoolean, aH as isBlockMetadataTransactionResponse, b2 as isEd25519Signature, b5 as isFeePayerSignature, aG as isGenesisTransactionResponse, b4 as isMultiAgentSignature, b6 as isMultiEd25519Signature, aE as isPendingTransactionResponse, b3 as isSecp256k1Signature, aI as isStateCheckpointTransactionResponse, aF as isUserTransactionResponse, aJ as isValidatorTransactionResponse, am as outOfRangeErrorMessage, an as validateNumberInRange } from './accountAddress-ccLvlUQe.js';
+import { S as Serializable, T as TransactionArgument, H as HexInput, a as Serializer, D as Deserializer, E as EntryFunctionArgument, U as Uint8, b as Uint16, c as Uint32, A as AnyNumber, d as Deserializable, e as Hex, f as AuthenticationKeyScheme, g as AccountAddress, h as AnyPublicKeyVariant, i as EphemeralPublicKeyVariant, N as Network, C as Client, j as ClientConfig, F as FullNodeConfig, I as IndexerConfig, k as FaucetConfig, l as AptosSettings, m as EphemeralCertificateVariant, Z as ZkpVariant, L as LedgerVersionArg, M as MoveModuleId, n as ScriptFunctionArgument, o as MoveFunctionId, p as AccountAddressInput, q as MoveFunctionGenericTypeParam, r as SigningSchemeInput, s as SigningScheme, t as AccountData, P as PaginationArgs, u as MoveModuleBytecode, v as TransactionResponse, w as MoveResource, x as MoveStructId, y as TokenStandardArg, O as OrderByArg, G as GetAccountOwnedTokensQueryResponse, z as GetAccountOwnedTokensFromCollectionResponse, B as GetAccountCollectionsWithOwnedTokenResponse, J as GetAccountCoinsDataResponse, W as WhereArg, K as GetAccountOwnedObjectsResponse, Q as GetCollectionDataResponse, R as GetTokenDataResponse, V as GetCurrentTokenOwnershipResponse, X as GetOwnedTokensResponse, Y as GetTokenActivityResponse, _ as GetEventsResponse, $ as WaitForTransactionOptions, a0 as UserTransactionResponse, a1 as MoveFunction, a2 as GetFungibleAssetMetadataResponse, a3 as GetFungibleAssetActivitiesResponse, a4 as GetCurrentFungibleAssetBalancesResponse, a5 as LedgerInfo, a6 as Block, a7 as MoveValue, a8 as GetChainTopUserTransactionsResponse, a9 as GraphqlQuery, aa as GetProcessorStatusResponse, ab as GetANSNameResponse, ac as GetNumberOfDelegatorsResponse, ad as GetDelegatedStakingActivitiesResponse, ae as PendingTransactionResponse, af as CommittedTransactionResponse, ag as GasEstimation, ah as TableItemRequest, ai as GetTableItemsDataResponse, aj as GetTableItemsMetadataResponse, ak as AptosRequest, al as ClientRequest, am as ClientResponse, an as MimeType } from './accountAddress-jP2Ua0t9.js';
+export { aA as AccountAuthenticatorVariant, bg as AccountSignature, ar as AddressInvalidReason, aB as AnySignatureVariant, aP as BlockMetadataTransactionResponse, aG as ClientHeadersType, aZ as DecodedTableData, a_ as DeletedTableData, bD as DeriveScheme, bj as DirectWriteSet, b0 as EntryFunctionPayloadResponse, aC as EphemeralSignatureVariant, bl as Event, bk as EventGuid, bG as GenerateAccount, bE as GenerateAccountWithEd25519, bF as GenerateAccountWithSingleSignerSecp256k1Key, b3 as GenesisPayload, aO as GenesisTransactionResponse, au as HexInvalidReason, by as MoveAbility, bs as MoveAddressType, bx as MoveFunctionVisibility, bA as MoveModule, bt as MoveObjectType, bu as MoveOptionType, b4 as MoveScriptBytecode, bB as MoveStruct, bz as MoveStructField, bv as MoveStructType, bw as MoveType, bq as MoveUint128Type, bn as MoveUint16Type, br as MoveUint256Type, bo as MoveUint32Type, bp as MoveUint64Type, bm as MoveUint8Type, b2 as MultisigPayloadResponse, bP as NetworkToChainId, bM as NetworkToFaucetAPI, bK as NetworkToIndexerAPI, bQ as NetworkToNetworkName, bL as NetworkToNodeAPI, bN as NetworkToPepperAPI, bO as NetworkToProverAPI, bH as OrderBy, bI as OrderByValue, as as ParsingError, at as ParsingResult, bC as RoleType, b1 as ScriptPayloadResponse, aw as ScriptTransactionArgumentVariants, bi as ScriptWriteSet, aQ as StateCheckpointTransactionResponse, bJ as TokenStandard, az as TransactionAuthenticatorVariant, bb as TransactionEd25519Signature, bf as TransactionFeePayerSignature, be as TransactionMultiAgentSignature, bd as TransactionMultiEd25519Signature, a$ as TransactionPayloadResponse, ax as TransactionPayloadVariants, aH as TransactionResponseType, bc as TransactionSecp256k1Signature, b5 as TransactionSignature, ay as TransactionVariants, av as TypeTagVariants, aE as Uint128, aF as Uint256, aD as Uint64, aR as ValidatorTransactionResponse, bh as WriteSet, aS as WriteSetChange, aT as WriteSetChangeDeleteModule, aU as WriteSetChangeDeleteResource, aV as WriteSetChangeDeleteTableItem, aW as WriteSetChangeWriteModule, aX as WriteSetChangeWriteResource, aY as WriteSetChangeWriteTableItem, ao as ensureBoolean, aL as isBlockMetadataTransactionResponse, b6 as isEd25519Signature, b9 as isFeePayerSignature, aK as isGenesisTransactionResponse, b8 as isMultiAgentSignature, ba as isMultiEd25519Signature, aI as isPendingTransactionResponse, b7 as isSecp256k1Signature, aM as isStateCheckpointTransactionResponse, aJ as isUserTransactionResponse, aN as isValidatorTransactionResponse, ap as outOfRangeErrorMessage, aq as validateNumberInRange } from './accountAddress-jP2Ua0t9.js';
 import EventEmitter from 'eventemitter3';
 
 type Maybe<T> = T | null;
@@ -1367,6 +1367,519 @@ declare class MultiKeySignature extends Signature {
     static deserialize(deserializer: Deserializer): MultiKeySignature;
 }
 
+/**
+ * Represents ephemeral public keys for Aptos Keyless accounts.
+ *
+ * These are not public keys used as a public key on an account.  They are only used ephemerally on Keyless accounts.
+ */
+declare class EphemeralPublicKey extends PublicKey {
+    /**
+     * The public key itself
+     */
+    readonly publicKey: PublicKey;
+    /**
+     * An enum indicating the scheme of the ephemeral public key
+     */
+    readonly variant: EphemeralPublicKeyVariant;
+    constructor(publicKey: PublicKey);
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Verifies a signed data with a the ephemeral public key
+     *
+     * @param args.message message
+     * @param args.signature The signature that was signed by the private key of the ephemeral public key
+     * @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;
+}
+/**
+ * Represents ephemeral signatures used in Aptos Keyless accounts.
+ *
+ * These signatures are used inside of KeylessSignature
+ */
+declare class EphemeralSignature extends Signature {
+    /**
+     * The signature signed by the private key of an EphemeralKeyPair
+     */
+    readonly signature: Signature;
+    constructor(signature: Signature);
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    static fromHex(hexInput: HexInput): EphemeralSignature;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): EphemeralSignature;
+}
+
+/**
+ * An abstract representation of a crypto proof.
+ * associated to a specific zero knowledge proof schemes e.g. Groth16, PLONK
+ */
+declare abstract class Proof extends Serializable {
+    /**
+     * Get the proof as a hex string with a 0x prefix e.g. 0x123456...
+     */
+    toString(): string;
+}
+
+type Groth16VerificationKeyResponse = {
+    alpha_g1: string;
+    beta_g2: string;
+    delta_g2: string;
+    gamma_abc_g1: [string, string];
+    gamma_g2: string;
+};
+
+/**
+ * Type of API endpoint for request routing
+ */
+declare enum AptosApiType {
+    FULLNODE = "Fullnode",
+    INDEXER = "Indexer",
+    FAUCET = "Faucet",
+    PEPPER = "Pepper",
+    PROVER = "Prover"
+}
+/**
+ * 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}
+ */
+declare enum ProcessorType {
+    ACCOUNT_TRANSACTION_PROCESSOR = "account_transactions_processor",
+    DEFAULT = "default_processor",
+    EVENTS_PROCESSOR = "events_processor",
+    FUNGIBLE_ASSET_PROCESSOR = "fungible_asset_processor",
+    STAKE_PROCESSOR = "stake_processor",
+    TOKEN_V2_PROCESSOR = "token_v2_processor",
+    USER_TRANSACTION_PROCESSOR = "user_transaction_processor"
+}
+
+/**
+ * This class holds the config information for the SDK client instance.
+ *
+ * @example
+ *
+ * const aptosConfig = new AptosConfig({network:Network.TESTNET})
+ */
+declare class AptosConfig {
+    /**
+     * The Network that this SDK is associated with. Defaults to DEVNET
+     */
+    readonly network: Network;
+    /**
+     * The client instance the SDK uses. Defaults to `@aptos-labs/aptos-client
+     */
+    readonly client: Client;
+    /**
+     * The optional hardcoded fullnode URL to send requests to instead of using the network
+     */
+    readonly fullnode?: string;
+    /**
+     * The optional hardcoded faucet URL to send requests to instead of using the network
+     */
+    readonly faucet?: string;
+    /**
+     * The optional hardcoded 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
+     */
+    readonly indexer?: string;
+    /**
+     * Optional client configurations
+     */
+    readonly clientConfig?: ClientConfig;
+    /**
+     * Optional specific Fullnode configurations
+     */
+    readonly fullnodeConfig?: FullNodeConfig;
+    /**
+     * Optional specific Indexer configurations
+     */
+    readonly indexerConfig?: IndexerConfig;
+    /**
+     * Optional specific Faucet configurations
+     */
+    readonly faucetConfig?: FaucetConfig;
+    constructor(settings?: AptosSettings);
+    /**
+     * Returns the URL endpoint to send the request to.
+     * If a custom URL was provided in the config, that URL is returned.
+     * If a custom URL was provided but not URL endpoints, an error is thrown.
+     * Otherwise, the URL endpoint is derived from the network.
+     *
+     * @param apiType - The type of Aptos API to get the URL for.
+     *
+     * @internal
+     */
+    getRequestUrl(apiType: AptosApiType): string;
+    /**
+     * Checks if the URL is a known pepper service endpoint
+     *
+     * @internal
+     * */
+    isPepperServiceRequest(url: string): boolean;
+    /**
+     * Checks if the URL is a known prover service endpoint
+     *
+     * @internal
+     * */
+    isProverServiceRequest(url: string): boolean;
+}
+
+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 {
+    /**
+     * The number of bytes that `idCommitment` should be
+     */
+    static readonly ID_COMMITMENT_LENGTH: number;
+    /**
+     * The value of the 'iss' claim on the JWT which identifies the OIDC provider.
+     */
+    readonly iss: string;
+    /**
+     * A value representing a cryptographic commitment to a user identity.
+     *
+     * It is calculated from the aud, uidKey, uidVal, pepper.
+     */
+    readonly idCommitment: Uint8Array;
+    constructor(iss: string, idCommitment: HexInput);
+    /**
+     * Get the authentication key for the keyless public key
+     *
+     * @returns AuthenticationKey
+     */
+    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;
+    /**
+     * Creates a KeylessPublicKey from the JWT components plus pepper
+     *
+     * @param args.iss the iss of the identity
+     * @param args.uidKey the key to use to get the uidVal in the JWT token
+     * @param args.uidVal the value of the uidKey in the JWT token
+     * @param args.aud the client ID of the application
+     * @param args.pepper The pepper used to maintain privacy of the account
+     * @returns KeylessPublicKey
+     */
+    static create(args: {
+        iss: string;
+        uidKey: string;
+        uidVal: string;
+        aud: string;
+        pepper: HexInput;
+    }): KeylessPublicKey;
+    static fromJWTAndPepper(args: {
+        jwt: string;
+        pepper: HexInput;
+        uidKey?: string;
+    }): KeylessPublicKey;
+}
+/**
+ * A signature of a message signed via Keyless Accounnt that uses proofs or the jwt token to authenticate.
+ */
+declare class KeylessSignature extends Signature {
+    /**
+     * The inner signature ZeroKnowledgeSigniature or OpenIdSignature
+     */
+    readonly ephemeralCertificate: EphemeralCertificate;
+    /**
+     * The jwt header in the token used to create the proof/signature.  In json string representation.
+     */
+    readonly jwtHeader: string;
+    /**
+     * The expiry timestamp in seconds of the EphemeralKeyPair used to sign
+     */
+    readonly expiryDateSecs: number;
+    /**
+     * The ephemeral public key used to verify the signature
+     */
+    readonly ephemeralPublicKey: EphemeralPublicKey;
+    /**
+     * The signature resulting from signing with the private key of the EphemeralKeyPair
+     */
+    readonly ephemeralSignature: EphemeralSignature;
+    constructor(args: {
+        jwtHeader: string;
+        ephemeralCertificate: EphemeralCertificate;
+        expiryDateSecs: number;
+        ephemeralPublicKey: EphemeralPublicKey;
+        ephemeralSignature: EphemeralSignature;
+    });
+    /**
+     * Get the signature in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the signature
+     */
+    toUint8Array(): Uint8Array;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): KeylessSignature;
+    static getSimulationSignature(): KeylessSignature;
+    static isSignature(signature: Signature): signature is KeylessSignature;
+}
+/**
+ * A container for a signature that is a ZeroKnowledgeSig.  Can be expanded to support OpenIdSignature.
+ */
+declare class EphemeralCertificate extends Signature {
+    readonly signature: Signature;
+    /**
+     * Index of the underlying enum variant
+     */
+    private readonly variant;
+    constructor(signature: Signature, variant: EphemeralCertificateVariant);
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): EphemeralCertificate;
+}
+declare class G1Bytes extends Serializable {
+    data: Uint8Array;
+    constructor(data: HexInput);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): G1Bytes;
+}
+declare class G2Bytes extends Serializable {
+    data: Uint8Array;
+    constructor(data: HexInput);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): G2Bytes;
+}
+/**
+ * A representation of a Groth16 proof.  The points are the compressed serialization of affine reprentation of the proof.
+ */
+declare class Groth16Zkp extends Proof {
+    /**
+     * The bytes of G1 proof point a
+     */
+    a: G1Bytes;
+    /**
+     * The bytes of G2 proof point b
+     */
+    b: G2Bytes;
+    /**
+     * The bytes of G1 proof point c
+     */
+    c: G1Bytes;
+    constructor(args: {
+        a: HexInput;
+        b: HexInput;
+        c: HexInput;
+    });
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Groth16Zkp;
+}
+/**
+ * A container for a different zero knowledge proof types
+ */
+declare class ZkProof extends Serializable {
+    readonly proof: Proof;
+    /**
+     * Index of the underlying enum variant
+     */
+    private readonly variant;
+    constructor(proof: Proof, variant: ZkpVariant);
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): ZkProof;
+}
+/**
+ * The signature representation of a proof
+ */
+declare class ZeroKnowledgeSig extends Signature {
+    /**
+     * The proof
+     */
+    readonly proof: ZkProof;
+    /**
+     * The max lifespan of the proof
+     */
+    readonly expHorizonSecs: number;
+    /**
+     * A key value pair on the JWT token that can be specified on the signature which would reveal the value on chain.
+     * Can be used to assert identity or other attributes.
+     */
+    readonly extraField?: string;
+    /**
+     * The 'aud' value of the recovery service which is set when recovering an account.
+     */
+    readonly overrideAudVal?: string;
+    /**
+     * The training wheels signature
+     */
+    readonly trainingWheelsSignature?: EphemeralSignature;
+    constructor(args: {
+        proof: ZkProof;
+        expHorizonSecs: number;
+        extraField?: string;
+        overrideAudVal?: string;
+        trainingWheelsSignature?: EphemeralSignature;
+    });
+    /**
+     * Get the signature in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the signature
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Return a ZeroKnowledgeSig object from its bcs serialization in bytes.
+     *
+     * @returns ZeroKnowledgeSig
+     */
+    static fromBytes(bytes: Uint8Array): ZeroKnowledgeSig;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): ZeroKnowledgeSig;
+}
+/**
+ * A class which represents the on-chain configuration for how Keyless accounts work
+ */
+declare class KeylessConfiguration {
+    /**
+     * The verification key used to verify Groth16 proofs on chain
+     */
+    readonly verficationKey: Groth16VerificationKey;
+    /**
+     * The maximum lifespan of an ephemeral key pair.  This is configured on chain.
+     */
+    readonly maxExpHorizonSecs: number;
+    constructor(verficationKey: Groth16VerificationKey, maxExpHorizonSecs: number);
+    static create(res: Groth16VerificationKeyResponse, maxExpHorizonSecs: number): KeylessConfiguration;
+}
+/**
+ * A representation of the verification key stored on chain used to verify Groth16 proofs
+ */
+declare class Groth16VerificationKey {
+    /**
+     * The `alpha * G`, where `G` is the generator of G1
+     */
+    readonly alphaG1: G1Bytes;
+    /**
+     * The `alpha * H`, where `H` is the generator of G2
+     */
+    readonly betaG2: G2Bytes;
+    /**
+     * The `delta * H`, where `H` is the generator of G2
+     */
+    readonly deltaG2: G2Bytes;
+    /**
+     * The `gamma^{-1} * (beta * a_i + alpha * b_i + c_i) * H`, where H is the generator of G1
+     */
+    readonly gammaAbcG1: G1Bytes[];
+    /**
+     * The `gamma * H`, where `H` is the generator of G2
+     */
+    readonly gammaG2: G2Bytes;
+    constructor(args: {
+        alphaG1: HexInput;
+        betaG2: HexInput;
+        deltaG2: HexInput;
+        gammaAbcG1: [HexInput, HexInput];
+        gammaG2: HexInput;
+    });
+    static fromGroth16VerificationKeyResponse(res: Groth16VerificationKeyResponse): Groth16VerificationKey;
+}
+/**
+ * Gets the parameters of how Keyless Accounts are configured on chain including the verifying key and the max expiry horizon
+ *
+ * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+ * @returns KeylessConfiguration
+ */
+declare function getKeylessConfig(args: {
+    aptosConfig: AptosConfig;
+    options?: LedgerVersionArg;
+}): Promise<KeylessConfiguration>;
+
 /**
  * Represents the Secp256k1 ecdsa public key
  *
@@ -1563,119 +2076,6 @@ declare class AccountAuthenticatorMultiKey extends AccountAuthenticator {
     static load(deserializer: Deserializer): AccountAuthenticatorMultiKey;
 }
 
-/**
- * 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}
- */
-declare enum ProcessorType {
-    ACCOUNT_TRANSACTION_PROCESSOR = "account_transactions_processor",
-    DEFAULT = "default_processor",
-    EVENTS_PROCESSOR = "events_processor",
-    FUNGIBLE_ASSET_PROCESSOR = "fungible_asset_processor",
-    STAKE_PROCESSOR = "stake_processor",
-    TOKEN_V2_PROCESSOR = "token_v2_processor",
-    USER_TRANSACTION_PROCESSOR = "user_transaction_processor"
-}
-
-/**
- * This class holds the config information for the SDK client instance.
- *
- * @example
- *
- * const aptosConfig = new AptosConfig({network:Network.TESTNET})
- */
-declare class AptosConfig {
-    /**
-     * The Network that this SDK is associated with. Defaults to DEVNET
-     */
-    readonly network: Network;
-    /**
-     * The client instance the SDK uses. Defaults to `@aptos-labs/aptos-client
-     */
-    readonly client: Client;
-    /**
-     * The optional hardcoded fullnode URL to send requests to instead of using the network
-     */
-    readonly fullnode?: string;
-    /**
-     * The optional hardcoded faucet URL to send requests to instead of using the network
-     */
-    readonly faucet?: string;
-    /**
-     * The optional hardcoded indexer URL to send requests to instead of using the network
-     */
-    readonly indexer?: string;
-    /**
-     * Optional client configurations
-     */
-    readonly clientConfig?: ClientConfig;
-    /**
-     * Optional specific Fullnode configurations
-     */
-    readonly fullnodeConfig?: FullNodeConfig;
-    /**
-     * Optional specific Indexer configurations
-     */
-    readonly indexerConfig?: IndexerConfig;
-    /**
-     * Optional specific Faucet configurations
-     */
-    readonly faucetConfig?: FaucetConfig;
-    constructor(settings?: AptosSettings);
-    /**
-     * Returns the URL endpoint to send the request to.
-     * If a custom URL was provided in the config, that URL is returned.
-     * If a custom URL was provided but not URL endpoints, an error is thrown.
-     * Otherwise, the URL endpoint is derived from the network.
-     *
-     * @param apiType - The type of Aptos API to get the URL for.
-     *
-     * @internal
-     */
-    getRequestUrl(apiType: AptosApiType): string;
-}
-
 /**
  * Representation of a ChainId that can serialized and deserialized
  */
@@ -2291,6 +2691,24 @@ type EntryFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | Ac
  * Script function arguments to be used when building a raw transaction using BCS serialized arguments
  */
 type ScriptFunctionArgumentTypes = Bool | U8 | U16 | U32 | U64 | U128 | U256 | AccountAddress | MoveVector<U8> | MoveString | FixedBytes;
+/**
+ * TypeArgument inputs for Entry functions, view functions, and scripts
+ *
+ * This can be a string version of the type argument such as:
+ * - u8
+ * - u16
+ * - u32
+ * - u64
+ * - u128
+ * - u256
+ * - bool
+ * - address
+ * - signer
+ * - vector<Type>
+ * - address::module::struct
+ * - address::module::struct<Type1, Type2>
+ */
+type TypeArgument = TypeTag | string;
 /**
  * Type that holds all raw transaction instances Aptos SDK supports
  */
@@ -2319,7 +2737,7 @@ type InputGenerateTransactionPayloadDataWithRemoteABI = InputScriptData | InputE
  */
 type InputEntryFunctionData = {
     function: MoveFunctionId;
-    typeArguments?: Array<TypeTag | string>;
+    typeArguments?: Array<TypeArgument>;
     functionArguments: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
     abi?: EntryFunctionABI;
 };
@@ -2350,7 +2768,7 @@ type InputMultiSigDataWithRemoteABI = {
  */
 type InputScriptData = {
     bytecode: HexInput;
-    typeArguments?: Array<TypeTag>;
+    typeArguments?: Array<TypeArgument>;
     functionArguments: Array<ScriptFunctionArgumentTypes>;
 };
 /**
@@ -2358,7 +2776,7 @@ type InputScriptData = {
  */
 type InputViewFunctionData = {
     function: MoveFunctionId;
-    typeArguments?: Array<TypeTag | string>;
+    typeArguments?: Array<TypeArgument>;
     functionArguments?: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
     abi?: ViewFunctionABI;
 };
@@ -2836,6 +3254,254 @@ declare class Ed25519Account implements Account$1 {
     signTransaction(transaction: AnyRawTransaction): Ed25519Signature;
 }
 
+/**
+ * A class which contains a key pair that is used in signing transactions via the Keyless authentication scheme. This key pair
+ * is ephemeral and has an expiration time.  For more details on how this class is used -
+ * https://aptos.dev/guides/keyless-accounts/#1-present-the-user-with-a-sign-in-with-idp-button-on-the-ui
+ */
+declare class EphemeralKeyPair extends Serializable {
+    static readonly BLINDER_LENGTH: number;
+    /**
+     * A byte array of length BLINDER_LENGTH used to obfuscate the public key from the IdP.
+     * Used in calculating the nonce passed to the IdP and as a secret witness in proof generation.
+     */
+    readonly blinder: Uint8Array;
+    /**
+     * A timestamp in seconds indicating when the ephemeral key pair is expired.  After expiry, a new
+     * EphemeralKeyPair must be generated and a new JWT needs to be created.
+     */
+    readonly expiryDateSecs: number;
+    /**
+     * The value passed to the IdP when the user authenticates.  It comprises of a hash of the
+     * ephermeral public key, expiry date, and blinder.
+     */
+    readonly nonce: string;
+    /**
+     * A private key used to sign transactions.  This private key is not tied to any account on the chain as it
+     * is ephemeral (not permanent) in nature.
+     */
+    private privateKey;
+    /**
+     * A public key used to verify transactions.  This public key is not tied to any account on the chain as it
+     * is ephemeral (not permanent) in nature.
+     */
+    private publicKey;
+    constructor(args: {
+        privateKey: PrivateKey;
+        expiryDateSecs?: number;
+        blinder?: HexInput;
+    });
+    /**
+     * Returns the public key of the key pair.
+     * @return EphemeralPublicKey
+     */
+    getPublicKey(): EphemeralPublicKey;
+    /**
+     * Returns the public key of the key pair.
+     * @return boolean
+     */
+    isExpired(): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): EphemeralKeyPair;
+    static fromBytes(bytes: Uint8Array): EphemeralKeyPair;
+    /**
+     * Returns the public key of the key pair.
+     * @param scheme the type of keypair to use for the EphemeralKeyPair.  Only Ed25519 supported for now.
+     * @param expiryDateSecs the date of expiry.
+     * @return boolean
+     */
+    static generate(args?: {
+        scheme?: EphemeralPublicKeyVariant;
+        expiryDateSecs?: number;
+    }): EphemeralKeyPair;
+    /**
+     * From the ephemeral public key, expiry timestamp, and blinder, calculate the nonce to be used at authentication via OIDC.
+     * @returns string
+     */
+    private generateNonce;
+    /**
+     * Sign the given message with the private key.
+     * @param data in HexInput format
+     * @returns EphemeralSignature
+     */
+    sign(data: HexInput): EphemeralSignature;
+}
+
+type AptsoDomainSeparator = `APTOS::${string}`;
+declare abstract class CryptoHashable extends Serializable {
+    abstract readonly domainSeparator: AptsoDomainSeparator;
+    /**
+     * Hashes the bcs serialized from of the class. This is the typescript corollary to the BCSCryptoHash macro in aptos-core.
+     *
+     * @returns Uint8Array
+     */
+    hash(): Uint8Array;
+}
+
+/**
+ * Account implementation for the Keyless authentication scheme.
+ *
+ * Used to represent a Keyless based account and sign transactions with it.
+ *
+ * Use KeylessAccount.fromJWTAndProof to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.
+ *
+ * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,
+ * EphemeralKeyPair, and corresponding proof.
+ */
+declare class KeylessAccount extends Serializable implements Account$1 {
+    static readonly PEPPER_LENGTH: number;
+    /**
+     * The KeylessPublicKey associated with the account
+     */
+    readonly publicKey: KeylessPublicKey;
+    /**
+     * The EphemeralKeyPair used to generate sign.
+     */
+    readonly ephemeralKeyPair: EphemeralKeyPair;
+    /**
+     * The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.
+     */
+    readonly uidKey: string;
+    /**
+     * The value of the uidKey claim on the JWT.  This intended to be a stable user identifier.
+     */
+    readonly uidVal: string;
+    /**
+     * The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's
+     * OIDC registration with the identity provider.
+     */
+    readonly aud: string;
+    /**
+     * A value contains 31 bytes of entropy that preserves privacy of the account. Typically fetched from a pepper provider.
+     */
+    readonly pepper: Uint8Array;
+    /**
+     * Account address associated with the account
+     */
+    readonly accountAddress: AccountAddress;
+    /**
+     * The zero knowledge signature (if ready) which contains the proof used to validate the EphemeralKeyPair.
+     */
+    proof: ZeroKnowledgeSig | undefined;
+    /**
+     * The proof of the EphemeralKeyPair or a promise that provides the proof.  This is used to allow for awaiting on
+     * fetching the proof.
+     */
+    readonly proofOrPromise: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
+    /**
+     * Signing scheme used to sign transactions
+     */
+    readonly signingScheme: SigningScheme;
+    /**
+     * The JWT token used to derive the account
+     */
+    readonly jwt: string;
+    /**
+     * An event emitter used to assist in handling asycronous proof fetching.
+     */
+    private readonly emitter;
+    constructor(args: {
+        address?: AccountAddress;
+        ephemeralKeyPair: EphemeralKeyPair;
+        iss: string;
+        uidKey: string;
+        uidVal: string;
+        aud: string;
+        pepper: HexInput;
+        proofOrFetcher: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
+        proofFetchCallback?: ProofFetchCallback;
+        jwt: string;
+    });
+    /**
+     * This initializes the asyncronous proof fetch
+     * @return
+     */
+    init(promise: Promise<ZeroKnowledgeSig>): Promise<void>;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): KeylessAccount;
+    /**
+     * Checks if the proof is expired.  If so the account must be rederived with a new EphemeralKeyPair
+     * and JWT token.
+     * @return boolean
+     */
+    isExpired(): boolean;
+    /**
+     * Sign a message using Keyless.
+     * @param message the message to sign, as binary input
+     * @return the AccountAuthenticator containing the signature, together with the account's public key
+     */
+    signWithAuthenticator(message: HexInput): AccountAuthenticatorSingleKey;
+    /**
+     * Sign a transaction using Keyless.
+     * @param transaction the raw transaction
+     * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+     */
+    signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey;
+    /**
+     * Waits for asyncronous proof fetching to finish.
+     * @return
+     */
+    waitForProofFetch(): Promise<void>;
+    /**
+     * Sign the given message using Keyless.
+     * @param message in HexInput format
+     * @returns Signature
+     */
+    sign(data: HexInput): KeylessSignature;
+    /**
+     * Sign the given transaction with Keyless.
+     * Signs the transaction and proof to guard against proof malleability.
+     * @param transaction the transaction to be signed
+     * @returns KeylessSignature
+     */
+    signTransaction(transaction: AnyRawTransaction): KeylessSignature;
+    verifySignature(args: {
+        message: HexInput;
+        signature: Signature;
+    }): boolean;
+    static fromBytes(bytes: Uint8Array): KeylessAccount;
+    static create(args: {
+        proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
+        jwt: string;
+        ephemeralKeyPair: EphemeralKeyPair;
+        pepper: HexInput;
+        uidKey?: string;
+        proofFetchCallback?: ProofFetchCallback;
+    }): KeylessAccount;
+}
+/**
+ * A container class to hold a transaction and a proof.  It implements CryptoHashable which is used to create
+ * the signing message for Keyless transactions.  We sign over the proof to ensure non-malleability.
+ */
+declare class TransactionAndProof extends CryptoHashable {
+    /**
+     * The transaction to sign.
+     */
+    transaction: AnyRawTransactionInstance;
+    /**
+     * The zero knowledge proof used in signing the transaction.
+     */
+    proof?: ZkProof;
+    /**
+     * The domain separator prefix used when hashing.
+     */
+    domainSeparator: AptsoDomainSeparator;
+    constructor(transaction: AnyRawTransactionInstance, proof?: ZkProof);
+    serialize(serializer: Serializer): void;
+}
+type ProofFetchSuccess = {
+    status: "Success";
+};
+type ProofFetchFailure = {
+    status: "Failed";
+    error: string;
+};
+type ProofFetchStatus = ProofFetchSuccess | ProofFetchFailure;
+type ProofFetchCallback = (status: ProofFetchStatus) => Promise<void>;
+interface ProofFetchEvents {
+    proofFetchFinish: (status: ProofFetchStatus) => void;
+}
+
 interface VerifyMultiKeySignatureArgs {
     message: HexInput;
     signature: MultiKeySignature;
@@ -2911,6 +3577,12 @@ declare class MultiKeyAccount implements Account$1 {
      * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
      */
     signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorMultiKey;
+    /**
+     * Waits for any proofs on any KeylessAccount signers to be fetched. If the proof is fetched a syncronously, call this
+     * to ensure signing with the KeylessAccount does not fail as the proof must be ready.
+     * @return
+     */
+    waitForProofFetch(): Promise<void>;
     /**
      * Sign the given message using the MultiKeyAccount's signers
      * @param message in HexInput format
@@ -4082,7 +4754,7 @@ declare function generateUserTransactionHash(args: InputSubmitTransactionData):
 /**
  * Convert type arguments to only type tags, allowing for string representations of type tags
  */
-declare function standardizeTypeTags(typeArguments?: Array<TypeTag | string>): Array<TypeTag>;
+declare function standardizeTypeTags(typeArguments?: Array<TypeArgument>): Array<TypeTag>;
 /**
  * Fetches a function ABI from the on-chain module ABI.  It doesn't validate whether it's a view or entry function.
  * @param moduleAddress
@@ -4137,6 +4809,9 @@ declare function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTr
  */
 declare function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array;
 /**
+ * @deprected
+ * Use CryptoHashable instead by having your class implement it and call hash() to get the signing message.
+ *
  * Generates the 'signing message' form of a serilizable value. It bcs serializes the value and uses the name of
  * its constructor as the domain separator.
  *
@@ -4164,11 +4839,13 @@ declare enum TypeTagParserErrorType {
     UnexpectedComma = "unexpected ','",
     TypeArgumentCountMismatch = "type argument count doesn't match expected amount",
     MissingTypeArgumentClose = "no matching '>' for '<'",
+    MissingTypeArgument = "no type argument before ','",
     UnexpectedPrimitiveTypeArguments = "primitive types not expected to have type arguments",
     UnexpectedVectorTypeArgumentCount = "vector type expected to have exactly one type argument",
     UnexpectedStructFormat = "unexpected struct format, must be of the form 0xaddress::module_name::struct_name",
     InvalidModuleNameCharacter = "module name must only contain alphanumeric or '_' characters",
-    InvalidStructNameCharacter = "struct name must only contain alphanumeric or '_' characters"
+    InvalidStructNameCharacter = "struct name must only contain alphanumeric or '_' characters",
+    InvalidAddress = "struct address must be valid"
 }
 declare class TypeTagParserError extends Error {
     constructor(typeTagStr: string, invalidReason: TypeTagParserErrorType);
@@ -5509,6 +6186,48 @@ declare class Table {
     }): Promise<GetTableItemsMetadataResponse>;
 }
 
+/**
+ * A class to query all `Keyless` related queries on Aptos.
+ *
+ * More documentation on how to integrate Keyless Accounts see the below
+ * https://aptos.dev/guides/keyless-accounts/#aptos-keyless-integration-guide
+ */
+declare class Keyless {
+    readonly config: AptosConfig;
+    constructor(config: AptosConfig);
+    /**
+     * Fetches the pepper from the Aptos pepper service API.
+     *
+     * @param args.jwt JWT token
+     * @param args.ephemeralKeyPair the EphemeralKeyPair used to generate the nonce in the JWT token
+     * @returns The pepper which is a Uint8Array of length 31.
+     */
+    getPepper(args: {
+        jwt: string;
+        ephemeralKeyPair: EphemeralKeyPair;
+    }): Promise<Uint8Array>;
+    /**
+     * Fetches the pepper from the Aptos pepper service API.
+     *
+     * @param args.jwt JWT token
+     * @param args.ephemeralKeyPair the EphemeralKeyPair used to generate the nonce in the JWT token
+     * @param args.uidKey a key in the JWT token to use to set the uidVal in the IdCommitment
+     * @param args.pepper the pepper
+     * @param args.proofFetchCallback a callback function that if set, the fetch of the proof will be done in the background. Once
+     * fetching finishes the callback function will be called.  This should be used to provide a more responsive user experience as now
+     * they are not blocked on fetching the proof. Thus the function will return much more quickly.
+     *
+     * @returns A KeylessAccount that can be used to sign transactions
+     */
+    deriveKeylessAccount(args: {
+        jwt: string;
+        ephemeralKeyPair: EphemeralKeyPair;
+        uidKey?: string;
+        pepper?: HexInput;
+        proofFetchCallback?: ProofFetchCallback;
+    }): Promise<KeylessAccount>;
+}
+
 /**
  * This class is the main entry point into Aptos's
  * APIs and separates functionality into different namespaces.
@@ -5533,9 +6252,10 @@ declare class Aptos {
     readonly staking: Staking;
     readonly transaction: Transaction;
     readonly table: Table;
+    readonly keyless: Keyless;
     constructor(settings?: AptosConfig);
 }
-interface Aptos extends Account, ANS, Coin, DigitalAsset, Event, Faucet, FungibleAsset, General, Staking, Table, Omit<Transaction, "build" | "simulate" | "submit" | "batch"> {
+interface Aptos extends Account, ANS, Coin, DigitalAsset, Event, Faucet, FungibleAsset, General, Keyless, Staking, Table, Omit<Transaction, "build" | "simulate" | "submit" | "batch"> {
 }
 
 /**
@@ -5646,6 +6366,13 @@ 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>>;
+/**
+ * Makes a get request to the pepper service
+ *
+ * @param options GetAptosRequestOptions
+ * @returns AptosResponse
+ */
+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 = {
@@ -5697,5 +6424,13 @@ 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>>;
+/**
+ * Makes a post request to the pepper service
+ *
+ * @param options GetAptosRequestOptions
+ * @returns AptosResponse
+ */
+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, AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountData, AccountPublicKey, AccountSequenceNumber, AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, AptosRequest, type AptosResponse, AptosSettings, AuthenticationKey, AuthenticationKeyScheme, Block, Bool, CKDPriv, ChainId, Client, ClientConfig, ClientRequest, ClientResponse, CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DerivedKeys, Deserializable, type DeserializableClass, Deserializer, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, type ExecutionFinishEventData, type FailureEventData, FaucetConfig, FeePayerRawTransaction, FixedBytes, FullNodeConfig, type FunctionABI, GasEstimation, type GenerateAccountArgs, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, GetANSNameResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedObjectsResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, type GetRequestOptions, GetTableItemsDataResponse, GetTableItemsMetadataResponse, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, HARDENED_OFFSET, Hex, HexInput, Identifier, IndexerConfig, type InputEntryFunctionData, type InputEntryFunctionDataWithABI, type InputEntryFunctionDataWithRemoteABI, type InputGenerateMultiAgentRawTransactionArgs, type InputGenerateMultiAgentRawTransactionData, type InputGenerateRawTransactionArgs, type InputGenerateSingleSignerRawTransactionArgs, type InputGenerateSingleSignerRawTransactionData, type InputGenerateTransactionData, type InputGenerateTransactionOptions, type InputGenerateTransactionPayloadData, type InputGenerateTransactionPayloadDataWithABI, type InputGenerateTransactionPayloadDataWithRemoteABI, type InputMultiSigData, type InputMultiSigDataWithABI, type InputMultiSigDataWithRemoteABI, type InputScriptData, type InputSimulateTransactionData, type InputSimulateTransactionOptions, type InputSubmitTransactionData, type InputViewFunctionData, type InputViewFunctionDataWithABI, type InputViewFunctionDataWithRemoteABI, KeyType, LedgerInfo, LedgerVersionArg, MimeType, ModuleId, MoveFunction, MoveFunctionGenericTypeParam, MoveFunctionId, MoveModuleBytecode, MoveModuleId, MoveOption, MoveResource, MoveString, MoveStructId, MoveValue, MoveVector, MultiAgentRawTransaction, MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeyAccount, MultiKeySignature, MultiSig, MultiSigTransactionPayload, Network, OrderByArg, PaginationArgs, PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, type PrivateKey, type PrivateKeyFromDerivationPathArgs, ProcessorType, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RotationProofChallenge, Script, ScriptFunctionArgument, type ScriptFunctionArgumentTypes, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, StructTag, type SuccessEventData, TableItemRequest, TokenStandardArg, TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, TransactionPayloadScript, TransactionResponse, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVector, U128, U16, U256, U32, U64, U8, Uint16, Uint32, Uint8, UserTransactionResponse, type VerifyEd25519SignatureArgs, type VerifyMultiKeySignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewFunctionABI, WaitForTransactionOptions, WhereArg, aptosCoinStructTag, aptosRequest, buildTransaction, checkOrConvertArgument, convertArgument, deriveKey, deriveTransactionType, deserializeFromScriptArgument, fetchEntryFunctionAbi, fetchFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateSigningMessageForSerializable, generateSigningMessageForTransaction, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAuthenticatorForSimulation, getFunctionParts, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBool, isEncodedEntryFunctionArgument, isLargeNumber, isNull, isNumber, isScriptDataInput, isString, isValidBIP44Path, isValidHardenedPath, mnemonicToSeed, normalizeBundle, objectStructTag, optionStructTag, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, promiseFulfilledStatus, request, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch };
+export { APTOS_BIP44_REGEX, APTOS_COIN, APTOS_HARDENED_REGEX, Account$1 as Account, AccountAddress, AccountAddressInput, AccountAuthenticator, AccountAuthenticatorEd25519, AccountAuthenticatorMultiEd25519, AccountAuthenticatorMultiKey, AccountAuthenticatorSingleKey, AccountData, AccountPublicKey, AccountSequenceNumber, AnyNumber, AnyPublicKey, AnyPublicKeyVariant, type AnyRawTransaction, type AnyRawTransactionInstance, AnySignature, type AnyTransactionPayloadInstance, Aptos, AptosApiError, AptosApiType, AptosConfig, AptosRequest, type AptosResponse, AptosSettings, AuthenticationKey, AuthenticationKeyScheme, Block, Bool, CKDPriv, ChainId, Client, ClientConfig, ClientRequest, ClientResponse, CommittedTransactionResponse, type CreateAccountFromPrivateKeyArgs, type CreateEd25519AccountFromPrivateKeyArgs, type CreateEd25519SingleKeyAccountFromPrivateKeyArgs, type CreateSingleKeyAccountFromPrivateKeyArgs, DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW, DEFAULT_TXN_TIMEOUT_SEC, type DerivedKeys, Deserializable, type DeserializableClass, Deserializer, EPK_HORIZON_SECS, Ed25519Account, Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, type Ed25519SignerConstructorArgs, type Ed25519SignerFromDerivationPathArgs, EntryFunction, type EntryFunctionABI, EntryFunctionArgument, type EntryFunctionArgumentTypes, EntryFunctionBytes, EphemeralCertificate, EphemeralCertificateVariant, EphemeralKeyPair, EphemeralPublicKey, EphemeralPublicKeyVariant, EphemeralSignature, type ExecutionFinishEventData, type FailureEventData, FaucetConfig, FeePayerRawTransaction, FixedBytes, FullNodeConfig, type FunctionABI, GasEstimation, type GenerateAccountArgs, type GenerateEd25519AccountArgs, type GenerateEd25519SingleKeyAccountArgs, type GenerateSingleKeyAccountArgs, GetANSNameResponse, GetAccountCoinsDataResponse, GetAccountCollectionsWithOwnedTokenResponse, GetAccountOwnedObjectsResponse, GetAccountOwnedTokensFromCollectionResponse, GetAccountOwnedTokensQueryResponse, type GetAptosRequestOptions, GetChainTopUserTransactionsResponse, GetCollectionDataResponse, GetCurrentFungibleAssetBalancesResponse, GetCurrentTokenOwnershipResponse, GetDelegatedStakingActivitiesResponse, GetEventsResponse, GetFungibleAssetActivitiesResponse, GetFungibleAssetMetadataResponse, GetNumberOfDelegatorsResponse, GetOwnedTokensResponse, GetProcessorStatusResponse, type GetRequestOptions, GetTableItemsDataResponse, GetTableItemsMetadataResponse, GetTokenActivityResponse, GetTokenDataResponse, GraphqlQuery, Groth16Zkp, HARDENED_OFFSET, Hex, HexInput, Identifier, IndexerConfig, type InputEntryFunctionData, type InputEntryFunctionDataWithABI, type InputEntryFunctionDataWithRemoteABI, type InputGenerateMultiAgentRawTransactionArgs, type InputGenerateMultiAgentRawTransactionData, type InputGenerateRawTransactionArgs, type InputGenerateSingleSignerRawTransactionArgs, type InputGenerateSingleSignerRawTransactionData, type InputGenerateTransactionData, type InputGenerateTransactionOptions, type InputGenerateTransactionPayloadData, type InputGenerateTransactionPayloadDataWithABI, type InputGenerateTransactionPayloadDataWithRemoteABI, type InputMultiSigData, type InputMultiSigDataWithABI, type InputMultiSigDataWithRemoteABI, type InputScriptData, type InputSimulateTransactionData, type InputSimulateTransactionOptions, type InputSubmitTransactionData, type InputViewFunctionData, type InputViewFunctionDataWithABI, type InputViewFunctionDataWithRemoteABI, KeyType, KeylessAccount, KeylessConfiguration, KeylessPublicKey, KeylessSignature, LedgerInfo, LedgerVersionArg, MAX_AUD_VAL_BYTES, MAX_COMMITED_EPK_BYTES, MAX_EXTRA_FIELD_BYTES, MAX_ISS_VAL_BYTES, MAX_JWT_HEADER_B64_BYTES, MAX_UID_KEY_BYTES, MAX_UID_VAL_BYTES, MimeType, ModuleId, MoveFunction, MoveFunctionGenericTypeParam, MoveFunctionId, MoveModuleBytecode, MoveModuleId, MoveOption, MoveResource, MoveString, MoveStructId, MoveValue, MoveVector, MultiAgentRawTransaction, MultiAgentTransaction, MultiEd25519PublicKey, MultiEd25519Signature, MultiKey, MultiKeyAccount, MultiKeySignature, MultiSig, MultiSigTransactionPayload, Network, OrderByArg, PaginationArgs, PendingTransactionResponse, type PostAptosRequestOptions, type PostRequestOptions, type PrivateKey, type PrivateKeyFromDerivationPathArgs, ProcessorType, type ProofFetchCallback, type ProofFetchEvents, type ProofFetchFailure, type ProofFetchStatus, type ProofFetchSuccess, PublicKey, RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT, RawTransaction, RawTransactionWithData, RotationProofChallenge, Script, ScriptFunctionArgument, type ScriptFunctionArgumentTypes, Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature, Serializable, Serializer, Signature, SignedTransaction, SigningScheme, SigningSchemeInput, type SimpleEntryFunctionArgumentTypes, SimpleTransaction, SingleKeyAccount, type SingleKeySignerConstructorArgs, type SingleKeySignerFromDerivationPathArgs, type SingleKeySignerGenerateArgs, StructTag, type SuccessEventData, TableItemRequest, TokenStandardArg, TransactionAndProof, TransactionArgument, TransactionAuthenticator, TransactionAuthenticatorEd25519, TransactionAuthenticatorFeePayer, TransactionAuthenticatorMultiAgent, TransactionAuthenticatorMultiEd25519, TransactionAuthenticatorSingleSender, TransactionPayload, TransactionPayloadEntryFunction, TransactionPayloadMultiSig, TransactionPayloadScript, TransactionResponse, TransactionWorker, type TransactionWorkerEvents, TransactionWorkerEventsEnum, type TypeArgument, TypeTag, TypeTagAddress, TypeTagBool, TypeTagGeneric, TypeTagParserError, TypeTagParserErrorType, TypeTagReference, TypeTagSigner, TypeTagStruct, TypeTagU128, TypeTagU16, TypeTagU256, TypeTagU32, TypeTagU64, TypeTagU8, TypeTagVector, U128, U16, U256, U32, U64, U8, Uint16, Uint32, Uint8, UserTransactionResponse, type VerifyEd25519SignatureArgs, type VerifyMultiKeySignatureArgs, type VerifySignatureArgs, type VerifySingleKeySignatureArgs, type ViewFunctionABI, WaitForTransactionOptions, WhereArg, ZeroKnowledgeSig, ZkProof, ZkpVariant, aptosCoinStructTag, aptosRequest, buildTransaction, checkOrConvertArgument, convertArgument, deriveKey, deriveTransactionType, deserializeFromScriptArgument, fetchEntryFunctionAbi, fetchFunctionAbi, fetchViewFunctionAbi, findFirstNonSignerArg, generateRawTransaction, generateSignedTransaction, generateSignedTransactionForSimulation, generateSigningMessage, generateSigningMessageForSerializable, generateSigningMessageForTransaction, generateTransactionPayload, generateTransactionPayloadWithABI, generateUserTransactionHash, generateViewFunctionPayload, generateViewFunctionPayloadWithABI, get, getAptosFullNode, getAptosPepperService, getAuthenticatorForSimulation, getFunctionParts, getKeylessConfig, hashValues, isBcsAddress, isBcsBool, isBcsFixedBytes, isBcsString, isBcsU128, isBcsU16, isBcsU256, isBcsU32, isBcsU64, isBcsU8, isBool, isEncodedEntryFunctionArgument, isLargeNumber, isNull, isNumber, isScriptDataInput, isString, isValidBIP44Path, isValidHardenedPath, mnemonicToSeed, normalizeBundle, objectStructTag, optionStructTag, paginateWithCursor, parseTypeTag, post, postAptosFaucet, postAptosFullNode, postAptosIndexer, postAptosPepperService, postAptosProvingService, promiseFulfilledStatus, request, splitPath, standardizeTypeTags, stringStructTag, throwTypeMismatch };