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

package/dist/esm/chunk-FJJ3KCPC.mjs

@@ -1,376 +0,0 @@
-import {
-  Hex
-} from "./chunk-GHQTJGG6.mjs";
-import {
-  MAX_U128_BIG_INT,
-  MAX_U16_NUMBER,
-  MAX_U256_BIG_INT,
-  MAX_U32_NUMBER,
-  MAX_U64_BIG_INT,
-  MAX_U8_NUMBER
-} from "./chunk-SBB4YEPT.mjs";
-import {
-  __decorateClass
-} from "./chunk-SAWN7RJP.mjs";
-
-// src/bcs/serializer.ts
-var Serializable = class {
-  /**
-   * Serializes a `Serializable` value to its BCS representation.
-   * This function is the TypeScript SDK equivalent of `bcs::to_bytes` in Move.
-   * @returns the BCS representation of the Serializable instance as a byte buffer.
-   * @group Implementation
-   * @category BCS
-   */
-  bcsToBytes() {
-    const serializer = new Serializer();
-    this.serialize(serializer);
-    return serializer.toUint8Array();
-  }
-  /**
-   * Converts the BCS-serialized bytes of a value into a Hex instance.
-   * This function provides a Hex representation of the BCS-serialized data for easier handling and manipulation.
-   * @returns A Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array.
-   * @group Implementation
-   * @category BCS
-   */
-  bcsToHex() {
-    const bcsBytes = this.bcsToBytes();
-    return Hex.fromHexInput(bcsBytes);
-  }
-  /**
-   * Returns the hex string representation of the `Serializable` value without the 0x prefix.
-   * @returns the hex format as a string without `0x` prefix.
-   */
-  toStringWithoutPrefix() {
-    return this.bcsToHex().toStringWithoutPrefix();
-  }
-  /**
-   * Returns the hex string representation of the `Serializable` value with the 0x prefix.
-   * @returns the hex formatas a string prefixed by `0x`.
-   */
-  toString() {
-    return `0x${this.toStringWithoutPrefix()}`;
-  }
-};
-var Serializer = class {
-  /**
-   * Constructs a serializer with a buffer of size `length` bytes, 64 bytes by default.
-   * The `length` must be greater than 0.
-   *
-   * @param length - The size of the buffer in bytes.
-   * @group Implementation
-   * @category BCS
-   */
-  constructor(length = 64) {
-    if (length <= 0) {
-      throw new Error("Length needs to be greater than 0");
-    }
-    this.buffer = new ArrayBuffer(length);
-    this.offset = 0;
-  }
-  /**
-   * Ensures that the internal buffer can accommodate the specified number of bytes.
-   * This function dynamically resizes the buffer if the current size is insufficient.
-   *
-   * @param bytes - The number of bytes to ensure the buffer can handle.
-   * @group Implementation
-   * @category BCS
-   */
-  ensureBufferWillHandleSize(bytes) {
-    while (this.buffer.byteLength < this.offset + bytes) {
-      const newBuffer = new ArrayBuffer(this.buffer.byteLength * 2);
-      new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
-      this.buffer = newBuffer;
-    }
-  }
-  /**
-   * Appends the specified values to the buffer, ensuring that the buffer can accommodate the new data.
-   *
-   * @param {Uint8Array} values - The values to be appended to the buffer.
-   * @group Implementation
-   * @category BCS
-   */
-  appendToBuffer(values) {
-    this.ensureBufferWillHandleSize(values.length);
-    new Uint8Array(this.buffer, this.offset).set(values);
-    this.offset += values.length;
-  }
-  /**
-   * Serializes a value into the buffer using the provided function, ensuring the buffer can accommodate the size.
-   *
-   * @param fn - The function to serialize the value, which takes a byte offset, the value to serialize, and an optional little-endian flag.
-   * @param fn.byteOffset - The byte offset at which to write the value.
-   * @param fn.value - The numeric value to serialize into the buffer.
-   * @param fn.littleEndian - Optional flag indicating whether to use little-endian byte order (defaults to true).
-   * @group Implementation
-   * @category BCS
-   */
-  // TODO: JSDoc bytesLength and value
-  serializeWithFunction(fn, bytesLength, value) {
-    this.ensureBufferWillHandleSize(bytesLength);
-    const dv = new DataView(this.buffer, this.offset);
-    fn.apply(dv, [0, value, true]);
-    this.offset += bytesLength;
-  }
-  /**
-   * Serializes a string. UTF8 string is supported.
-   * The number of bytes in the string content is serialized first, as a uleb128-encoded u32 integer.
-   * Then the string content is serialized as UTF8 encoded bytes.
-   *
-   * 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.
-   *
-   * @param value - The string to serialize.
-   *
-   * @example
-   * ```typescript
-   * const serializer = new Serializer();
-   * serializer.serializeStr("1234abcd");
-   * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
-   * ```
-   * @group Implementation
-   * @category BCS
-   */
-  serializeStr(value) {
-    const textEncoder = new TextEncoder();
-    this.serializeBytes(textEncoder.encode(value));
-  }
-  /**
-   * Serializes an array of bytes.
-   *
-   * This function encodes the length of the byte array as a u32 integer in uleb128 format, followed by the byte array itself.
-   * BCS layout for "bytes": bytes_length | bytes
-   * where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.
-   * @param value - The byte array to serialize.
-   * @group Implementation
-   * @category BCS
-   */
-  serializeBytes(value) {
-    this.serializeU32AsUleb128(value.length);
-    this.appendToBuffer(value);
-  }
-  /**
-     * Serializes an array of bytes with a known length, allowing for efficient deserialization without needing to serialize the
-     * length itself.
-     * When deserializing, the number of bytes to deserialize needs to be passed in.
-  
-     * @param value - The Uint8Array to be serialized.
-     * @group Implementation
-     * @category BCS
-     */
-  serializeFixedBytes(value) {
-    this.appendToBuffer(value);
-  }
-  /**
-   * Serializes a boolean value into a byte representation.
-   *
-   * The BCS layout for a boolean uses one byte, where "0x01" represents true and "0x00" represents false.
-   *
-   * @param value - The boolean value to serialize.
-   * @group Implementation
-   * @category BCS
-   */
-  serializeBool(value) {
-    ensureBoolean(value);
-    const byteValue = value ? 1 : 0;
-    this.appendToBuffer(new Uint8Array([byteValue]));
-  }
-  serializeU8(value) {
-    this.appendToBuffer(new Uint8Array([value]));
-  }
-  serializeU16(value) {
-    this.serializeWithFunction(DataView.prototype.setUint16, 2, value);
-  }
-  serializeU32(value) {
-    this.serializeWithFunction(DataView.prototype.setUint32, 4, value);
-  }
-  serializeU64(value) {
-    const low = BigInt(value) & BigInt(MAX_U32_NUMBER);
-    const high = BigInt(value) >> BigInt(32);
-    this.serializeU32(Number(low));
-    this.serializeU32(Number(high));
-  }
-  serializeU128(value) {
-    const low = BigInt(value) & MAX_U64_BIG_INT;
-    const high = BigInt(value) >> BigInt(64);
-    this.serializeU64(low);
-    this.serializeU64(high);
-  }
-  serializeU256(value) {
-    const low = BigInt(value) & MAX_U128_BIG_INT;
-    const high = BigInt(value) >> BigInt(128);
-    this.serializeU128(low);
-    this.serializeU128(high);
-  }
-  serializeU32AsUleb128(val) {
-    let value = val;
-    const valueArray = [];
-    while (value >>> 7 !== 0) {
-      valueArray.push(value & 127 | 128);
-      value >>>= 7;
-    }
-    valueArray.push(value);
-    this.appendToBuffer(new Uint8Array(valueArray));
-  }
-  /**
-   * Returns the buffered bytes as a Uint8Array.
-   *
-   * This function allows you to retrieve the byte representation of the buffer up to the current offset.
-   *
-   * @returns Uint8Array - The byte array representation of the buffer.
-   * @group Implementation
-   * @category BCS
-   */
-  toUint8Array() {
-    return new Uint8Array(this.buffer).slice(0, this.offset);
-  }
-  /**
-   * Serializes a `Serializable` value, facilitating composable serialization.
-   *
-   * @param value The Serializable value to serialize.
-   *
-   * @returns the serializer instance
-   * @group Implementation
-   * @category BCS
-   */
-  serialize(value) {
-    value.serialize(this);
-  }
-  /**
-   * Serializes an array of BCS Serializable values to a serializer instance.
-   * The bytes are added to the serializer instance's byte buffer.
-   *
-   * @param values The array of BCS Serializable values
-   * @example
-   * 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();
-   * // serializedBytes is now the BCS-serialized bytes
-   * // The equivalent value in Move would be:
-   * // `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`;
-   * @group Implementation
-   * @category BCS
-   */
-  serializeVector(values) {
-    this.serializeU32AsUleb128(values.length);
-    values.forEach((item) => {
-      item.serialize(this);
-    });
-  }
-  /**
-   * Serializes an optional value which can be a Serializable, string, or Uint8Array.
-   * For strings and Uint8Arrays, it uses the appropriate serialization method.
-   *
-   * @param value The value to serialize (Serializable, string, Uint8Array, or undefined)
-   * @param len Optional fixed length for Uint8Array serialization. If provided, uses serializeFixedBytes instead of serializeBytes
-   *
-   * @example
-   * ```typescript
-   * const serializer = new Serializer();
-   * serializer.serializeOption("hello");  // Serializes optional string
-   * serializer.serializeOption(new Uint8Array([1, 2, 3]));  // Serializes optional bytes
-   * serializer.serializeOption(new Uint8Array([1, 2, 3]), 3);  // Serializes optional fixed-length bytes
-   * serializer.serializeOption(new AccountAddress(...));  // Serializes optional Serializable
-   * serializer.serializeOption(undefined);  // Serializes none case
-   * ```
-   * @group Implementation
-   * @category BCS
-   */
-  serializeOption(value, len) {
-    const hasValue = value !== void 0;
-    this.serializeBool(hasValue);
-    if (hasValue) {
-      if (typeof value === "string") {
-        this.serializeStr(value);
-      } else if (value instanceof Uint8Array) {
-        if (len !== void 0) {
-          this.serializeFixedBytes(value);
-        } else {
-          this.serializeBytes(value);
-        }
-      } else {
-        value.serialize(this);
-      }
-    }
-  }
-  /**
-   * @deprecated use `serializeOption` instead.
-   * Serializes an optional string, supporting UTF8 encoding.
-   * The function encodes the existence of the string first, followed by the length and content if it exists.
-   *
-   * BCS layout for optional "string": 1 | 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.
-   * BCS layout for undefined: 0
-   *
-   * @param value - The optional string to serialize. If undefined, it will serialize as 0.
-   * @group Implementation
-   * @category BCS
-   */
-  serializeOptionStr(value) {
-    if (value === void 0) {
-      this.serializeU32AsUleb128(0);
-    } else {
-      this.serializeU32AsUleb128(1);
-      this.serializeStr(value);
-    }
-  }
-};
-__decorateClass([
-  checkNumberRange(0, MAX_U8_NUMBER)
-], Serializer.prototype, "serializeU8", 1);
-__decorateClass([
-  checkNumberRange(0, MAX_U16_NUMBER)
-], Serializer.prototype, "serializeU16", 1);
-__decorateClass([
-  checkNumberRange(0, MAX_U32_NUMBER)
-], Serializer.prototype, "serializeU32", 1);
-__decorateClass([
-  checkNumberRange(BigInt(0), MAX_U64_BIG_INT)
-], Serializer.prototype, "serializeU64", 1);
-__decorateClass([
-  checkNumberRange(BigInt(0), MAX_U128_BIG_INT)
-], Serializer.prototype, "serializeU128", 1);
-__decorateClass([
-  checkNumberRange(BigInt(0), MAX_U256_BIG_INT)
-], Serializer.prototype, "serializeU256", 1);
-__decorateClass([
-  checkNumberRange(0, MAX_U32_NUMBER)
-], Serializer.prototype, "serializeU32AsUleb128", 1);
-function ensureBoolean(value) {
-  if (typeof value !== "boolean") {
-    throw new Error(`${value} is not a boolean value`);
-  }
-}
-var outOfRangeErrorMessage = (value, min, max) => `${value} is out of range: [${min}, ${max}]`;
-function validateNumberInRange(value, minValue, maxValue) {
-  const valueBigInt = BigInt(value);
-  if (valueBigInt > BigInt(maxValue) || valueBigInt < BigInt(minValue)) {
-    throw new Error(outOfRangeErrorMessage(value, minValue, maxValue));
-  }
-}
-function checkNumberRange(minValue, maxValue) {
-  return (target, propertyKey, descriptor) => {
-    const childFunction = descriptor.value;
-    descriptor.value = function deco(value) {
-      validateNumberInRange(value, minValue, maxValue);
-      return childFunction.apply(this, [value]);
-    };
-    return descriptor;
-  };
-}
-
-export {
-  Serializable,
-  Serializer,
-  ensureBoolean,
-  outOfRangeErrorMessage,
-  validateNumberInRange
-};
-//# sourceMappingURL=chunk-FJJ3KCPC.mjs.map

package/dist/esm/chunk-GHQTJGG6.mjs

@@ -1,196 +0,0 @@
-import {
-  ParsingError
-} from "./chunk-QPT4BSAB.mjs";
-
-// src/core/hex.ts
-import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
-var HexInvalidReason = /* @__PURE__ */ ((HexInvalidReason2) => {
-  HexInvalidReason2["TOO_SHORT"] = "too_short";
-  HexInvalidReason2["INVALID_LENGTH"] = "invalid_length";
-  HexInvalidReason2["INVALID_HEX_CHARS"] = "invalid_hex_chars";
-  return HexInvalidReason2;
-})(HexInvalidReason || {});
-var Hex = class _Hex {
-  /**
-   * Create a new Hex instance from a Uint8Array.
-   *
-   * @param data - The Uint8Array containing the data to initialize the Hex instance.
-   * @group Implementation
-   * @category Serialization
-   */
-  constructor(data) {
-    this.data = data;
-  }
-  // ===
-  // Methods for representing an instance of Hex as other types.
-  // ===
-  /**
-   * Get the inner hex data as a Uint8Array. The inner data is already a Uint8Array, so no conversion takes place.
-   *
-   * @returns Hex data as Uint8Array
-   * @group Implementation
-   * @category Serialization
-   */
-  toUint8Array() {
-    return this.data;
-  }
-  /**
-   * Get the hex data as a string without the 0x prefix.
-   *
-   * @returns Hex string without 0x prefix
-   * @group Implementation
-   * @category Serialization
-   */
-  toStringWithoutPrefix() {
-    return bytesToHex(this.data);
-  }
-  /**
-   * Get the hex data as a string with the 0x prefix.
-   *
-   * @returns Hex string with 0x prefix
-   * @group Implementation
-   * @category Serialization
-   */
-  toString() {
-    return `0x${this.toStringWithoutPrefix()}`;
-  }
-  // ===
-  // Methods for creating an instance of Hex from other types.
-  // ===
-  /**
-   * Converts a hex string into a Hex instance, allowing for both prefixed and non-prefixed formats.
-   *
-   * @param str - A hex string, with or without the 0x prefix.
-   *
-   * @throws ParsingError - If the hex string is too short, has an odd number of characters, or contains invalid hex characters.
-   *
-   * @returns Hex - The resulting Hex instance created from the provided string.
-   * @group Implementation
-   * @category Serialization
-   */
-  static fromHexString(str) {
-    let input = str;
-    if (input.startsWith("0x")) {
-      input = input.slice(2);
-    }
-    if (input.length === 0) {
-      throw new ParsingError(
-        "Hex string is too short, must be at least 1 char long, excluding the optional leading 0x.",
-        "too_short" /* TOO_SHORT */
-      );
-    }
-    if (input.length % 2 !== 0) {
-      throw new ParsingError("Hex string must be an even number of hex characters.", "invalid_length" /* INVALID_LENGTH */);
-    }
-    try {
-      return new _Hex(hexToBytes(input));
-    } catch (error) {
-      throw new ParsingError(
-        `Hex string contains invalid hex characters: ${error?.message}`,
-        "invalid_hex_chars" /* INVALID_HEX_CHARS */
-      );
-    }
-  }
-  /**
-   * Converts an instance of HexInput, which can be a string or a Uint8Array, into a Hex instance.
-   * This function is useful for transforming hexadecimal representations into a structured Hex object for further manipulation.
-   *
-   * @param hexInput - A HexInput which can be a string or Uint8Array.
-   * @returns A Hex instance created from the provided hexInput.
-   * @group Implementation
-   * @category Serialization
-   */
-  static fromHexInput(hexInput) {
-    if (hexInput instanceof Uint8Array) return new _Hex(hexInput);
-    return _Hex.fromHexString(hexInput);
-  }
-  /**
-   * Converts an instance of HexInput, which can be a string or a Uint8Array, into a Uint8Array.
-   *
-   * @param hexInput - A HexInput which can be a string or Uint8Array.
-   * @returns A Uint8Array created from the provided hexInput.
-   */
-  static hexInputToUint8Array(hexInput) {
-    if (hexInput instanceof Uint8Array) return hexInput;
-    return _Hex.fromHexString(hexInput).toUint8Array();
-  }
-  /**
-   * Converts a HexInput (string or Uint8Array) to a hex string with '0x' prefix.
-   *
-   * @param hexInput - The input to convert, either a hex string (with/without '0x' prefix) or Uint8Array
-   * @returns A hex string with '0x' prefix (e.g., "0x1234")
-   *
-   * @example
-   * ```typescript
-   * Hex.hexInputToString("1234")        // returns "0x1234"
-   * Hex.hexInputToString("0x1234")      // returns "0x1234"
-   * Hex.hexInputToString(new Uint8Array([0x12, 0x34])) // returns "0x1234"
-   * ```
-   */
-  static hexInputToString(hexInput) {
-    return _Hex.fromHexInput(hexInput).toString();
-  }
-  /**
-   * Converts a HexInput (string or Uint8Array) to a hex string without '0x' prefix.
-   *
-   * @param hexInput - The input to convert, either a hex string (with/without '0x' prefix) or Uint8Array
-   * @returns A hex string without '0x' prefix (e.g., "1234")
-   *
-   * @example
-   * ```typescript
-   * Hex.hexInputToStringWithoutPrefix("1234")        // returns "1234"
-   * Hex.hexInputToStringWithoutPrefix("0x1234")      // returns "1234"
-   * Hex.hexInputToStringWithoutPrefix(new Uint8Array([0x12, 0x34])) // returns "1234"
-   * ```
-   */
-  static hexInputToStringWithoutPrefix(hexInput) {
-    return _Hex.fromHexInput(hexInput).toStringWithoutPrefix();
-  }
-  // ===
-  // Methods for checking validity.
-  // ===
-  /**
-   * Check if the provided string is a valid hexadecimal representation.
-   *
-   * @param str - A hex string representing byte data.
-   *
-   * @returns An object containing:
-   *  - valid: A boolean indicating whether the string is valid.
-   *  - invalidReason: The reason for invalidity if the string is not valid.
-   *  - invalidReasonMessage: A message explaining why the string is invalid.
-   * @group Implementation
-   * @category Serialization
-   */
-  static isValid(str) {
-    try {
-      _Hex.fromHexString(str);
-      return { valid: true };
-    } catch (error) {
-      return {
-        valid: false,
-        invalidReason: error?.invalidReason,
-        invalidReasonMessage: error?.message
-      };
-    }
-  }
-  /**
-   * Determine if two Hex instances are equal by comparing their underlying byte data.
-   *
-   * @param other The Hex instance to compare to.
-   * @returns true if the Hex instances are equal, false if not.
-   * @group Implementation
-   * @category Serialization
-   */
-  equals(other) {
-    if (this.data.length !== other.data.length) return false;
-    return this.data.every((value, index) => value === other.data[index]);
-  }
-};
-var hexToAsciiString = (hex) => new TextDecoder().decode(Hex.fromHexInput(hex).toUint8Array());
-
-export {
-  HexInvalidReason,
-  Hex,
-  hexToAsciiString
-};
-//# sourceMappingURL=chunk-GHQTJGG6.mjs.map

package/dist/esm/chunk-GREMFKLA.mjs

@@ -1,84 +0,0 @@
-import {
-  aptosRequest
-} from "./chunk-ORIVGO5I.mjs";
-
-// src/client/post.ts
-async function post(options) {
-  const { type, originMethod, path, body, acceptType, contentType, params, aptosConfig, overrides } = options;
-  const url = aptosConfig.getRequestUrl(type);
-  return aptosRequest(
-    {
-      url,
-      method: "POST",
-      originMethod,
-      path,
-      body,
-      contentType,
-      acceptType,
-      params,
-      overrides
-    },
-    aptosConfig,
-    options.type
-  );
-}
-async function postAptosFullNode(options) {
-  const { aptosConfig } = options;
-  return post({
-    ...options,
-    type: "Fullnode" /* FULLNODE */,
-    overrides: {
-      ...aptosConfig.clientConfig,
-      ...aptosConfig.fullnodeConfig,
-      ...options.overrides,
-      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS }
-    }
-  });
-}
-async function postAptosIndexer(options) {
-  const { aptosConfig } = options;
-  return post({
-    ...options,
-    type: "Indexer" /* INDEXER */,
-    overrides: {
-      ...aptosConfig.clientConfig,
-      ...aptosConfig.indexerConfig,
-      ...options.overrides,
-      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.indexerConfig?.HEADERS }
-    }
-  });
-}
-async function postAptosFaucet(options) {
-  const { aptosConfig } = options;
-  const modifiedAptosConfig = {
-    ...aptosConfig,
-    clientConfig: { ...aptosConfig.clientConfig }
-  };
-  delete modifiedAptosConfig?.clientConfig?.API_KEY;
-  return post({
-    ...options,
-    type: "Faucet" /* FAUCET */,
-    overrides: {
-      ...modifiedAptosConfig.clientConfig,
-      ...modifiedAptosConfig.faucetConfig,
-      ...options.overrides,
-      HEADERS: { ...modifiedAptosConfig.clientConfig?.HEADERS, ...modifiedAptosConfig.faucetConfig?.HEADERS }
-    }
-  });
-}
-async function postAptosPepperService(options) {
-  return post({ ...options, type: "Pepper" /* PEPPER */ });
-}
-async function postAptosProvingService(options) {
-  return post({ ...options, type: "Prover" /* PROVER */ });
-}
-
-export {
-  post,
-  postAptosFullNode,
-  postAptosIndexer,
-  postAptosFaucet,
-  postAptosPepperService,
-  postAptosProvingService
-};
-//# sourceMappingURL=chunk-GREMFKLA.mjs.map