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

package/dist/esm/chunk-IP7GATDH.mjs

@@ -1,322 +0,0 @@
-import {
-  view,
-  viewJson
-} from "./chunk-ORCQEMJL.mjs";
-import {
-  getBlockByHeight,
-  getBlockByVersion
-} from "./chunk-BU43ZFDJ.mjs";
-import {
-  getChainTopUserTransactions,
-  getIndexerLastSuccessVersion,
-  getLedgerInfo,
-  getProcessorStatus,
-  queryIndexer
-} from "./chunk-YK66QBML.mjs";
-
-// src/api/general.ts
-var General = class {
-  /**
-   * Initializes a new instance of the Aptos client with the specified configuration.
-   * This allows users to interact with the Aptos blockchain using the provided settings.
-   *
-   * @param config - The configuration settings for the Aptos client.
-   * @param config.network - The network to connect to (e.g., TESTNET, MAINNET).
-   * @param config.nodeUrl - The URL of the Aptos node to connect to.
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * async function runExample() {
-   *     // Create a configuration for the Aptos client
-   *     const config = new AptosConfig({
-   *         network: Network.TESTNET, // specify the network
-   *         nodeUrl: "https://testnet.aptos.dev" // specify the node URL
-   *     });
-   *
-   *     // Initialize the Aptos client with the configuration
-   *     const aptos = new Aptos(config);
-   *
-   *     console.log("Aptos client initialized:", aptos);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group General
-   */
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Queries for the Aptos ledger information.
-   *
-   * @returns The Aptos Ledger Info, which includes details such as chain ID, epoch, and ledger version.
-   *
-   * @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 the ledger information
-   *   const ledgerInfo = await aptos.getLedgerInfo();
-   *
-   *   console.log(ledgerInfo);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group General
-   */
-  async getLedgerInfo() {
-    return getLedgerInfo({ aptosConfig: this.config });
-  }
-  /**
-   * Retrieves the chain ID of the Aptos blockchain.
-   *
-   * @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 the chain ID
-   *   const chainId = await aptos.getChainId();
-   *   console.log("Chain ID:", chainId);
-   * }
-   * runExample().catch(console.error);
-   *
-   * @returns The chain ID of the Aptos blockchain.
-   * ```
-   * @group General
-   */
-  async getChainId() {
-    const result = await this.getLedgerInfo();
-    return result.chain_id;
-  }
-  /**
-   * Retrieves block information by the specified ledger version.
-   *
-   * @param args - The arguments for retrieving the block.
-   * @param args.ledgerVersion - The ledger version to lookup block information for.
-   * @param args.options - Optional parameters for the request.
-   * @param args.options.withTransactions - If set to true, include all transactions in the block.
-   *
-   * @returns Block information with optional transactions.
-   *
-   * @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 block information for a specific ledger version
-   *   const block = await aptos.getBlockByVersion({ ledgerVersion: 5 });
-   *   console.log(block);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group General
-   */
-  async getBlockByVersion(args) {
-    return getBlockByVersion({
-      aptosConfig: this.config,
-      ...args
-    });
-  }
-  /**
-   * Retrieve a block by its height, allowing for the inclusion of transactions if specified.
-   *
-   * @param args - The parameters for the block retrieval.
-   * @param args.blockHeight - The block height to look up, starting at 0.
-   * @param args.options - Optional settings for the retrieval.
-   * @param args.options.withTransactions - If set to true, includes all transactions in the block.
-   *
-   * @returns The block with optional transactions included.
-   *
-   * @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 the block at height 5, including transactions
-   *   const block = await aptos.getBlockByHeight({ blockHeight: 5, options: { withTransactions: true } });
-   *   console.log(block);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group General
-   */
-  async getBlockByHeight(args) {
-    return getBlockByHeight({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries for a Move view function
-   * @param args.payload Payload for the view function
-   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
-   *
-   * @example
-   * const data = await aptos.view({
-   *  payload: {
-   *   function: "0x1::coin::balance",
-   *   typeArguments: ["0x1::aptos_coin::AptosCoin"],
-   *   functionArguments: [accountAddress],
-   *  }
-   * })
-   *
-   * @returns an array of Move values
-   * @group General
-   */
-  async view(args) {
-    return view({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries for a Move view function with JSON, this provides compatability with the old `aptos` package
-   * @param args.payload Payload for the view function
-   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
-   *
-   * @example
-   * const data = await aptos.view({
-   *  payload: {
-   *   function: "0x1::coin::balance",
-   *   typeArguments: ["0x1::aptos_coin::AptosCoin"],
-   *   functionArguments: [accountAddress.toString()],
-   *  }
-   * })
-   *
-   * @returns an array of Move values
-   * @group General
-   */
-  async viewJson(args) {
-    return viewJson({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Queries the top user transactions based on the specified limit.
-   *
-   * @param args - The arguments for querying top user transactions.
-   * @param args.limit - The number of transactions to return.
-   * @returns GetChainTopUserTransactionsResponse
-   *
-   * @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() {
-   *   // Fetch the top user transactions with a limit of 5
-   *   const topUserTransactions = await aptos.getChainTopUserTransactions({ limit: 5 });
-   *
-   *   console.log(topUserTransactions);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group General
-   */
-  async getChainTopUserTransactions(args) {
-    return getChainTopUserTransactions({
-      aptosConfig: this.config,
-      ...args
-    });
-  }
-  /**
-   * Retrieves data from the Aptos Indexer using a GraphQL query.
-   * This function allows you to execute complex queries to fetch specific data from the Aptos blockchain.
-   *
-   * @param args.query.query - A GraphQL query string.
-   * @param args.query.variables - The variables for the query (optional).
-   *
-   * @return The provided T type.
-   *
-   * @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() {
-   *   // Querying the Aptos Indexer for ledger information
-   *   const topUserTransactions = await aptos.queryIndexer({
-   *     query: { query: `query MyQuery {
-   *       ledger_infos {
-   *         chain_id
-   *       }
-   *     }`}
-   *   });
-   *
-   *   console.log(topUserTransactions);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group General
-   */
-  async queryIndexer(args) {
-    return queryIndexer({
-      aptosConfig: this.config,
-      ...args
-    });
-  }
-  /**
-   * Queries for the last successful indexer version, providing insight into the ledger version the indexer is updated to, which
-   * may lag behind the full nodes.
-   *
-   * @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() {
-   *   // Get the last successful indexer version
-   *   const version = await aptos.getIndexerLastSuccessVersion();
-   *   console.log(`Last successful indexer version: ${version}`);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group General
-   */
-  async getIndexerLastSuccessVersion() {
-    return getIndexerLastSuccessVersion({ aptosConfig: this.config });
-  }
-  /**
-   * Query the processor status for a specific processor type.
-   *
-   * @param processorType The processor type to query.
-   * @returns The status of the specified processor type.
-   *
-   * @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() {
-   *   // Get the processor status for the account transactions processor
-   *   const status = await aptos.getProcessorStatus("account_transactions_processor");
-   *   console.log(status);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group General
-   */
-  async getProcessorStatus(processorType) {
-    return getProcessorStatus({ aptosConfig: this.config, processorType });
-  }
-};
-
-export {
-  General
-};
-//# sourceMappingURL=chunk-IP7GATDH.mjs.map

package/dist/esm/chunk-IPUAVRGL.mjs

@@ -1,248 +0,0 @@
-import {
-  Secp256k1PublicKey,
-  Secp256k1Signature
-} from "./chunk-ECTX2FGD.mjs";
-import {
-  FederatedKeylessPublicKey
-} from "./chunk-6SNGKTWE.mjs";
-import {
-  KeylessPublicKey,
-  KeylessSignature
-} from "./chunk-T573PCIR.mjs";
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-TFW6N66T.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-R4JTQQBX.mjs";
-import {
-  Signature
-} from "./chunk-KLUO6XPE.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-PKUXOBIV.mjs";
-
-// src/core/crypto/singleKey.ts
-var AnyPublicKey = class _AnyPublicKey extends AccountPublicKey {
-  // region Constructors
-  /**
-   * Creates an instance of the signature class based on the provided signature type.
-   * This allows for the handling of different signature variants such as Ed25519, Secp256k1, and Keyless.
-   *
-   * @param publicKey - The publicKey object which determines the variant to be used.
-   * @throws Error if the provided signature type is unsupported.
-   * @group Implementation
-   * @category Serialization
-   */
-  constructor(publicKey) {
-    super();
-    this.publicKey = publicKey;
-    if (publicKey instanceof Ed25519PublicKey) {
-      this.variant = 0 /* Ed25519 */;
-    } else if (publicKey instanceof Secp256k1PublicKey) {
-      this.variant = 1 /* Secp256k1 */;
-    } else if (publicKey instanceof KeylessPublicKey) {
-      this.variant = 3 /* Keyless */;
-    } else if (publicKey instanceof FederatedKeylessPublicKey) {
-      this.variant = 4 /* FederatedKeyless */;
-    } else {
-      throw new Error("Unsupported public key type");
-    }
-  }
-  // endregion
-  // region AccountPublicKey
-  /**
-   * Verifies the provided signature against the given message.
-   * This function helps ensure the integrity and authenticity of the message by confirming that the signature is valid.
-   *
-   * @param args - The arguments for signature verification.
-   * @param args.message - The message that was signed.
-   * @param args.signature - The signature to verify, which must be an instance of AnySignature.
-   * @returns A boolean indicating whether the signature is valid for the given message.
-   * @group Implementation
-   * @category Serialization
-   */
-  verifySignature(args) {
-    const { message, signature } = args;
-    if (!AnySignature.isInstance(signature)) {
-      return false;
-    }
-    return this.publicKey.verifySignature({
-      message,
-      signature: signature.signature
-    });
-  }
-  /**
-   * Generates an authentication key from the current instance's byte representation.
-   * This function is essential for creating a unique identifier for authentication purposes.
-   *
-   * @returns {AuthenticationKey} The generated authentication key.
-   * @group Implementation
-   * @category Serialization
-   */
-  authKey() {
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 2 /* SingleKey */,
-      input: this.toUint8Array()
-    });
-  }
-  /**
-   * Get the signature in bytes (Uint8Array).
-   *
-   * This function is a warning that it will soon return the underlying signature bytes directly.
-   * Use AnySignature.bcsToBytes() instead.
-   *
-   * @returns Uint8Array representation of the signature.
-   * @group Implementation
-   * @category Serialization
-   */
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  // endregion
-  // region Serializable
-  /**
-   * Serializes the current object using the provided serializer.
-   * This function helps in converting the object into a format suitable for transmission or storage.
-   *
-   * @param serializer - The serializer instance used to perform the serialization.
-   * @group Implementation
-   * @category Serialization
-   */
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.variant);
-    this.publicKey.serialize(serializer);
-  }
-  /**
-   * Deserializes an AnySignature from the provided deserializer.
-   * This function helps in reconstructing the AnySignature object from its serialized form, allowing for further processing or validation.
-   *
-   * @param deserializer - The deserializer instance used to read the serialized data.
-   * @group Implementation
-   * @category Serialization
-   */
-  static deserialize(deserializer) {
-    const variantIndex = deserializer.deserializeUleb128AsU32();
-    let publicKey;
-    switch (variantIndex) {
-      case 0 /* Ed25519 */:
-        publicKey = Ed25519PublicKey.deserialize(deserializer);
-        break;
-      case 1 /* Secp256k1 */:
-        publicKey = Secp256k1PublicKey.deserialize(deserializer);
-        break;
-      case 3 /* Keyless */:
-        publicKey = KeylessPublicKey.deserialize(deserializer);
-        break;
-      case 4 /* FederatedKeyless */:
-        publicKey = FederatedKeylessPublicKey.deserialize(deserializer);
-        break;
-      default:
-        throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);
-    }
-    return new _AnyPublicKey(publicKey);
-  }
-  // endregion
-  /**
-   * Determines if the provided public key is an instance of AnyPublicKey.
-   *
-   * @param publicKey - The public key to check.
-   * @deprecated Use `instanceof AnyPublicKey` instead.
-   * @group Implementation
-   * @category Serialization
-   */
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _AnyPublicKey;
-  }
-  /**
-   * Determines if the current public key is an instance of Ed25519PublicKey.
-   *
-   * @deprecated use `publicKey instanceof Ed25519PublicKey` instead.
-   * @group Implementation
-   * @category Serialization
-   */
-  isEd25519() {
-    return this.publicKey instanceof Ed25519PublicKey;
-  }
-  /**
-   * Checks if the public key is an instance of Secp256k1PublicKey.
-   *
-   * @deprecated use `publicKey instanceof Secp256k1PublicKey` instead.
-   * @group Implementation
-   * @category Serialization
-   */
-  isSecp256k1PublicKey() {
-    return this.publicKey instanceof Secp256k1PublicKey;
-  }
-  /**
-   * Determines if the provided publicKey is an instance of a valid PublicKey object.
-   *
-   * @param publicKey - The publicKey to be checked for validity.
-   * @param publicKey.publicKey - The actual publicKey object that needs to be validated.
-   * @returns True if the signature is a valid instance; otherwise, false.
-   * @group Implementation
-   * @category Serialization
-   */
-  static isInstance(publicKey) {
-    return "publicKey" in publicKey && "variant" in publicKey;
-  }
-};
-var AnySignature = class _AnySignature extends Signature {
-  // region Constructors
-  constructor(signature) {
-    super();
-    this.signature = signature;
-    if (signature instanceof Ed25519Signature) {
-      this.variant = 0 /* Ed25519 */;
-    } else if (signature instanceof Secp256k1Signature) {
-      this.variant = 1 /* Secp256k1 */;
-    } else if (signature instanceof KeylessSignature) {
-      this.variant = 3 /* Keyless */;
-    } else {
-      throw new Error("Unsupported signature type");
-    }
-  }
-  // endregion
-  // region AccountSignature
-  toUint8Array() {
-    console.warn(
-      "[Aptos SDK] Calls to AnySignature.toUint8Array() will soon return the underlying signature bytes. Use AnySignature.bcsToBytes() instead."
-    );
-    return this.bcsToBytes();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.variant);
-    this.signature.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const variantIndex = deserializer.deserializeUleb128AsU32();
-    let signature;
-    switch (variantIndex) {
-      case 0 /* Ed25519 */:
-        signature = Ed25519Signature.deserialize(deserializer);
-        break;
-      case 1 /* Secp256k1 */:
-        signature = Secp256k1Signature.deserialize(deserializer);
-        break;
-      case 3 /* Keyless */:
-        signature = KeylessSignature.deserialize(deserializer);
-        break;
-      default:
-        throw new Error(`Unknown variant index for AnySignature: ${variantIndex}`);
-    }
-    return new _AnySignature(signature);
-  }
-  // endregion
-  static isInstance(signature) {
-    return "signature" in signature && typeof signature.signature === "object" && signature.signature !== null && "toUint8Array" in signature.signature;
-  }
-};
-
-export {
-  AnyPublicKey,
-  AnySignature
-};
-//# sourceMappingURL=chunk-IPUAVRGL.mjs.map