@aptos-labs/ts-sdk 4.0.0-zeta.0 → 5.0.0

package/dist/esm/chunk-UAXZDOSV.mjs

@@ -1,19 +0,0 @@
-import {
-  waitForIndexer
-} from "./chunk-4OAWQT57.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-UAXZDOSV.mjs.map

package/dist/esm/chunk-UKXKN5YN.mjs

@@ -1,72 +0,0 @@
-import {
-  Hex
-} from "./chunk-GHQTJGG6.mjs";
-
-// src/core/crypto/privateKey.ts
-var _PrivateKey = class _PrivateKey {
-  /**
-   * Format a HexInput to an AIP-80 compliant string.
-   *
-   * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
-   *
-   * @param privateKey - The HexString or Uint8Array format of the private key.
-   * @param privateKeyType - The private key type
-   */
-  static formatPrivateKey(privateKey, type) {
-    const aip80Prefix = _PrivateKey.AIP80_PREFIXES[type];
-    let formattedPrivateKey = privateKey;
-    if (typeof formattedPrivateKey === "string" && formattedPrivateKey.startsWith(aip80Prefix)) {
-      formattedPrivateKey = formattedPrivateKey.split("-")[2];
-    }
-    return `${aip80Prefix}${Hex.fromHexInput(formattedPrivateKey).toString()}`;
-  }
-  /**
-   * Parse a HexInput that may be a HexString, Uint8Array, or a AIP-80 compliant string to a Hex instance.
-   *
-   * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
-   *
-   * @param value - A HexString, Uint8Array, or a AIP-80 compliant string.
-   * @param privateKeyType - The private key type
-   * @param strict - If true, the value MUST be compliant with AIP-80.
-   */
-  static parseHexInput(value, type, strict) {
-    let data;
-    const aip80Prefix = _PrivateKey.AIP80_PREFIXES[type];
-    if (typeof value === "string") {
-      if (!strict && !value.startsWith(aip80Prefix)) {
-        data = Hex.fromHexInput(value);
-        if (strict !== false) {
-          console.warn(
-            "[Aptos SDK] It is recommended that private keys are AIP-80 compliant (https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md). You can fix the private key by formatting it with `PrivateKey.formatPrivateKey(privateKey: string, type: 'ed25519' | 'secp256k1'): string`."
-          );
-        }
-      } else if (value.startsWith(aip80Prefix)) {
-        data = Hex.fromHexString(value.split("-")[2]);
-      } else {
-        if (strict) {
-          throw new Error("Invalid HexString input while parsing private key. Must AIP-80 compliant string.");
-        }
-        throw new Error("Invalid HexString input while parsing private key.");
-      }
-    } else {
-      data = Hex.fromHexInput(value);
-    }
-    return data;
-  }
-};
-/**
- * The AIP-80 compliant prefixes for each private key type. Append this to a private key's hex representation
- * to get an AIP-80 compliant string.
- *
- * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
- */
-_PrivateKey.AIP80_PREFIXES = {
-  ["ed25519" /* Ed25519 */]: "ed25519-priv-",
-  ["secp256k1" /* Secp256k1 */]: "secp256k1-priv-"
-};
-var PrivateKey = _PrivateKey;
-
-export {
-  PrivateKey
-};
-//# sourceMappingURL=chunk-UKXKN5YN.mjs.map

package/dist/esm/chunk-WZD3K77H.mjs

@@ -1,53 +0,0 @@
-import {
-  Signature
-} from "./chunk-MOQKSDHO.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-ITS22VZT.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-6ZZZXQX5.mjs";
-import {
-  Hex
-} from "./chunk-GHQTJGG6.mjs";
-
-// src/core/crypto/abstraction.ts
-var AbstractSignature = class _AbstractSignature extends Signature {
-  constructor(value) {
-    super();
-    this.value = Hex.fromHexInput(value).toUint8Array();
-  }
-  serialize(serializer) {
-    serializer.serializeBytes(this.value);
-  }
-  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
-  async verifySignatureAsync(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-WZD3K77H.mjs.map

package/dist/esm/chunk-XBBBLYRH.mjs

@@ -1,66 +0,0 @@
-import {
-  queryIndexer
-} from "./chunk-QIM243UU.mjs";
-import {
-  GetTableItemsData,
-  GetTableItemsMetadata
-} from "./chunk-A5FS7NAD.mjs";
-import {
-  postAptosFullNode
-} from "./chunk-GREMFKLA.mjs";
-
-// src/internal/table.ts
-async function getTableItem(args) {
-  const { aptosConfig, handle, data, options } = args;
-  const response = await postAptosFullNode({
-    aptosConfig,
-    originMethod: "getTableItem",
-    path: `tables/${handle}/item`,
-    params: { ledger_version: options?.ledgerVersion },
-    body: data
-  });
-  return response.data;
-}
-async function getTableItemsData(args) {
-  const { aptosConfig, options } = args;
-  const graphqlQuery = {
-    query: GetTableItemsData,
-    variables: {
-      where_condition: options?.where,
-      offset: options?.offset,
-      limit: options?.limit,
-      order_by: options?.orderBy
-    }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getTableItemsData"
-  });
-  return data.table_items;
-}
-async function getTableItemsMetadata(args) {
-  const { aptosConfig, options } = args;
-  const graphqlQuery = {
-    query: GetTableItemsMetadata,
-    variables: {
-      where_condition: options?.where,
-      offset: options?.offset,
-      limit: options?.limit,
-      order_by: options?.orderBy
-    }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getTableItemsMetadata"
-  });
-  return data.table_metadatas;
-}
-
-export {
-  getTableItem,
-  getTableItemsData,
-  getTableItemsMetadata
-};
-//# sourceMappingURL=chunk-XBBBLYRH.mjs.map

package/dist/esm/chunk-YJJUYS67.mjs

@@ -1,329 +0,0 @@
-import {
-  Hex
-} from "./chunk-GHQTJGG6.mjs";
-import {
-  MAX_U32_NUMBER
-} from "./chunk-SBB4YEPT.mjs";
-
-// src/bcs/deserializer.ts
-var Deserializer = class _Deserializer {
-  /**
-   * Creates a new instance of the class with a copy of the provided data buffer.
-   * This prevents outside mutation of the buffer.
-   *
-   * @param data - The data to be copied into the internal buffer as a Uint8Array.
-   * @group Implementation
-   * @category BCS
-   */
-  constructor(data) {
-    this.buffer = new ArrayBuffer(data.length);
-    new Uint8Array(this.buffer).set(data, 0);
-    this.offset = 0;
-  }
-  static fromHex(hex) {
-    const data = Hex.hexInputToUint8Array(hex);
-    return new _Deserializer(data);
-  }
-  /**
-   * Reads a specified number of bytes from the buffer and advances the offset.
-   *
-   * @param length - The number of bytes to read from the buffer.
-   * @throws Throws an error if the read operation exceeds the buffer's length.
-   * @group Implementation
-   * @category BCS
-   */
-  read(length) {
-    if (this.offset + length > this.buffer.byteLength) {
-      throw new Error("Reached to the end of buffer");
-    }
-    const bytes = this.buffer.slice(this.offset, this.offset + length);
-    this.offset += length;
-    return bytes;
-  }
-  /**
-   * Returns the number of bytes remaining in the buffer.
-   *
-   * This information is useful to determine if there's more data to be read.
-   *
-   * @returns The number of bytes remaining in the buffer.
-   * @group Implementation
-   * @category BCS
-   */
-  remaining() {
-    return this.buffer.byteLength - this.offset;
-  }
-  /**
-   * Asserts that the buffer has no remaining bytes.
-   *
-   * @throws {Error} Throws an error if there are remaining bytes in the buffer.
-   * @group Implementation
-   * @category BCS
-   */
-  assertFinished() {
-    if (this.remaining() !== 0) {
-      throw new Error("Buffer has remaining bytes");
-    }
-  }
-  /**
-   * Deserializes a UTF-8 encoded string from a byte array. It first reads the length of the string in bytes,
-   * followed by the actual byte content, and decodes it into a string.
-   *
-   * BCS layout for "string": string_length | string_content
-   * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
-   *
-   * @example
-   * ```typescript
-   * const deserializer = new Deserializer(new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
-   * assert(deserializer.deserializeStr() === "1234abcd");
-   * ```
-   * @group Implementation
-   * @category BCS
-   */
-  deserializeStr() {
-    const value = this.deserializeBytes();
-    const textDecoder = new TextDecoder();
-    return textDecoder.decode(value);
-  }
-  /**
-   * @deprecated use `deserializeOption("string")` instead.
-   *
-   * The BCS layout for Optional<String> is 0 if none, else 1 followed by the string length and string content.
-   * @returns The deserialized string if it exists, otherwise undefined.
-   * @example
-   * ```typescript
-   * const deserializer = new Deserializer(new Uint8Array([0x00]));
-   * assert(deserializer.deserializeOptionStr() === undefined);
-   * const deserializer = new Deserializer(new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));
-   * assert(deserializer.deserializeOptionStr() === "1234abcd");
-   * ```
-   */
-  deserializeOptionStr() {
-    return this.deserializeOption("string");
-  }
-  deserializeOption(type, len) {
-    const exists = this.deserializeBool();
-    if (!exists) return void 0;
-    if (type === "string") {
-      return this.deserializeStr();
-    }
-    if (type === "bytes") {
-      return this.deserializeBytes();
-    }
-    if (type === "fixedBytes") {
-      if (len === void 0) {
-        throw new Error("Fixed bytes length not provided");
-      }
-      return this.deserializeFixedBytes(len);
-    }
-    return this.deserialize(type);
-  }
-  /**
-   * Deserializes an array of bytes.
-   *
-   * The BCS layout for "bytes" consists of a bytes_length followed by the bytes themselves, where bytes_length is a u32 integer
-   * encoded as a uleb128 integer, indicating the length of the bytes array.
-   *
-   * @returns {Uint8Array} The deserialized array of bytes.
-   * @group Implementation
-   * @category BCS
-   */
-  deserializeBytes() {
-    const len = this.deserializeUleb128AsU32();
-    return new Uint8Array(this.read(len));
-  }
-  /**
-   * Deserializes an array of bytes of a specified length.
-   *
-   * @param len - The number of bytes to read from the source.
-   * @group Implementation
-   * @category BCS
-   */
-  deserializeFixedBytes(len) {
-    return new Uint8Array(this.read(len));
-  }
-  /**
-   * Deserializes a boolean value from a byte stream.
-   *
-   * The BCS layout for a boolean uses one byte, where "0x01" represents true and "0x00" represents false.
-   * An error is thrown if the byte value is not valid.
-   *
-   * @returns The deserialized boolean value.
-   * @throws Throws an error if the boolean value is invalid.
-   * @group Implementation
-   * @category BCS
-   */
-  deserializeBool() {
-    const bool = new Uint8Array(this.read(1))[0];
-    if (bool !== 1 && bool !== 0) {
-      throw new Error("Invalid boolean value");
-    }
-    return bool === 1;
-  }
-  /**
-   * Deserializes a uint8 number from the binary data.
-   *
-   * BCS layout for "uint8": One byte. Binary format in little-endian representation.
-   *
-   * @returns {number} The deserialized uint8 number.
-   * @group Implementation
-   * @category BCS
-   */
-  deserializeU8() {
-    return new DataView(this.read(1)).getUint8(0);
-  }
-  /**
-   * Deserializes a uint16 number from a binary format in little-endian representation.
-   *
-   * BCS layout for "uint16": Two bytes.
-   * @example
-   * ```typescript
-   * const deserializer = new Deserializer(new Uint8Array([0x34, 0x12]));
-   * assert(deserializer.deserializeU16() === 4660);
-   * ```
-   * @group Implementation
-   * @category BCS
-   */
-  deserializeU16() {
-    return new DataView(this.read(2)).getUint16(0, true);
-  }
-  /**
-   * Deserializes a uint32 number from a binary format in little-endian representation.
-   *
-   * BCS layout for "uint32": Four bytes.
-   * @example
-   * ```typescript
-   * const deserializer = new Deserializer(new Uint8Array([0x78, 0x56, 0x34, 0x12]));
-   * assert(deserializer.deserializeU32() === 305419896);
-   * ```
-   * @group Implementation
-   * @category BCS
-   */
-  deserializeU32() {
-    return new DataView(this.read(4)).getUint32(0, true);
-  }
-  /**
-   * Deserializes a uint64 number.
-   *
-   * This function combines two 32-bit values to return a 64-bit unsigned integer in little-endian representation.
-   * @example
-   * ```typescript
-   * const deserializer = new Deserializer(new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
-   * assert(deserializer.deserializeU64() === 1311768467750121216);
-   * ```
-   * @group Implementation
-   * @category BCS
-   */
-  deserializeU64() {
-    const low = this.deserializeU32();
-    const high = this.deserializeU32();
-    return BigInt(BigInt(high) << BigInt(32) | BigInt(low));
-  }
-  /**
-   * Deserializes a uint128 number from its binary representation.
-   * This function combines two 64-bit values to return a single uint128 value in little-endian format.
-   *
-   * @returns {BigInt} The deserialized uint128 number.
-   * @group Implementation
-   * @category BCS
-   */
-  deserializeU128() {
-    const low = this.deserializeU64();
-    const high = this.deserializeU64();
-    return BigInt(high << BigInt(64) | low);
-  }
-  /**
-   * Deserializes a uint256 number from its binary representation.
-   *
-   * The BCS layout for "uint256" consists of thirty-two bytes in little-endian format.
-   *
-   * @returns {BigInt} The deserialized uint256 number.
-   * @group Implementation
-   * @category BCS
-   */
-  deserializeU256() {
-    const low = this.deserializeU128();
-    const high = this.deserializeU128();
-    return BigInt(high << BigInt(128) | low);
-  }
-  /**
-   * Deserializes a uleb128 encoded uint32 number.
-   *
-   * This function is used for interpreting lengths of variable-length sequences and tags of enum values in BCS encoding.
-   *
-   * @throws {Error} Throws an error if the parsed value exceeds the maximum uint32 number.
-   * @returns {number} The deserialized uint32 value.
-   * @group Implementation
-   * @category BCS
-   */
-  deserializeUleb128AsU32() {
-    let value = BigInt(0);
-    let shift = 0;
-    while (value < MAX_U32_NUMBER) {
-      const byte = this.deserializeU8();
-      value |= BigInt(byte & 127) << BigInt(shift);
-      if ((byte & 128) === 0) {
-        break;
-      }
-      shift += 7;
-    }
-    if (value > MAX_U32_NUMBER) {
-      throw new Error("Overflow while parsing uleb128-encoded uint32 value");
-    }
-    return Number(value);
-  }
-  /**
-   * Helper function that primarily exists to support alternative syntax for deserialization.
-   * That is, if we have a `const deserializer: new Deserializer(...)`, instead of having to use
-   * `MyClass.deserialize(deserializer)`, we can call `deserializer.deserialize(MyClass)`.
-   *
-   * @example const deserializer = new Deserializer(new Uint8Array([1, 2, 3]));
-   * const value = deserializer.deserialize(MyClass); // where MyClass has a `deserialize` function
-   * // value is now an instance of MyClass
-   * // equivalent to `const value = MyClass.deserialize(deserializer)`
-   * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
-   *
-   * @returns the deserialized value of class type T
-   * @group Implementation
-   * @category BCS
-   */
-  deserialize(cls) {
-    return cls.deserialize(this);
-  }
-  /**
-   * Deserializes an array of BCS Deserializable values given an existing Deserializer instance with a loaded byte buffer.
-   *
-   * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
-   * @returns An array of deserialized values of type T.
-   * @example
-   * // serialize a vector of addresses
-   * const addresses = new Array<AccountAddress>(
-   *   AccountAddress.from("0x1"),
-   *   AccountAddress.from("0x2"),
-   *   AccountAddress.from("0xa"),
-   *   AccountAddress.from("0xb"),
-   * );
-   * const serializer = new Serializer();
-   * serializer.serializeVector(addresses);
-   * const serializedBytes = serializer.toUint8Array();
-   *
-   * // deserialize the bytes into an array of addresses
-   * const deserializer = new Deserializer(serializedBytes);
-   * const deserializedAddresses = deserializer.deserializeVector(AccountAddress);
-   * // deserializedAddresses is now an array of AccountAddress instances
-   * @group Implementation
-   * @category BCS
-   */
-  deserializeVector(cls) {
-    const length = this.deserializeUleb128AsU32();
-    const vector = new Array();
-    for (let i = 0; i < length; i += 1) {
-      vector.push(this.deserialize(cls));
-    }
-    return vector;
-  }
-};
-
-export {
-  Deserializer
-};
-//# sourceMappingURL=chunk-YJJUYS67.mjs.map