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

package/dist/esm/chunk-A7LYGPFL.mjs

@@ -1,208 +0,0 @@
-import {
-  getAccountEventsByCreationNumber,
-  getAccountEventsByEventType,
-  getEvents,
-  getModuleEventsByEventType
-} from "./chunk-Y3M32DIB.mjs";
-import {
-  waitForIndexerOnVersion
-} from "./chunk-WXQUBQK4.mjs";
-
-// src/api/event.ts
-var Event = class {
-  /**
-   * Initializes a new instance of the Aptos client with the provided configuration.
-   *
-   * @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.
-   * @param config.faucetUrl - The URL of the faucet to use for funding accounts.
-   *
-   * @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 }); // Specify your own network if needed
-   *     const aptos = new Aptos(config);
-   *
-   *     console.log("Aptos client initialized:", aptos);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Event
-   */
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Retrieve module events based on a specified event type.
-   * This function allows you to query for events that are associated with a particular module event type in the Aptos blockchain.
-   *
-   * @param args - The arguments for retrieving module events.
-   * @param args.eventType - The event type to filter the results.
-   * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-   * @param args.options - Optional pagination and ordering parameters for the event results.
-   *
-   * @returns Promise<GetEventsResponse> - A promise that resolves to the retrieved events.
-   *
-   * @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 module events for a specific event type
-   *   const events = await aptos.getModuleEventsByEventType({
-   *     eventType: "0x1::transaction_fee::FeeStatement", // specify the event type
-   *     minimumLedgerVersion: 1, // optional: specify minimum ledger version if needed
-   *   });
-   *
-   *   console.log(events); // log the retrieved events
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Event
-   */
-  async getModuleEventsByEventType(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: "events_processor" /* EVENTS_PROCESSOR */
-    });
-    return getModuleEventsByEventType({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Retrieve events associated with a specific account address and creation number.
-   *
-   * @param args - The parameters for retrieving account events.
-   * @param args.accountAddress - The account address to query events for.
-   * @param args.creationNumber - The event creation number to filter the events.
-   * @param args.minimumLedgerVersion - Optional minimum ledger version to sync up to before querying.
-   *
-   * @returns Promise<GetEventsResponse>
-   *
-   * @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 events for the account at creation number 0
-   *   const events = await aptos.getAccountEventsByCreationNumber({
-   *     accountAddress: "0x1", // replace with a real account address
-   *     creationNumber: 0,
-   *   });
-   *
-   *   console.log(events);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Event
-   */
-  async getAccountEventsByCreationNumber(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: "events_processor" /* EVENTS_PROCESSOR */
-    });
-    return getAccountEventsByCreationNumber({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Retrieve events associated with a specific account address and event type.
-   *
-   * @param args.accountAddress - The account address to query events for.
-   * @param args.eventType - The type of event to filter by.
-   * @param args.minimumLedgerVersion - Optional ledger version to sync up to before querying.
-   * @param args.options - Optional pagination and ordering parameters for the event query.
-   *
-   * @returns Promise<GetEventsResponse>
-   *
-   * @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 events for a specific account and event type
-   *   const events = await aptos.getAccountEventsByEventType({
-   *     accountAddress: "0x1", // replace with a real account address
-   *     eventType: "0x1::transaction_fee::FeeStatement", // replace with a real event type
-   *     minimumLedgerVersion: 1, // optional, specify if needed
-   *   });
-   *
-   *   console.log(events);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Event
-   */
-  async getAccountEventsByEventType(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: "events_processor" /* EVENTS_PROCESSOR */
-    });
-    return getAccountEventsByEventType({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Retrieve all events from the Aptos blockchain.
-   * An optional `where` clause can be provided to filter the results based on specific criteria.
-   *
-   * @param args Optional parameters for the query.
-   * @param args.minimumLedgerVersion Optional ledger version to sync up to before querying.
-   * @param args.options Optional pagination and filtering options.
-   * @param args.options.where Optional condition to filter events.
-   * @param args.options.offset Optional pagination offset.
-   * @param args.options.limit Optional maximum number of events to return.
-   * @param args.options.orderBy Optional ordering of the results.
-   *
-   * @returns GetEventsQuery response type containing the events.
-   *
-   * @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 all events
-   *   const events = await aptos.getEvents();
-   *
-   *   // Retrieve events with filtering by account address
-   *   const whereCondition = {
-   *     account_address: { _eq: "0x123" }, // replace with a real account address
-   *   };
-   *   const filteredEvents = await aptos.getEvents({
-   *     options: { where: whereCondition },
-   *   });
-   *
-   *   console.log(events);
-   *   console.log(filteredEvents);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Event
-   */
-  async getEvents(args) {
-    await waitForIndexerOnVersion({
-      config: this.config,
-      minimumLedgerVersion: args?.minimumLedgerVersion,
-      processorType: "events_processor" /* EVENTS_PROCESSOR */
-    });
-    return getEvents({ aptosConfig: this.config, ...args });
-  }
-};
-
-export {
-  Event
-};
-//# sourceMappingURL=chunk-A7LYGPFL.mjs.map

package/dist/esm/chunk-AGKEC2IM.mjs

@@ -1,250 +0,0 @@
-import {
-  MultiEd25519PublicKey,
-  MultiEd25519Signature
-} from "./chunk-3TUV6YMI.mjs";
-import {
-  MultiKey,
-  MultiKeySignature
-} from "./chunk-DMFRIING.mjs";
-import {
-  AnyPublicKey,
-  AnySignature
-} from "./chunk-IPUAVRGL.mjs";
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-TFW6N66T.mjs";
-import {
-  getFunctionParts,
-  isValidFunctionInfo
-} from "./chunk-RQS33JAS.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  Serializable
-} from "./chunk-C7T6GW5P.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/transactions/authenticator/account.ts
-var AccountAuthenticator = class extends Serializable {
-  /**
-   * Deserializes an AccountAuthenticator from the provided deserializer.
-   * This function helps in reconstructing the AccountAuthenticator object based on the variant index.
-   *
-   * @param deserializer - The deserializer instance used to read the serialized data.
-   * @group Implementation
-   * @category Transactions
-   */
-  static deserialize(deserializer) {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case 0 /* Ed25519 */:
-        return AccountAuthenticatorEd25519.load(deserializer);
-      case 1 /* MultiEd25519 */:
-        return AccountAuthenticatorMultiEd25519.load(deserializer);
-      case 2 /* SingleKey */:
-        return AccountAuthenticatorSingleKey.load(deserializer);
-      case 3 /* MultiKey */:
-        return AccountAuthenticatorMultiKey.load(deserializer);
-      case 4 /* NoAccountAuthenticator */:
-        return AccountAuthenticatorNoAccountAuthenticator.load(deserializer);
-      case 5 /* Abstraction */:
-        return AccountAuthenticatorAbstraction.load(deserializer);
-      default:
-        throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`);
-    }
-  }
-  /**
-   * Determines if the current instance is an Ed25519 account authenticator.
-   *
-   * @returns {boolean} True if the instance is of type AccountAuthenticatorEd25519, otherwise false.
-   * @group Implementation
-   * @category Transactions
-   */
-  isEd25519() {
-    return this instanceof AccountAuthenticatorEd25519;
-  }
-  /**
-   * Determines if the current instance is of type AccountAuthenticatorMultiEd25519.
-   *
-   * @returns {boolean} True if the instance is a multi-signature Ed25519 account authenticator, otherwise false.
-   * @group Implementation
-   * @category Transactions
-   */
-  isMultiEd25519() {
-    return this instanceof AccountAuthenticatorMultiEd25519;
-  }
-  /**
-   * Determines if the current instance is of the type AccountAuthenticatorSingleKey.
-   *
-   * @returns {boolean} True if the instance is an AccountAuthenticatorSingleKey, otherwise false.
-   * @group Implementation
-   * @category Transactions
-   */
-  isSingleKey() {
-    return this instanceof AccountAuthenticatorSingleKey;
-  }
-  /**
-   * Determine if the current instance is of type AccountAuthenticatorMultiKey.
-   *
-   * @returns {boolean} Returns true if the instance is an AccountAuthenticatorMultiKey, otherwise false.
-   * @group Implementation
-   * @category Transactions
-   */
-  isMultiKey() {
-    return this instanceof AccountAuthenticatorMultiKey;
-  }
-};
-var AccountAuthenticatorEd25519 = class _AccountAuthenticatorEd25519 extends AccountAuthenticator {
-  /**
-   * Creates an instance of the class with the specified public keys and signatures.
-   *
-   * @param public_key The public key used for verification.
-   * @param signature The signatures corresponding to the public keys.
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(public_key, signature) {
-    super();
-    this.public_key = public_key;
-    this.signature = signature;
-  }
-  /**
-   * Serializes the account authenticator data into the provided serializer.
-   * This function captures the multi-key variant, public keys, and signatures for serialization.
-   *
-   * @param serializer - The serializer instance used to perform the serialization.
-   * @group Implementation
-   * @category Transactions
-   */
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(0 /* Ed25519 */);
-    this.public_key.serialize(serializer);
-    this.signature.serialize(serializer);
-  }
-  /**
-   * Loads an instance of AccountAuthenticatorMultiKey from the provided deserializer.
-   * This function helps in reconstructing the authenticator object using the deserialized public keys and signatures.
-   *
-   * @param deserializer - The deserializer used to extract the necessary data for loading the authenticator.
-   * @group Implementation
-   * @category Transactions
-   */
-  static load(deserializer) {
-    const public_key = Ed25519PublicKey.deserialize(deserializer);
-    const signature = Ed25519Signature.deserialize(deserializer);
-    return new _AccountAuthenticatorEd25519(public_key, signature);
-  }
-};
-var AccountAuthenticatorMultiEd25519 = class _AccountAuthenticatorMultiEd25519 extends AccountAuthenticator {
-  constructor(public_key, signature) {
-    super();
-    this.public_key = public_key;
-    this.signature = signature;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(1 /* MultiEd25519 */);
-    this.public_key.serialize(serializer);
-    this.signature.serialize(serializer);
-  }
-  static load(deserializer) {
-    const public_key = MultiEd25519PublicKey.deserialize(deserializer);
-    const signature = MultiEd25519Signature.deserialize(deserializer);
-    return new _AccountAuthenticatorMultiEd25519(public_key, signature);
-  }
-};
-var AccountAuthenticatorSingleKey = class _AccountAuthenticatorSingleKey extends AccountAuthenticator {
-  constructor(public_key, signature) {
-    super();
-    this.public_key = public_key;
-    this.signature = signature;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(2 /* SingleKey */);
-    this.public_key.serialize(serializer);
-    this.signature.serialize(serializer);
-  }
-  static load(deserializer) {
-    const public_key = AnyPublicKey.deserialize(deserializer);
-    const signature = AnySignature.deserialize(deserializer);
-    return new _AccountAuthenticatorSingleKey(public_key, signature);
-  }
-};
-var AccountAuthenticatorMultiKey = class _AccountAuthenticatorMultiKey extends AccountAuthenticator {
-  constructor(public_keys, signatures) {
-    super();
-    this.public_keys = public_keys;
-    this.signatures = signatures;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(3 /* MultiKey */);
-    this.public_keys.serialize(serializer);
-    this.signatures.serialize(serializer);
-  }
-  static load(deserializer) {
-    const public_keys = MultiKey.deserialize(deserializer);
-    const signatures = MultiKeySignature.deserialize(deserializer);
-    return new _AccountAuthenticatorMultiKey(public_keys, signatures);
-  }
-};
-var AccountAuthenticatorNoAccountAuthenticator = class _AccountAuthenticatorNoAccountAuthenticator extends AccountAuthenticator {
-  // eslint-disable-next-line class-methods-use-this
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(4 /* NoAccountAuthenticator */);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  static load(deserializer) {
-    return new _AccountAuthenticatorNoAccountAuthenticator();
-  }
-};
-var AccountAuthenticatorAbstraction = class _AccountAuthenticatorAbstraction extends AccountAuthenticator {
-  constructor(functionInfo, signingMessageDigest, authenticator) {
-    super();
-    if (!isValidFunctionInfo(functionInfo)) {
-      throw new Error(`Invalid function info ${functionInfo} passed into AccountAuthenticatorAbstraction`);
-    }
-    this.functionInfo = functionInfo;
-    this.authenticator = Hex.fromHexInput(authenticator);
-    this.signingMessageDigest = Hex.fromHexInput(Hex.fromHexInput(signingMessageDigest).toUint8Array());
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(5 /* Abstraction */);
-    const { moduleAddress, moduleName, functionName } = getFunctionParts(this.functionInfo);
-    AccountAddress.fromString(moduleAddress).serialize(serializer);
-    serializer.serializeStr(moduleName);
-    serializer.serializeStr(functionName);
-    serializer.serializeU32AsUleb128(0 /* V1 */);
-    serializer.serializeBytes(this.signingMessageDigest.toUint8Array());
-    serializer.serializeFixedBytes(this.authenticator.toUint8Array());
-  }
-  static load(deserializer) {
-    const moduleAddress = AccountAddress.deserialize(deserializer);
-    const moduleName = deserializer.deserializeStr();
-    const functionName = deserializer.deserializeStr();
-    const variant = deserializer.deserializeUleb128AsU32();
-    if (variant === 0 /* V1 */) {
-      const signingMessageDigest = deserializer.deserializeBytes();
-      const authenticator = deserializer.deserializeFixedBytes(deserializer.remaining());
-      return new _AccountAuthenticatorAbstraction(
-        `${moduleAddress}::${moduleName}::${functionName}`,
-        signingMessageDigest,
-        authenticator
-      );
-    }
-    throw new Error(`Unknown variant index for AccountAuthenticatorAbstraction: ${variant}`);
-  }
-};
-
-export {
-  AccountAuthenticator,
-  AccountAuthenticatorEd25519,
-  AccountAuthenticatorMultiEd25519,
-  AccountAuthenticatorSingleKey,
-  AccountAuthenticatorMultiKey,
-  AccountAuthenticatorNoAccountAuthenticator,
-  AccountAuthenticatorAbstraction
-};
-//# sourceMappingURL=chunk-AGKEC2IM.mjs.map

package/dist/esm/chunk-AKXCFBYF.mjs

@@ -1,49 +0,0 @@
-import {
-  AccountPublicKey
-} from "./chunk-R4JTQQBX.mjs";
-import {
-  Signature
-} from "./chunk-KLUO6XPE.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-PKUXOBIV.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/core/crypto/abstraction.ts
-var AbstractSignature = class _AbstractSignature extends Signature {
-  constructor(value) {
-    super();
-    this.value = Hex.fromHexInput(value);
-  }
-  serialize(serializer) {
-    serializer.serializeBytes(this.value.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    return new _AbstractSignature(deserializer.deserializeBytes());
-  }
-};
-var AbstractPublicKey = class extends AccountPublicKey {
-  constructor(accountAddress) {
-    super();
-    this.accountAddress = accountAddress;
-  }
-  authKey() {
-    return new AuthenticationKey({ data: this.accountAddress.toUint8Array() });
-  }
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  verifySignature(args) {
-    throw new Error("This function is not implemented for AbstractPublicKey.");
-  }
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  serialize(serializer) {
-    throw new Error("This function is not implemented for AbstractPublicKey.");
-  }
-};
-
-export {
-  AbstractSignature,
-  AbstractPublicKey
-};
-//# sourceMappingURL=chunk-AKXCFBYF.mjs.map

package/dist/esm/chunk-APM7OSLS.mjs

@@ -1,122 +0,0 @@
-// src/core/crypto/poseidon.ts
-import {
-  poseidon1,
-  poseidon2,
-  poseidon3,
-  poseidon4,
-  poseidon5,
-  poseidon6,
-  poseidon7,
-  poseidon8,
-  poseidon9,
-  poseidon10,
-  poseidon11,
-  poseidon12,
-  poseidon13,
-  poseidon14,
-  poseidon15,
-  poseidon16
-} from "poseidon-lite";
-var numInputsToPoseidonFunc = [
-  poseidon1,
-  poseidon2,
-  poseidon3,
-  poseidon4,
-  poseidon5,
-  poseidon6,
-  poseidon7,
-  poseidon8,
-  poseidon9,
-  poseidon10,
-  poseidon11,
-  poseidon12,
-  poseidon13,
-  poseidon14,
-  poseidon15,
-  poseidon16
-];
-var BYTES_PACKED_PER_SCALAR = 31;
-var MAX_NUM_INPUT_SCALARS = 16;
-var MAX_NUM_INPUT_BYTES = (MAX_NUM_INPUT_SCALARS - 1) * BYTES_PACKED_PER_SCALAR;
-function hashStrToField(str, maxSizeBytes) {
-  const textEncoder = new TextEncoder();
-  const strBytes = textEncoder.encode(str);
-  return hashBytesWithLen(strBytes, maxSizeBytes);
-}
-function hashBytesWithLen(bytes, maxSizeBytes) {
-  if (bytes.length > maxSizeBytes) {
-    throw new Error(`Inputted bytes of length ${bytes} is longer than ${maxSizeBytes}`);
-  }
-  const packed = padAndPackBytesWithLen(bytes, maxSizeBytes);
-  return poseidonHash(packed);
-}
-function padAndPackBytesNoLen(bytes, maxSizeBytes) {
-  if (bytes.length > maxSizeBytes) {
-    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
-  }
-  const paddedStrBytes = padUint8ArrayWithZeros(bytes, maxSizeBytes);
-  return packBytes(paddedStrBytes);
-}
-function padAndPackBytesWithLen(bytes, maxSizeBytes) {
-  if (bytes.length > maxSizeBytes) {
-    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
-  }
-  return padAndPackBytesNoLen(bytes, maxSizeBytes).concat([BigInt(bytes.length)]);
-}
-function packBytes(bytes) {
-  if (bytes.length > MAX_NUM_INPUT_BYTES) {
-    throw new Error(`Can't pack more than ${MAX_NUM_INPUT_BYTES}.  Was given ${bytes.length} bytes`);
-  }
-  return chunkUint8Array(bytes, BYTES_PACKED_PER_SCALAR).map((chunk) => bytesToBigIntLE(chunk));
-}
-function chunkUint8Array(array, chunkSize) {
-  const result = [];
-  for (let i = 0; i < array.length; i += chunkSize) {
-    result.push(array.subarray(i, i + chunkSize));
-  }
-  return result;
-}
-function bytesToBigIntLE(bytes) {
-  let result = BigInt(0);
-  for (let i = bytes.length - 1; i >= 0; i -= 1) {
-    result = result << BigInt(8) | BigInt(bytes[i]);
-  }
-  return result;
-}
-function bigIntToBytesLE(value, length) {
-  let val = BigInt(value);
-  const bytes = new Uint8Array(length);
-  for (let i = 0; i < length; i += 1) {
-    bytes[i] = Number(val & BigInt(255));
-    val >>= BigInt(8);
-  }
-  return bytes;
-}
-function padUint8ArrayWithZeros(inputArray, paddedSize) {
-  if (paddedSize < inputArray.length) {
-    throw new Error("Padded size must be greater than or equal to the input array size.");
-  }
-  const paddedArray = new Uint8Array(paddedSize);
-  paddedArray.set(inputArray);
-  for (let i = inputArray.length; i < paddedSize; i += 1) {
-    paddedArray[i] = 0;
-  }
-  return paddedArray;
-}
-function poseidonHash(inputs) {
-  if (inputs.length > numInputsToPoseidonFunc.length) {
-    throw new Error(
-      `Unable to hash input of length ${inputs.length}.  Max input length is ${numInputsToPoseidonFunc.length}`
-    );
-  }
-  return numInputsToPoseidonFunc[inputs.length - 1](inputs);
-}
-
-export {
-  hashStrToField,
-  padAndPackBytesWithLen,
-  bytesToBigIntLE,
-  bigIntToBytesLE,
-  poseidonHash
-};
-//# sourceMappingURL=chunk-APM7OSLS.mjs.map