@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0-zeta.0

package/dist/esm/chunk-WHSS6I7T.mjs

@@ -1,90 +0,0 @@
-import {
-  SingleKeyAccount
-} from "./chunk-G7BB6K4B.mjs";
-import {
-  Ed25519Account
-} from "./chunk-62LC4PPC.mjs";
-import {
-  Ed25519PrivateKey
-} from "./chunk-TFW6N66T.mjs";
-
-// src/account/Account.ts
-var Account = class {
-  static generate(args = {}) {
-    const { scheme = 0 /* Ed25519 */, legacy = true } = args;
-    if (scheme === 0 /* Ed25519 */ && legacy) {
-      return Ed25519Account.generate();
-    }
-    return SingleKeyAccount.generate({ scheme });
-  }
-  static fromPrivateKey(args) {
-    const { privateKey, address, legacy = true } = args;
-    if (privateKey instanceof Ed25519PrivateKey && legacy) {
-      return new Ed25519Account({
-        privateKey,
-        address
-      });
-    }
-    return new SingleKeyAccount({ privateKey, address });
-  }
-  /**
-   * @deprecated use `fromPrivateKey` instead.
-   * Instantiates an account using 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 - The arguments required to create an account from a private key.
-   * @param args.privateKey - The underlying private key for the account.
-   * @param args.address - 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
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static fromPrivateKeyAndAddress(args) {
-    return this.fromPrivateKey(args);
-  }
-  static fromDerivationPath(args) {
-    const { scheme = 0 /* Ed25519 */, mnemonic, path, legacy = true } = args;
-    if (scheme === 0 /* Ed25519 */ && legacy) {
-      return Ed25519Account.fromDerivationPath({ mnemonic, path });
-    }
-    return SingleKeyAccount.fromDerivationPath({ scheme, mnemonic, path });
-  }
-  /**
-   * Retrieve the authentication key for the associated account using the provided public key.
-   * 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 - The arguments for retrieving the authentication key.
-   * @param args.publicKey - The public key of the account.
-   * @returns The authentication key for the associated account.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static authKey(args) {
-    const { publicKey } = args;
-    return publicKey.authKey();
-  }
-  /**
-   * Verify the given message and signature with the public key.
-   * This function helps ensure the integrity and authenticity of a message by validating its signature.
-   *
-   * @param args - The arguments for verifying the signature.
-   * @param args.message - The raw message data in HexInput format.
-   * @param args.signature - The signed message signature.
-   * @returns A boolean indicating whether the signature is valid.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  verifySignature(args) {
-    return this.publicKey.verifySignature(args);
-  }
-};
-
-export {
-  Account
-};
-//# sourceMappingURL=chunk-WHSS6I7T.mjs.map

package/dist/esm/chunk-WHSS6I7T.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/Account.ts"],"sourcesContent":["import type { AccountAuthenticator } from \"../transactions/authenticator/account\";\nimport { HexInput, SigningScheme, SigningSchemeInput } from \"../types\";\nimport type { AccountAddress, AccountAddressInput } from \"../core/accountAddress\";\nimport { AuthenticationKey } from \"../core/authenticationKey\";\nimport { AccountPublicKey, Ed25519PrivateKey, PrivateKeyInput, Signature, VerifySignatureArgs } from \"../core/crypto\";\nimport { Ed25519Account } from \"./Ed25519Account\";\nimport { SingleKeyAccount } from \"./SingleKeyAccount\";\nimport { AnyRawTransaction } from \"../transactions/types\";\n\n/**\n * Arguments for creating an `Ed25519Account` from an `Ed25519PrivateKey`.\n * To use the SingleKey authentication scheme, set `legacy` to false.\n *\n * @param privateKey - The private key used to create the account.\n * @param address - Optional address for the account.\n * @param legacy - Indicates whether to use legacy authentication (default is true).\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface CreateEd25519AccountFromPrivateKeyArgs {\n  privateKey: Ed25519PrivateKey;\n  address?: AccountAddressInput;\n  legacy?: true;\n}\n\n/**\n * Arguments for creating a `SingleKeyAccount` using an `Ed25519PrivateKey`.\n * The `legacy` property must be set to false to utilize the `SingleKey` authentication scheme.\n *\n * @param privateKey - The Ed25519 private key used for account creation.\n * @param address - Optional account address input.\n * @param legacy - Must be false to enable the `SingleKey` authentication scheme.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs {\n  privateKey: Ed25519PrivateKey;\n  address?: AccountAddressInput;\n  legacy: false;\n}\n\n/**\n * Arguments for creating a `SingleKeyAccount` from a supported private key, excluding `Ed25519PrivateKey`.\n * The `legacy` argument is always false and cannot be set to true.\n *\n * @param privateKey - The private key used to create the account.\n * @param address - Optional address input for the account.\n * @param legacy - Always false; cannot be explicitly set to true.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface CreateSingleKeyAccountFromPrivateKeyArgs {\n  privateKey: PrivateKeyInput;\n  address?: AccountAddressInput;\n  legacy?: false;\n}\n\n/**\n * Arguments for creating an `Account` from a private key when the key type is unknown at compile time.\n *\n * @param privateKey - The private key used to create the account.\n * @param address - Optional address for the account.\n * @param legacy - Optional flag indicating if the account is a legacy account.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface CreateAccountFromPrivateKeyArgs {\n  privateKey: PrivateKeyInput;\n  address?: AccountAddressInput;\n  legacy?: boolean;\n}\n\n/**\n * Arguments for generating an Ed25519 account, specifying the signing scheme and legacy option.\n *\n * @param scheme - The signing scheme to use for the account.\n * @param legacy - Indicates if the account should be created in legacy mode.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface GenerateEd25519AccountArgs {\n  scheme?: SigningSchemeInput.Ed25519;\n  legacy?: true;\n}\n\n/**\n * Arguments for generating a `SingleKeyAccount` with an underlying `Ed25519PrivateKey`.\n * The `legacy` argument must be set to false to ensure an `Ed25519SingleKeyAccount` is returned.\n *\n * @param scheme - Optional signing scheme input for the account.\n * @param legacy - Indicates whether to use legacy account generation.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface GenerateEd25519SingleKeyAccountArgs {\n  scheme?: SigningSchemeInput.Ed25519;\n  legacy: false;\n}\n\n/**\n * Arguments for generating a `SingleKeyAccount` using a supported private key other than `Ed25519PrivateKey`.\n * The `legacy` argument is optional and defaults to false, and cannot be set to true.\n *\n * @param scheme - The signing scheme to use for the account.\n * @param legacy - Indicates whether to use legacy account generation (defaults to false).\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface GenerateSingleKeyAccountArgs {\n  scheme: Exclude<SigningSchemeInput, SigningSchemeInput.Ed25519>;\n  legacy?: false;\n}\n\n/**\n * Arguments for generating an opaque `Account` when the input signature scheme is unknown at compile time.\n *\n * @param scheme - The signing scheme to use for account generation.\n * @param legacy - Indicates whether to use legacy account generation methods.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface GenerateAccountArgs {\n  scheme?: SigningSchemeInput;\n  legacy?: boolean;\n}\n\n/**\n * Arguments for deriving a private key using a mnemonic phrase and a specified BIP44 path.\n *\n * @param path - The BIP44 derivation path for the key.\n * @param mnemonic - The mnemonic phrase used for key generation.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface PrivateKeyFromDerivationPathArgs {\n  path: string;\n  mnemonic: string;\n}\n\n/**\n * Abstract class representing a generic Aptos account.\n *\n * This class serves as a single entry point for account generation, allowing accounts to be created\n * either through `Account.generate()` or `Account.fromDerivationPath`. Although it is defined as an\n * abstract class, it should be treated as an interface and enforced using the `implements` keyword.\n *\n * Note: Generating an account instance does not create the account on-chain.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport abstract class Account {\n  /**\n   * Public key associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  abstract readonly publicKey: AccountPublicKey;\n\n  /**\n   * Account address associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  abstract readonly accountAddress: AccountAddress;\n\n  /**\n   * Signing scheme used to sign transactions\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  abstract signingScheme: SigningScheme;\n\n  /**\n   * Generates a new account based on the specified signing scheme and legacy option.\n   * This function allows you to create an account with either the Ed25519 signing scheme or a different scheme as specified.\n   *\n   * @param args - The arguments for generating the account.\n   * @param args.scheme - The signing scheme to use for account generation. Defaults to Ed25519.\n   * @param args.legacy - Indicates whether to use the legacy account generation method. Defaults to true.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static generate(args?: GenerateEd25519AccountArgs): Ed25519Account;\n  static generate(args: GenerateEd25519SingleKeyAccountArgs): SingleKeyAccount;\n  static generate(args: GenerateSingleKeyAccountArgs): SingleKeyAccount;\n  static generate(args: GenerateAccountArgs): Account;\n  static generate(args: GenerateAccountArgs = {}) {\n    const { scheme = SigningSchemeInput.Ed25519, legacy = true } = args;\n    if (scheme === SigningSchemeInput.Ed25519 && legacy) {\n      return Ed25519Account.generate();\n    }\n    return SingleKeyAccount.generate({ scheme });\n  }\n\n  /**\n   * Creates an account from a given private key and address.\n   * This function allows you to instantiate an account based on the provided private key,\n   * and it can differentiate between legacy and non-legacy accounts.\n   *\n   * @param args - The arguments for creating the account.\n   * @param args.privateKey - The private key used to create the account.\n   * @param args.address - The address associated with the account.\n   * @param args.legacy - A boolean indicating whether to create a legacy account (default is true).\n   * @returns An instance of either Ed25519Account or SingleKeyAccount based on the provided private key.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static fromPrivateKey(args: CreateEd25519AccountFromPrivateKeyArgs): Ed25519Account;\n  static fromPrivateKey(args: CreateSingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;\n  static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs): SingleKeyAccount;\n  static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs): Ed25519Account | SingleKeyAccount {\n    const { privateKey, address, legacy = true } = args;\n    if (privateKey instanceof Ed25519PrivateKey && legacy) {\n      return new Ed25519Account({\n        privateKey,\n        address,\n      });\n    }\n    return new SingleKeyAccount({ privateKey, address });\n  }\n\n  /**\n   * @deprecated use `fromPrivateKey` instead.\n   * Instantiates an account using a private key and a specified account address. This is primarily used to instantiate an\n   * `Account` that has had its authentication key rotated.\n   *\n   * @param args - The arguments required to create an account from a private key.\n   * @param args.privateKey - The underlying private key for the account.\n   * @param args.address - The account address the `Account` will sign for.\n   * @param args.legacy - Optional. If set to false, the keypair generated is a Unified keypair. Defaults to generating a Legacy\n   * Ed25519 keypair.\n   *\n   * @returns Account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static fromPrivateKeyAndAddress(args: CreateAccountFromPrivateKeyArgs) {\n    return this.fromPrivateKey(args);\n  }\n\n  /**\n   * Generates an account from a specified derivation path and mnemonic.\n   * This function allows you to create an account using different signing schemes based on the provided arguments.\n   *\n   * @param args - The arguments for generating the account.\n   * @param args.scheme - The signing scheme to use for account generation. Defaults to Ed25519.\n   * @param args.mnemonic - The mnemonic phrase used to derive the account.\n   * @param args.path - The derivation path used to generate the account.\n   * @param args.legacy - A boolean indicating whether to use the legacy account generation method. Defaults to true.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static fromDerivationPath(args: GenerateEd25519AccountArgs & PrivateKeyFromDerivationPathArgs): Ed25519Account;\n  static fromDerivationPath(\n    args: GenerateEd25519SingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs,\n  ): SingleKeyAccount;\n  static fromDerivationPath(args: GenerateSingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;\n  static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs): Account;\n  static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs) {\n    const { scheme = SigningSchemeInput.Ed25519, mnemonic, path, legacy = true } = args;\n    if (scheme === SigningSchemeInput.Ed25519 && legacy) {\n      return Ed25519Account.fromDerivationPath({ mnemonic, path });\n    }\n    return SingleKeyAccount.fromDerivationPath({ scheme, mnemonic, path });\n  }\n\n  /**\n   * Retrieve the authentication key for the associated account using the provided public key.\n   * This key enables account owners to rotate their private key(s) associated with the account without changing the address that\n   * hosts their account.\n   * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}\n   *\n   * @param args - The arguments for retrieving the authentication key.\n   * @param args.publicKey - The public key of the account.\n   * @returns The authentication key for the associated account.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static authKey(args: { publicKey: AccountPublicKey }): AuthenticationKey {\n    const { publicKey } = args;\n    return publicKey.authKey();\n  }\n\n  /**\n   * Sign a message using the available signing capabilities.\n   * @param message the signing message, as binary input\n   * @return the AccountAuthenticator containing the signature, together with the account's public key\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  abstract signWithAuthenticator(message: HexInput): AccountAuthenticator;\n\n  /**\n   * Sign a transaction using the available signing capabilities.\n   * @param transaction the raw transaction\n   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  abstract signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticator;\n\n  /**\n   * Sign the given message using the available signing capabilities.\n   * @param message in HexInput format\n   * @returns Signature\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  abstract sign(message: HexInput): Signature;\n\n  /**\n   * Sign the given transaction using the available signing capabilities.\n   * @param transaction the transaction to be signed\n   * @returns Signature\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  abstract signTransaction(transaction: AnyRawTransaction): Signature;\n\n  /**\n   * Verify the given message and signature with the public key.\n   * This function helps ensure the integrity and authenticity of a message by validating its signature.\n   *\n   * @param args - The arguments for verifying the signature.\n   * @param args.message - The raw message data in HexInput format.\n   * @param args.signature - The signed message signature.\n   * @returns A boolean indicating whether the signature is valid.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  verifySignature(args: VerifySignatureArgs): boolean {\n    return this.publicKey.verifySignature(args);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAsJO,IAAe,UAAf,MAAuB;AAAA,EAoC5B,OAAO,SAAS,OAA4B,CAAC,GAAG;AAC9C,UAAM,EAAE,0BAAqC,SAAS,KAAK,IAAI;AAC/D,QAAI,8BAAyC,QAAQ;AACnD,aAAO,eAAe,SAAS;AAAA,IACjC;AACA,WAAO,iBAAiB,SAAS,EAAE,OAAO,CAAC;AAAA,EAC7C;AAAA,EAkBA,OAAO,eAAe,MAA0E;AAC9F,UAAM,EAAE,YAAY,SAAS,SAAS,KAAK,IAAI;AAC/C,QAAI,sBAAsB,qBAAqB,QAAQ;AACrD,aAAO,IAAI,eAAe;AAAA,QACxB;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH;AACA,WAAO,IAAI,iBAAiB,EAAE,YAAY,QAAQ,CAAC;AAAA,EACrD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,OAAO,yBAAyB,MAAuC;AACrE,WAAO,KAAK,eAAe,IAAI;AAAA,EACjC;AAAA,EAoBA,OAAO,mBAAmB,MAA8D;AACtF,UAAM,EAAE,0BAAqC,UAAU,MAAM,SAAS,KAAK,IAAI;AAC/E,QAAI,8BAAyC,QAAQ;AACnD,aAAO,eAAe,mBAAmB,EAAE,UAAU,KAAK,CAAC;AAAA,IAC7D;AACA,WAAO,iBAAiB,mBAAmB,EAAE,QAAQ,UAAU,KAAK,CAAC;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,OAAO,QAAQ,MAA0D;AACvE,UAAM,EAAE,UAAU,IAAI;AACtB,WAAO,UAAU,QAAQ;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiDA,gBAAgB,MAAoC;AAClD,WAAO,KAAK,UAAU,gBAAgB,IAAI;AAAA,EAC5C;AACF;","names":[]}

package/dist/esm/chunk-WLTQHGIJ.mjs

@@ -1,177 +0,0 @@
-import {
-  getTableItem,
-  getTableItemsData,
-  getTableItemsMetadata
-} from "./chunk-YT7V6AVJ.mjs";
-import {
-  waitForIndexerOnVersion
-} from "./chunk-WXQUBQK4.mjs";
-
-// src/api/table.ts
-var Table = class {
-  /**
-   * Initializes a new instance of the Aptos client with the specified configuration.
-   * This allows you to interact with the Aptos blockchain using the provided settings.
-   *
-   * @param config - The configuration settings for the Aptos client.
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * async function runExample() {
-   *     // Create a new Aptos client with testnet configuration
-   *     const config = new AptosConfig({ network: Network.TESTNET });
-   *     const aptos = new Aptos(config);
-   *
-   *     console.log("Aptos client initialized:", aptos);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Table
-   */
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Queries for a specific item in a table identified by the handle and the key for the item.
-   * This function allows you to retrieve structured data from a table in the Aptos blockchain.
-   *
-   * @param args.handle A pointer to where that table is stored.
-   * @param args.data Object that describes the table item, including key and value types.
-   * @param args.data.key_type The Move type of the table key.
-   * @param args.data.value_type The Move type of the table value.
-   * @param args.data.key The value of the table key.
-   * @param args.options.ledgerVersion The ledger version to query; if not provided, it will get the latest version.
-   *
-   * @returns Table item value rendered in JSON.
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * const config = new AptosConfig({ network: Network.TESTNET });
-   * const aptos = new Aptos(config);
-   *
-   * async function runExample() {
-   *   // Retrieve a table item from the Aptos blockchain
-   *   const tableItem = await aptos.getTableItem({
-   *     handle: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca",
-   *     data: {
-   *       key_type: "address", // Move type of table key
-   *       value_type: "u128", // Move type of table value
-   *       key: "0x619dc29a0aac8fa146714058e8dd6d2d0f3bdf5f6331907bf91f3acd81e6935" // Value of table key
-   *     },
-   *   });
-   *
-   *   console.log(tableItem);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Table
-   */
-  async getTableItem(args) {
-    return getTableItem({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries for table items data with optional filtering and pagination.
-   * This function allows you to retrieve specific data from a table based on provided criteria.
-   *
-   * @param args - The arguments for querying table items data.
-   * @param args.minimumLedgerVersion - Optional minimum ledger version to wait for before querying.
-   * @param args.options - Optional parameters for pagination and filtering.
-   * @param args.options.where - Conditions to filter the response.
-   * @param args.options.offset - The number of items to skip before starting to collect the result set.
-   * @param args.options.limit - The maximum number of items to return.
-   * @param args.options.orderBy - The criteria to order the results.
-   *
-   * Note: This query calls the indexer server.
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * const config = new AptosConfig({ network: Network.TESTNET });
-   * const aptos = new Aptos(config);
-   *
-   * async function runExample() {
-   *   // Retrieve table items data with specific filtering options
-   *   const data = await aptos.getTableItemsData({
-   *     minimumLedgerVersion: 1, // specify your own minimum ledger version if needed
-   *     options: {
-   *       where: {
-   *         table_handle: { _eq: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca" },
-   *         transaction_version: { _eq: "0" }
-   *       },
-   *       limit: 10, // specify your own limit if needed
-   *     },
-   *   });
-   *
-   *   console.log(data);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   *
-   * @returns GetTableItemsDataResponse
-   * @group Table
-   */
-  async getTableItemsData(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: "default_processor" /* DEFAULT */
-    });
-    return getTableItemsData({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries for the metadata of table items, allowing for filtering and pagination.
-   *
-   * @param args - The parameters for the query.
-   * @param args.minimumLedgerVersion - Optional minimum ledger version to wait for before querying.
-   * @param args.options - Optional parameters for pagination and filtering.
-   * @param args.options.where - Conditions to filter the response.
-   * @param args.options.offset - The offset for pagination.
-   * @param args.options.limit - The maximum number of items to return.
-   * @param args.options.orderBy - The order in which to return the items.
-   *
-   * Note that this query calls the indexer server.
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * const config = new AptosConfig({ network: Network.TESTNET });
-   * const aptos = new Aptos(config);
-   *
-   * async function runExample() {
-   *   // Fetching table items metadata with a filter condition
-   *   const data = await aptos.getTableItemsMetadata({
-   *     minimumLedgerVersion: 1, // specify your own minimum ledger version if needed
-   *     options: {
-   *       where: { handle: { _eq: "0x1b854694ae746cdbd8d44186ca4929b2b337df21d1c74633be19b2710552fdca" } },
-   *       limit: 10, // specify your own limit if needed
-   *     },
-   *   });
-   *
-   *   console.log(data);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   *
-   * @returns GetTableItemsMetadataResponse
-   * @group Table
-   */
-  async getTableItemsMetadata(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: "default_processor" /* DEFAULT */
-    });
-    return getTableItemsMetadata({ aptosConfig: this.config, ...args });
-  }
-};
-
-export {
-  Table
-};
-//# sourceMappingURL=chunk-WLTQHGIJ.mjs.map

package/dist/esm/chunk-WUM247HF.mjs

@@ -1,125 +0,0 @@
-import {
-  AbstractKeylessAccount
-} from "./chunk-ILTEOGFF.mjs";
-import {
-  KeylessPublicKey,
-  getIssAudAndUidVal
-} from "./chunk-T573PCIR.mjs";
-import {
-  Deserializer
-} from "./chunk-NUT2VOX2.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/account/KeylessAccount.ts
-var KeylessAccount = class _KeylessAccount extends AbstractKeylessAccount {
-  // Use the static constructor 'create' instead.
-  /**
-   * Use the static generator `create(...)` instead.
-   * Creates an instance of the KeylessAccount with an optional proof.
-   *
-   * @param args - The parameters for creating a KeylessAccount.
-   * @param args.address - Optional account address associated with the KeylessAccount.
-   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
-   * @param args.iss - A JWT issuer.
-   * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.
-   * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.
-   * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's
-   * OIDC registration with the identity provider.
-   * @param args.pepper - A hexadecimal input used for additional security.
-   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
-   * @param args.proofFetchCallback - Optional callback function for fetching proof.
-   * @param args.jwt - A JSON Web Token used for authentication.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  constructor(args) {
-    const publicKey = KeylessPublicKey.create(args);
-    super({ publicKey, ...args });
-    this.publicKey = publicKey;
-  }
-  /**
-   * Serializes the transaction data into a format suitable for transmission or storage.
-   * This function ensures that both the transaction bytes and the proof are properly serialized.
-   *
-   * @param serializer - The serializer instance used to convert the transaction data into bytes.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  serialize(serializer) {
-    super.serialize(serializer);
-  }
-  /**
-   * Deserializes the provided deserializer to create a KeylessAccount instance.
-   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.
-   *
-   * @param deserializer - The deserializer instance used to retrieve the serialized data.
-   * @returns A KeylessAccount instance created from the deserialized data.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static deserialize(deserializer) {
-    const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } = AbstractKeylessAccount.partialDeserialize(deserializer);
-    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
-    return new _KeylessAccount({
-      address,
-      proof,
-      ephemeralKeyPair,
-      iss,
-      uidKey,
-      uidVal,
-      aud,
-      pepper,
-      jwt,
-      verificationKeyHash
-    });
-  }
-  /**
-   * Deserialize bytes using this account's information.
-   *
-   * @param bytes The bytes being interpreted.
-   * @returns
-   */
-  static fromBytes(bytes) {
-    return _KeylessAccount.deserialize(new Deserializer(Hex.hexInputToUint8Array(bytes)));
-  }
-  /**
-   * Creates a KeylessAccount instance using the provided parameters.
-   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
-   * This is used instead of the KeylessAccount constructor.
-   *
-   * @param args - The parameters for creating a KeylessAccount.
-   * @param args.address - Optional account address associated with the KeylessAccount.
-   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
-   * @param args.jwt - A JSON Web Token used for authentication.
-   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
-   * @param args.pepper - A hexadecimal input used for additional security.
-   * @param args.uidKey - Optional key for user identification, defaults to "sub".
-   * @param args.proofFetchCallback - Optional callback function for fetching proof.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static create(args) {
-    const { address, proof, jwt, ephemeralKeyPair, pepper, uidKey = "sub", proofFetchCallback, verificationKey } = args;
-    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
-    return new _KeylessAccount({
-      address,
-      proof,
-      ephemeralKeyPair,
-      iss,
-      uidKey,
-      uidVal,
-      aud,
-      pepper,
-      jwt,
-      proofFetchCallback,
-      verificationKeyHash: verificationKey ? verificationKey.hash() : void 0
-    });
-  }
-};
-
-export {
-  KeylessAccount
-};
-//# sourceMappingURL=chunk-WUM247HF.mjs.map

package/dist/esm/chunk-WUM247HF.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/KeylessAccount.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { HexInput } from \"../types\";\nimport { AccountAddress } from \"../core/accountAddress\";\nimport { getIssAudAndUidVal, Groth16VerificationKey, KeylessPublicKey, ZeroKnowledgeSig } from \"../core/crypto\";\n\nimport { EphemeralKeyPair } from \"./EphemeralKeyPair\";\nimport { Deserializer, Serializer } from \"../bcs\";\nimport { AbstractKeylessAccount, ProofFetchCallback } from \"./AbstractKeylessAccount\";\nimport { Hex } from \"../core/hex\";\n\n/**\n * Account implementation for the Keyless authentication scheme.\n *\n * Used to represent a Keyless based account and sign transactions with it.\n *\n * Use `KeylessAccount.create()` to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.\n *\n * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,\n * EphemeralKeyPair, and corresponding proof.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport class KeylessAccount extends AbstractKeylessAccount {\n  /**\n   * The KeylessPublicKey associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly publicKey: KeylessPublicKey;\n\n  // Use the static constructor 'create' instead.\n\n  /**\n   * Use the static generator `create(...)` instead.\n   * Creates an instance of the KeylessAccount with an optional proof.\n   *\n   * @param args - The parameters for creating a KeylessAccount.\n   * @param args.address - Optional account address associated with the KeylessAccount.\n   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.\n   * @param args.iss - A JWT issuer.\n   * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.\n   * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.\n   * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's\n   * OIDC registration with the identity provider.\n   * @param args.pepper - A hexadecimal input used for additional security.\n   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.\n   * @param args.proofFetchCallback - Optional callback function for fetching proof.\n   * @param args.jwt - A JSON Web Token used for authentication.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  constructor(args: {\n    address?: AccountAddress;\n    ephemeralKeyPair: EphemeralKeyPair;\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    proofFetchCallback?: ProofFetchCallback;\n    jwt: string;\n    verificationKeyHash?: HexInput;\n  }) {\n    const publicKey = KeylessPublicKey.create(args);\n    super({ publicKey, ...args });\n    this.publicKey = publicKey;\n  }\n\n  /**\n   * Serializes the transaction data into a format suitable for transmission or storage.\n   * This function ensures that both the transaction bytes and the proof are properly serialized.\n   *\n   * @param serializer - The serializer instance used to convert the transaction data into bytes.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  serialize(serializer: Serializer): void {\n    super.serialize(serializer);\n  }\n\n  /**\n   * Deserializes the provided deserializer to create a KeylessAccount instance.\n   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.\n   *\n   * @param deserializer - The deserializer instance used to retrieve the serialized data.\n   * @returns A KeylessAccount instance created from the deserialized data.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static deserialize(deserializer: Deserializer): KeylessAccount {\n    const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } =\n      AbstractKeylessAccount.partialDeserialize(deserializer);\n    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });\n    return new KeylessAccount({\n      address,\n      proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n      verificationKeyHash,\n    });\n  }\n\n  /**\n   * Deserialize bytes using this account's information.\n   *\n   * @param bytes The bytes being interpreted.\n   * @returns\n   */\n  static fromBytes(bytes: HexInput): KeylessAccount {\n    return KeylessAccount.deserialize(new Deserializer(Hex.hexInputToUint8Array(bytes)));\n  }\n\n  /**\n   * Creates a KeylessAccount instance using the provided parameters.\n   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.\n   * This is used instead of the KeylessAccount constructor.\n   *\n   * @param args - The parameters for creating a KeylessAccount.\n   * @param args.address - Optional account address associated with the KeylessAccount.\n   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.\n   * @param args.jwt - A JSON Web Token used for authentication.\n   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.\n   * @param args.pepper - A hexadecimal input used for additional security.\n   * @param args.uidKey - Optional key for user identification, defaults to \"sub\".\n   * @param args.proofFetchCallback - Optional callback function for fetching proof.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static create(args: {\n    address?: AccountAddress;\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    jwt: string;\n    ephemeralKeyPair: EphemeralKeyPair;\n    pepper: HexInput;\n    uidKey?: string;\n    proofFetchCallback?: ProofFetchCallback;\n    verificationKey?: Groth16VerificationKey;\n  }): KeylessAccount {\n    const { address, proof, jwt, ephemeralKeyPair, pepper, uidKey = \"sub\", proofFetchCallback, verificationKey } = args;\n\n    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });\n    return new KeylessAccount({\n      address,\n      proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n      proofFetchCallback,\n      verificationKeyHash: verificationKey ? verificationKey.hash() : undefined,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAwBO,IAAM,iBAAN,MAAM,wBAAuB,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA6BzD,YAAY,MAYT;AACD,UAAM,YAAY,iBAAiB,OAAO,IAAI;AAC9C,UAAM,EAAE,WAAW,GAAG,KAAK,CAAC;AAC5B,SAAK,YAAY;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,UAAU,YAA8B;AACtC,UAAM,UAAU,UAAU;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,OAAO,YAAY,cAA4C;AAC7D,UAAM,EAAE,SAAS,OAAO,kBAAkB,KAAK,QAAQ,QAAQ,oBAAoB,IACjF,uBAAuB,mBAAmB,YAAY;AACxD,UAAM,EAAE,KAAK,KAAK,OAAO,IAAI,mBAAmB,EAAE,KAAK,OAAO,CAAC;AAC/D,WAAO,IAAI,gBAAe;AAAA,MACxB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAO,UAAU,OAAiC;AAChD,WAAO,gBAAe,YAAY,IAAI,aAAa,IAAI,qBAAqB,KAAK,CAAC,CAAC;AAAA,EACrF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,OAAO,OAAO,MASK;AACjB,UAAM,EAAE,SAAS,OAAO,KAAK,kBAAkB,QAAQ,SAAS,OAAO,oBAAoB,gBAAgB,IAAI;AAE/G,UAAM,EAAE,KAAK,KAAK,OAAO,IAAI,mBAAmB,EAAE,KAAK,OAAO,CAAC;AAC/D,WAAO,IAAI,gBAAe;AAAA,MACxB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,qBAAqB,kBAAkB,gBAAgB,KAAK,IAAI;AAAA,IAClE,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/esm/chunk-WXQUBQK4.mjs

@@ -1,19 +0,0 @@
-import {
-  waitForIndexer
-} from "./chunk-BU43ZFDJ.mjs";
-
-// src/api/utils.ts
-async function waitForIndexerOnVersion(args) {
-  if (args.minimumLedgerVersion !== void 0) {
-    await waitForIndexer({
-      aptosConfig: args.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: args.processorType
-    });
-  }
-}
-
-export {
-  waitForIndexerOnVersion
-};
-//# sourceMappingURL=chunk-WXQUBQK4.mjs.map

package/dist/esm/chunk-X4N5BN3S.mjs

@@ -1,40 +0,0 @@
-import {
-  generateViewFunctionPayload
-} from "./chunk-IJ7XCPP3.mjs";
-import {
-  postBinaryAptosFullNode
-} from "./chunk-6T3V5LXK.mjs";
-import {
-  Serializer
-} from "./chunk-C7T6GW5P.mjs";
-
-// src/internal/experimental.ts
-async function viewBinary(args) {
-  const { aptosConfig, payload, options } = args;
-  const viewFunctionPayload = await generateViewFunctionPayload({
-    ...payload,
-    aptosConfig
-  });
-  const serializer = new Serializer();
-  viewFunctionPayload.serialize(serializer);
-  const bytes = serializer.toUint8Array();
-  const { data } = await postBinaryAptosFullNode({
-    aptosConfig,
-    path: "view",
-    originMethod: "view",
-    contentType: "application/x.aptos.view_function+bcs" /* BCS_VIEW_FUNCTION */,
-    acceptType: "application/x-bcs" /* BCS */,
-    params: { ledger_version: options?.ledgerVersion },
-    body: bytes
-  });
-  const array = new Uint8Array(data);
-  if (options?.convert) {
-    return options.convert(array);
-  }
-  return array;
-}
-
-export {
-  viewBinary
-};
-//# sourceMappingURL=chunk-X4N5BN3S.mjs.map

package/dist/esm/chunk-X4N5BN3S.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/experimental.ts"],"sourcesContent":["import { AptosConfig } from \"../api/aptosConfig\";\nimport { generateViewFunctionPayload, InputViewFunctionData } from \"../transactions\";\nimport { LedgerVersionArg, MimeType } from \"../types\";\nimport { Serializer } from \"../bcs\";\nimport { postBinaryAptosFullNode } from \"../client\";\n\nexport async function viewBinary(args: {\n  aptosConfig: AptosConfig;\n  payload: InputViewFunctionData;\n  options?: LedgerVersionArg & { convert?: undefined };\n}): Promise<Uint8Array>;\n\nexport async function viewBinary<T extends {}>(args: {\n  aptosConfig: AptosConfig;\n  payload: InputViewFunctionData;\n  options?: LedgerVersionArg & { convert?: (input: Uint8Array) => T };\n}): Promise<T>;\n\n/**\n * Reads a binary view function, and converts into the appropriate type if a converter is provided.\n * @experimental\n * @param args\n */\nexport async function viewBinary<T extends {} = Uint8Array>(args: {\n  aptosConfig: AptosConfig;\n  payload: InputViewFunctionData;\n  options?: LedgerVersionArg & { convert?: (input: Uint8Array) => T };\n}): Promise<Uint8Array | T> {\n  const { aptosConfig, payload, options } = args;\n  const viewFunctionPayload = await generateViewFunctionPayload({\n    ...payload,\n    aptosConfig,\n  });\n\n  const serializer = new Serializer();\n  viewFunctionPayload.serialize(serializer);\n  const bytes = serializer.toUint8Array();\n\n  const { data } = await postBinaryAptosFullNode<Uint8Array>({\n    aptosConfig,\n    path: \"view\",\n    originMethod: \"view\",\n    contentType: MimeType.BCS_VIEW_FUNCTION,\n    acceptType: MimeType.BCS,\n    params: { ledger_version: options?.ledgerVersion },\n    body: bytes,\n  });\n\n  const array = new Uint8Array(data);\n  if (options?.convert) {\n    return options.convert(array);\n  }\n\n  return array;\n}\n"],"mappings":";;;;;;;;;;;AAuBA,eAAsB,WAAsC,MAIhC;AAC1B,QAAM,EAAE,aAAa,SAAS,QAAQ,IAAI;AAC1C,QAAM,sBAAsB,MAAM,4BAA4B;AAAA,IAC5D,GAAG;AAAA,IACH;AAAA,EACF,CAAC;AAED,QAAM,aAAa,IAAI,WAAW;AAClC,sBAAoB,UAAU,UAAU;AACxC,QAAM,QAAQ,WAAW,aAAa;AAEtC,QAAM,EAAE,KAAK,IAAI,MAAM,wBAAoC;AAAA,IACzD;AAAA,IACA,MAAM;AAAA,IACN,cAAc;AAAA,IACd;AAAA,IACA;AAAA,IACA,QAAQ,EAAE,gBAAgB,SAAS,cAAc;AAAA,IACjD,MAAM;AAAA,EACR,CAAC;AAED,QAAM,QAAQ,IAAI,WAAW,IAAI;AACjC,MAAI,SAAS,SAAS;AACpB,WAAO,QAAQ,QAAQ,KAAK;AAAA,EAC9B;AAEA,SAAO;AACT;","names":[]}