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

package/dist/esm/chunk-FQQW55X7.mjs

@@ -0,0 +1,288 @@
+import {
+  Hex
+} from "./chunk-YV7M4CFP.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-OR7TEZ25.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
+   */
+  bcsToBytes() {
+    const serializer = new Serializer();
+    this.serialize(serializer);
+    return serializer.toUint8Array();
+  }
+  /**
+   * Helper function to get a value's BCS-serialized bytes as a Hex instance.
+   * @returns a Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array
+   */
+  bcsToHex() {
+    const bcsBytes = this.bcsToBytes();
+    return Hex.fromHexInput(bcsBytes);
+  }
+};
+var Serializer = class {
+  // Constructs a serializer with a buffer of size `length` bytes, 64 bytes by default.
+  // `length` must be greater than 0.
+  constructor(length = 64) {
+    if (length <= 0) {
+      throw new Error("Length needs to be greater than 0");
+    }
+    this.buffer = new ArrayBuffer(length);
+    this.offset = 0;
+  }
+  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;
+    }
+  }
+  appendToBuffer(values) {
+    this.ensureBufferWillHandleSize(values.length);
+    new Uint8Array(this.buffer, this.offset).set(values);
+    this.offset += values.length;
+  }
+  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.
+   *
+   * @example
+   * ```ts
+   * const serializer = new Serializer();
+   * serializer.serializeStr("1234abcd");
+   * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
+   * ```
+   */
+  serializeStr(value) {
+    const textEncoder = new TextEncoder();
+    this.serializeBytes(textEncoder.encode(value));
+  }
+  /**
+   * Serializes an array of bytes.
+   *
+   * 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.
+   */
+  serializeBytes(value) {
+    this.serializeU32AsUleb128(value.length);
+    this.appendToBuffer(value);
+  }
+  /**
+   * Serializes an array of bytes with known length. Therefore, length doesn't need to be
+   * serialized to help deserialization.
+   *
+   * When deserializing, the number of bytes to deserialize needs to be passed in.
+   */
+  serializeFixedBytes(value) {
+    this.appendToBuffer(value);
+  }
+  /**
+   * Serializes a boolean value.
+   *
+   * BCS layout for "boolean": One byte. "0x01" for true and "0x00" for false.
+   */
+  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
+   */
+  toUint8Array() {
+    return new Uint8Array(this.buffer).slice(0, this.offset);
+  }
+  /**
+   * Serializes a `Serializable` value, facilitating composable serialization.
+   *
+   * @param value The Serializable value to serialize
+   *
+   * @example
+   * // Define the MoveStruct class that implements the Serializable interface
+   * class MoveStruct extends Serializable {
+   *     constructor(
+   *         public creatorAddress: AccountAddress, // where AccountAddress extends Serializable
+   *         public collectionName: string,
+   *         public tokenName: string
+   *     ) {}
+   *
+   *     serialize(serializer: Serializer): void {
+   *         serializer.serialize(this.creatorAddress);  // Composable serialization of another Serializable object
+   *         serializer.serializeStr(this.collectionName);
+   *         serializer.serializeStr(this.tokenName);
+   *     }
+   * }
+   *
+   * // Construct a MoveStruct
+   * const moveStruct = new MoveStruct(new AccountAddress(...), "MyCollection", "TokenA");
+   *
+   * // Serialize a string, a u64 number, and a MoveStruct instance.
+   * const serializer = new Serializer();
+   * serializer.serializeStr("ExampleString");
+   * serializer.serializeU64(12345678);
+   * serializer.serialize(moveStruct);
+   *
+   * // Get the bytes from the Serializer instance
+   * const serializedBytes = serializer.toUint8Array();
+   *
+   * @returns the serializer instance
+   */
+  serialize(value) {
+    value.serialize(this);
+  }
+  /**
+   * Serializes an array of BCS Serializable values to a serializer instance.
+   * Note that this does not return anything. 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])`;
+   */
+  serializeVector(values) {
+    this.serializeU32AsUleb128(values.length);
+    values.forEach((item) => {
+      item.serialize(this);
+    });
+  }
+  serializeOption(value) {
+    if (value === void 0) {
+      this.serializeU32AsUleb128(0);
+    } else {
+      this.serializeU32AsUleb128(1);
+      value.serialize(this);
+    }
+  }
+  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-FQQW55X7.mjs.map

package/dist/esm/{chunk-TVRJ3M7B.mjs.map → chunk-FQQW55X7.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/bcs/serializer.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/* eslint-disable no-bitwise */\nimport {\n  MAX_U128_BIG_INT,\n  MAX_U16_NUMBER,\n  MAX_U32_NUMBER,\n  MAX_U64_BIG_INT,\n  MAX_U8_NUMBER,\n  MAX_U256_BIG_INT,\n} from \"./consts\";\nimport { Hex } from \"../core/hex\";\nimport { AnyNumber, Uint16, Uint32, Uint8 } from \"../types\";\n\n// This class is intended to be used as a base class for all serializable types.\n// It can be used to facilitate composable serialization of a complex type and\n// in general to serialize a type to its BCS representation.\nexport abstract class Serializable {\n  abstract serialize(serializer: Serializer): void;\n\n  /**\n   * Serializes a `Serializable` value to its BCS representation.\n   * This function is the Typescript SDK equivalent of `bcs::to_bytes` in Move.\n   * @returns the BCS representation of the Serializable instance as a byte buffer\n   */\n  bcsToBytes(): Uint8Array {\n    const serializer = new Serializer();\n    this.serialize(serializer);\n    return serializer.toUint8Array();\n  }\n\n  /**\n   * Helper function to get a value's BCS-serialized bytes as a Hex instance.\n   * @returns a Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array\n   */\n  bcsToHex(): Hex {\n    const bcsBytes = this.bcsToBytes();\n    return Hex.fromHexInput(bcsBytes);\n  }\n}\n\nexport class Serializer {\n  private buffer: ArrayBuffer;\n\n  private offset: number;\n\n  // Constructs a serializer with a buffer of size `length` bytes, 64 bytes by default.\n  // `length` must be greater than 0.\n  constructor(length: number = 64) {\n    if (length <= 0) {\n      throw new Error(\"Length needs to be greater than 0\");\n    }\n    this.buffer = new ArrayBuffer(length);\n    this.offset = 0;\n  }\n\n  private ensureBufferWillHandleSize(bytes: number) {\n    while (this.buffer.byteLength < this.offset + bytes) {\n      const newBuffer = new ArrayBuffer(this.buffer.byteLength * 2);\n      new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));\n      this.buffer = newBuffer;\n    }\n  }\n\n  protected appendToBuffer(values: Uint8Array) {\n    this.ensureBufferWillHandleSize(values.length);\n    new Uint8Array(this.buffer, this.offset).set(values);\n    this.offset += values.length;\n  }\n\n  private serializeWithFunction(\n    fn: (byteOffset: number, value: number, littleEndian?: boolean) => void,\n    bytesLength: number,\n    value: number,\n  ) {\n    this.ensureBufferWillHandleSize(bytesLength);\n    const dv = new DataView(this.buffer, this.offset);\n    fn.apply(dv, [0, value, true]);\n    this.offset += bytesLength;\n  }\n\n  /**\n   * Serializes a string. UTF8 string is supported.\n   *\n   * The number of bytes in the string content is serialized first, as a uleb128-encoded u32 integer.\n   * Then the string content is serialized as UTF8 encoded bytes.\n   *\n   * BCS layout for \"string\": string_length | string_content\n   * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.\n   *\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeStr(\"1234abcd\");\n   * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));\n   * ```\n   */\n  serializeStr(value: string) {\n    const textEncoder = new TextEncoder();\n    this.serializeBytes(textEncoder.encode(value));\n  }\n\n  /**\n   * Serializes an array of bytes.\n   *\n   * BCS layout for \"bytes\": bytes_length | bytes\n   * where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.\n   */\n  serializeBytes(value: Uint8Array) {\n    this.serializeU32AsUleb128(value.length);\n    this.appendToBuffer(value);\n  }\n\n  /**\n   * Serializes an array of bytes with known length. Therefore, length doesn't need to be\n   * serialized to help deserialization.\n   *\n   * When deserializing, the number of bytes to deserialize needs to be passed in.\n   */\n  serializeFixedBytes(value: Uint8Array) {\n    this.appendToBuffer(value);\n  }\n\n  /**\n   * Serializes a boolean value.\n   *\n   * BCS layout for \"boolean\": One byte. \"0x01\" for true and \"0x00\" for false.\n   */\n  serializeBool(value: boolean) {\n    ensureBoolean(value);\n    const byteValue = value ? 1 : 0;\n    this.appendToBuffer(new Uint8Array([byteValue]));\n  }\n\n  /**\n   * Serializes a uint8 number.\n   *\n   * BCS layout for \"uint8\": One byte. Binary format in little-endian representation.\n   */\n  @checkNumberRange(0, MAX_U8_NUMBER)\n  serializeU8(value: Uint8) {\n    this.appendToBuffer(new Uint8Array([value]));\n  }\n\n  /**\n   * Serializes a uint16 number.\n   *\n   * BCS layout for \"uint16\": Two bytes. Binary format in little-endian representation.\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeU16(4660);\n   * assert(serializer.toUint8Array() === new Uint8Array([0x34, 0x12]));\n   * ```\n   */\n  @checkNumberRange(0, MAX_U16_NUMBER)\n  serializeU16(value: Uint16) {\n    this.serializeWithFunction(DataView.prototype.setUint16, 2, value);\n  }\n\n  /**\n   * Serializes a uint32 number.\n   *\n   * BCS layout for \"uint32\": Four bytes. Binary format in little-endian representation.\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeU32(305419896);\n   * assert(serializer.toUint8Array() === new Uint8Array([0x78, 0x56, 0x34, 0x12]));\n   * ```\n   */\n  @checkNumberRange(0, MAX_U32_NUMBER)\n  serializeU32(value: Uint32) {\n    this.serializeWithFunction(DataView.prototype.setUint32, 4, value);\n  }\n\n  /**\n   * Serializes a uint64 number.\n   *\n   * BCS layout for \"uint64\": Eight bytes. Binary format in little-endian representation.\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeU64(1311768467750121216);\n   * assert(serializer.toUint8Array() === new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));\n   * ```\n   */\n  @checkNumberRange(BigInt(0), MAX_U64_BIG_INT)\n  serializeU64(value: AnyNumber) {\n    const low = BigInt(value) & BigInt(MAX_U32_NUMBER);\n    const high = BigInt(value) >> BigInt(32);\n\n    // write little endian number\n    this.serializeU32(Number(low));\n    this.serializeU32(Number(high));\n  }\n\n  /**\n   * Serializes a uint128 number.\n   *\n   * BCS layout for \"uint128\": Sixteen bytes. Binary format in little-endian representation.\n   */\n  @checkNumberRange(BigInt(0), MAX_U128_BIG_INT)\n  serializeU128(value: AnyNumber) {\n    const low = BigInt(value) & MAX_U64_BIG_INT;\n    const high = BigInt(value) >> BigInt(64);\n\n    // write little endian number\n    this.serializeU64(low);\n    this.serializeU64(high);\n  }\n\n  /**\n   * Serializes a uint256 number.\n   *\n   * BCS layout for \"uint256\": Sixteen bytes. Binary format in little-endian representation.\n   */\n  @checkNumberRange(BigInt(0), MAX_U256_BIG_INT)\n  serializeU256(value: AnyNumber) {\n    const low = BigInt(value) & MAX_U128_BIG_INT;\n    const high = BigInt(value) >> BigInt(128);\n\n    // write little endian number\n    this.serializeU128(low);\n    this.serializeU128(high);\n  }\n\n  /**\n   * Serializes a uint32 number with uleb128.\n   *\n   * BCS uses uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values\n   */\n  @checkNumberRange(0, MAX_U32_NUMBER)\n  serializeU32AsUleb128(val: Uint32) {\n    let value = val;\n    const valueArray = [];\n    while (value >>> 7 !== 0) {\n      valueArray.push((value & 0x7f) | 0x80);\n      value >>>= 7;\n    }\n    valueArray.push(value);\n    this.appendToBuffer(new Uint8Array(valueArray));\n  }\n\n  /**\n   * Returns the buffered bytes\n   */\n  toUint8Array(): Uint8Array {\n    return new Uint8Array(this.buffer).slice(0, this.offset);\n  }\n\n  /**\n   * Serializes a `Serializable` value, facilitating composable serialization.\n   *\n   * @param value The Serializable value to serialize\n   *\n   * @example\n   * // Define the MoveStruct class that implements the Serializable interface\n   * class MoveStruct extends Serializable {\n   *     constructor(\n   *         public creatorAddress: AccountAddress, // where AccountAddress extends Serializable\n   *         public collectionName: string,\n   *         public tokenName: string\n   *     ) {}\n   *\n   *     serialize(serializer: Serializer): void {\n   *         serializer.serialize(this.creatorAddress);  // Composable serialization of another Serializable object\n   *         serializer.serializeStr(this.collectionName);\n   *         serializer.serializeStr(this.tokenName);\n   *     }\n   * }\n   *\n   * // Construct a MoveStruct\n   * const moveStruct = new MoveStruct(new AccountAddress(...), \"MyCollection\", \"TokenA\");\n   *\n   * // Serialize a string, a u64 number, and a MoveStruct instance.\n   * const serializer = new Serializer();\n   * serializer.serializeStr(\"ExampleString\");\n   * serializer.serializeU64(12345678);\n   * serializer.serialize(moveStruct);\n   *\n   * // Get the bytes from the Serializer instance\n   * const serializedBytes = serializer.toUint8Array();\n   *\n   * @returns the serializer instance\n   */\n  serialize<T extends Serializable>(value: T): void {\n    // NOTE: The `serialize` method called by `value` is defined in `value`'s\n    // Serializable interface, not the one defined in this class.\n    value.serialize(this);\n  }\n\n  /**\n   * Serializes an array of BCS Serializable values to a serializer instance.\n   * Note that this does not return anything. The bytes are added to the serializer instance's byte buffer.\n   *\n   * @param values The array of BCS Serializable values\n   * @example\n   * const addresses = new Array<AccountAddress>(\n   *   AccountAddress.from(\"0x1\"),\n   *   AccountAddress.from(\"0x2\"),\n   *   AccountAddress.from(\"0xa\"),\n   *   AccountAddress.from(\"0xb\"),\n   * );\n   * const serializer = new Serializer();\n   * serializer.serializeVector(addresses);\n   * const serializedBytes = serializer.toUint8Array();\n   * // serializedBytes is now the BCS-serialized bytes\n   * // The equivalent value in Move would be:\n   * // `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`;\n   */\n  serializeVector<T extends Serializable>(values: Array<T>): void {\n    this.serializeU32AsUleb128(values.length);\n    values.forEach((item) => {\n      item.serialize(this);\n    });\n  }\n\n  serializeOption<T extends Serializable>(value?: T): void {\n    if (value === undefined) {\n      this.serializeU32AsUleb128(0);\n    } else {\n      this.serializeU32AsUleb128(1);\n      value.serialize(this);\n    }\n  }\n\n  serializeOptionStr(value?: string): void {\n    if (value === undefined) {\n      this.serializeU32AsUleb128(0);\n    } else {\n      this.serializeU32AsUleb128(1);\n      this.serializeStr(value);\n    }\n  }\n}\n\nexport function ensureBoolean(value: unknown): asserts value is boolean {\n  if (typeof value !== \"boolean\") {\n    throw new Error(`${value} is not a boolean value`);\n  }\n}\n\nexport const outOfRangeErrorMessage = (value: AnyNumber, min: AnyNumber, max: AnyNumber) =>\n  `${value} is out of range: [${min}, ${max}]`;\n\nexport function validateNumberInRange<T extends AnyNumber>(value: T, minValue: T, maxValue: T) {\n  const valueBigInt = BigInt(value);\n  if (valueBigInt > BigInt(maxValue) || valueBigInt < BigInt(minValue)) {\n    throw new Error(outOfRangeErrorMessage(value, minValue, maxValue));\n  }\n}\n\n/**\n * A decorator to ensure the input argument for a function is within a range.\n * @param minValue The input argument must be >= minValue\n * @param maxValue The input argument must be <= maxValue\n */\nfunction checkNumberRange<T extends AnyNumber>(minValue: T, maxValue: T) {\n  return (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => {\n    const childFunction = descriptor.value;\n    // eslint-disable-next-line no-param-reassign\n    descriptor.value = function deco(value: AnyNumber) {\n      validateNumberInRange(value, minValue, maxValue);\n      return childFunction.apply(this, [value]);\n    };\n\n    return descriptor;\n  };\n}\n"],"mappings":"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","names":["Serializable","serializer","Serializer","bcsBytes","Hex","length","bytes","newBuffer","values","fn","bytesLength","value","dv","textEncoder","ensureBoolean","byteValue","low","MAX_U32_NUMBER","high","MAX_U64_BIG_INT","MAX_U128_BIG_INT","val","valueArray","item","__decorateClass","checkNumberRange","MAX_U8_NUMBER","MAX_U16_NUMBER","MAX_U256_BIG_INT","outOfRangeErrorMessage","min","max","validateNumberInRange","minValue","maxValue","valueBigInt","target","propertyKey","descriptor","childFunction"]}
+{"version":3,"sources":["../../src/bcs/serializer.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/* eslint-disable no-bitwise */\nimport {\n  MAX_U128_BIG_INT,\n  MAX_U16_NUMBER,\n  MAX_U32_NUMBER,\n  MAX_U64_BIG_INT,\n  MAX_U8_NUMBER,\n  MAX_U256_BIG_INT,\n} from \"./consts\";\nimport { Hex } from \"../core/hex\";\nimport { AnyNumber, Uint16, Uint32, Uint8 } from \"../types\";\n\n// This class is intended to be used as a base class for all serializable types.\n// It can be used to facilitate composable serialization of a complex type and\n// in general to serialize a type to its BCS representation.\nexport abstract class Serializable {\n  abstract serialize(serializer: Serializer): void;\n\n  /**\n   * Serializes a `Serializable` value to its BCS representation.\n   * This function is the Typescript SDK equivalent of `bcs::to_bytes` in Move.\n   * @returns the BCS representation of the Serializable instance as a byte buffer\n   */\n  bcsToBytes(): Uint8Array {\n    const serializer = new Serializer();\n    this.serialize(serializer);\n    return serializer.toUint8Array();\n  }\n\n  /**\n   * Helper function to get a value's BCS-serialized bytes as a Hex instance.\n   * @returns a Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array\n   */\n  bcsToHex(): Hex {\n    const bcsBytes = this.bcsToBytes();\n    return Hex.fromHexInput(bcsBytes);\n  }\n}\n\nexport class Serializer {\n  private buffer: ArrayBuffer;\n\n  private offset: number;\n\n  // Constructs a serializer with a buffer of size `length` bytes, 64 bytes by default.\n  // `length` must be greater than 0.\n  constructor(length: number = 64) {\n    if (length <= 0) {\n      throw new Error(\"Length needs to be greater than 0\");\n    }\n    this.buffer = new ArrayBuffer(length);\n    this.offset = 0;\n  }\n\n  private ensureBufferWillHandleSize(bytes: number) {\n    while (this.buffer.byteLength < this.offset + bytes) {\n      const newBuffer = new ArrayBuffer(this.buffer.byteLength * 2);\n      new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));\n      this.buffer = newBuffer;\n    }\n  }\n\n  protected appendToBuffer(values: Uint8Array) {\n    this.ensureBufferWillHandleSize(values.length);\n    new Uint8Array(this.buffer, this.offset).set(values);\n    this.offset += values.length;\n  }\n\n  private serializeWithFunction(\n    fn: (byteOffset: number, value: number, littleEndian?: boolean) => void,\n    bytesLength: number,\n    value: number,\n  ) {\n    this.ensureBufferWillHandleSize(bytesLength);\n    const dv = new DataView(this.buffer, this.offset);\n    fn.apply(dv, [0, value, true]);\n    this.offset += bytesLength;\n  }\n\n  /**\n   * Serializes a string. UTF8 string is supported.\n   *\n   * The number of bytes in the string content is serialized first, as a uleb128-encoded u32 integer.\n   * Then the string content is serialized as UTF8 encoded bytes.\n   *\n   * BCS layout for \"string\": string_length | string_content\n   * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.\n   *\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeStr(\"1234abcd\");\n   * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));\n   * ```\n   */\n  serializeStr(value: string) {\n    const textEncoder = new TextEncoder();\n    this.serializeBytes(textEncoder.encode(value));\n  }\n\n  /**\n   * Serializes an array of bytes.\n   *\n   * BCS layout for \"bytes\": bytes_length | bytes\n   * where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.\n   */\n  serializeBytes(value: Uint8Array) {\n    this.serializeU32AsUleb128(value.length);\n    this.appendToBuffer(value);\n  }\n\n  /**\n   * Serializes an array of bytes with known length. Therefore, length doesn't need to be\n   * serialized to help deserialization.\n   *\n   * When deserializing, the number of bytes to deserialize needs to be passed in.\n   */\n  serializeFixedBytes(value: Uint8Array) {\n    this.appendToBuffer(value);\n  }\n\n  /**\n   * Serializes a boolean value.\n   *\n   * BCS layout for \"boolean\": One byte. \"0x01\" for true and \"0x00\" for false.\n   */\n  serializeBool(value: boolean) {\n    ensureBoolean(value);\n    const byteValue = value ? 1 : 0;\n    this.appendToBuffer(new Uint8Array([byteValue]));\n  }\n\n  /**\n   * Serializes a uint8 number.\n   *\n   * BCS layout for \"uint8\": One byte. Binary format in little-endian representation.\n   */\n  @checkNumberRange(0, MAX_U8_NUMBER)\n  serializeU8(value: Uint8) {\n    this.appendToBuffer(new Uint8Array([value]));\n  }\n\n  /**\n   * Serializes a uint16 number.\n   *\n   * BCS layout for \"uint16\": Two bytes. Binary format in little-endian representation.\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeU16(4660);\n   * assert(serializer.toUint8Array() === new Uint8Array([0x34, 0x12]));\n   * ```\n   */\n  @checkNumberRange(0, MAX_U16_NUMBER)\n  serializeU16(value: Uint16) {\n    this.serializeWithFunction(DataView.prototype.setUint16, 2, value);\n  }\n\n  /**\n   * Serializes a uint32 number.\n   *\n   * BCS layout for \"uint32\": Four bytes. Binary format in little-endian representation.\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeU32(305419896);\n   * assert(serializer.toUint8Array() === new Uint8Array([0x78, 0x56, 0x34, 0x12]));\n   * ```\n   */\n  @checkNumberRange(0, MAX_U32_NUMBER)\n  serializeU32(value: Uint32) {\n    this.serializeWithFunction(DataView.prototype.setUint32, 4, value);\n  }\n\n  /**\n   * Serializes a uint64 number.\n   *\n   * BCS layout for \"uint64\": Eight bytes. Binary format in little-endian representation.\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeU64(1311768467750121216);\n   * assert(serializer.toUint8Array() === new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));\n   * ```\n   */\n  @checkNumberRange(BigInt(0), MAX_U64_BIG_INT)\n  serializeU64(value: AnyNumber) {\n    const low = BigInt(value) & BigInt(MAX_U32_NUMBER);\n    const high = BigInt(value) >> BigInt(32);\n\n    // write little endian number\n    this.serializeU32(Number(low));\n    this.serializeU32(Number(high));\n  }\n\n  /**\n   * Serializes a uint128 number.\n   *\n   * BCS layout for \"uint128\": Sixteen bytes. Binary format in little-endian representation.\n   */\n  @checkNumberRange(BigInt(0), MAX_U128_BIG_INT)\n  serializeU128(value: AnyNumber) {\n    const low = BigInt(value) & MAX_U64_BIG_INT;\n    const high = BigInt(value) >> BigInt(64);\n\n    // write little endian number\n    this.serializeU64(low);\n    this.serializeU64(high);\n  }\n\n  /**\n   * Serializes a uint256 number.\n   *\n   * BCS layout for \"uint256\": Sixteen bytes. Binary format in little-endian representation.\n   */\n  @checkNumberRange(BigInt(0), MAX_U256_BIG_INT)\n  serializeU256(value: AnyNumber) {\n    const low = BigInt(value) & MAX_U128_BIG_INT;\n    const high = BigInt(value) >> BigInt(128);\n\n    // write little endian number\n    this.serializeU128(low);\n    this.serializeU128(high);\n  }\n\n  /**\n   * Serializes a uint32 number with uleb128.\n   *\n   * BCS uses uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values\n   */\n  @checkNumberRange(0, MAX_U32_NUMBER)\n  serializeU32AsUleb128(val: Uint32) {\n    let value = val;\n    const valueArray = [];\n    while (value >>> 7 !== 0) {\n      valueArray.push((value & 0x7f) | 0x80);\n      value >>>= 7;\n    }\n    valueArray.push(value);\n    this.appendToBuffer(new Uint8Array(valueArray));\n  }\n\n  /**\n   * Returns the buffered bytes\n   */\n  toUint8Array(): Uint8Array {\n    return new Uint8Array(this.buffer).slice(0, this.offset);\n  }\n\n  /**\n   * Serializes a `Serializable` value, facilitating composable serialization.\n   *\n   * @param value The Serializable value to serialize\n   *\n   * @example\n   * // Define the MoveStruct class that implements the Serializable interface\n   * class MoveStruct extends Serializable {\n   *     constructor(\n   *         public creatorAddress: AccountAddress, // where AccountAddress extends Serializable\n   *         public collectionName: string,\n   *         public tokenName: string\n   *     ) {}\n   *\n   *     serialize(serializer: Serializer): void {\n   *         serializer.serialize(this.creatorAddress);  // Composable serialization of another Serializable object\n   *         serializer.serializeStr(this.collectionName);\n   *         serializer.serializeStr(this.tokenName);\n   *     }\n   * }\n   *\n   * // Construct a MoveStruct\n   * const moveStruct = new MoveStruct(new AccountAddress(...), \"MyCollection\", \"TokenA\");\n   *\n   * // Serialize a string, a u64 number, and a MoveStruct instance.\n   * const serializer = new Serializer();\n   * serializer.serializeStr(\"ExampleString\");\n   * serializer.serializeU64(12345678);\n   * serializer.serialize(moveStruct);\n   *\n   * // Get the bytes from the Serializer instance\n   * const serializedBytes = serializer.toUint8Array();\n   *\n   * @returns the serializer instance\n   */\n  serialize<T extends Serializable>(value: T): void {\n    // NOTE: The `serialize` method called by `value` is defined in `value`'s\n    // Serializable interface, not the one defined in this class.\n    value.serialize(this);\n  }\n\n  /**\n   * Serializes an array of BCS Serializable values to a serializer instance.\n   * Note that this does not return anything. The bytes are added to the serializer instance's byte buffer.\n   *\n   * @param values The array of BCS Serializable values\n   * @example\n   * const addresses = new Array<AccountAddress>(\n   *   AccountAddress.from(\"0x1\"),\n   *   AccountAddress.from(\"0x2\"),\n   *   AccountAddress.from(\"0xa\"),\n   *   AccountAddress.from(\"0xb\"),\n   * );\n   * const serializer = new Serializer();\n   * serializer.serializeVector(addresses);\n   * const serializedBytes = serializer.toUint8Array();\n   * // serializedBytes is now the BCS-serialized bytes\n   * // The equivalent value in Move would be:\n   * // `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`;\n   */\n  serializeVector<T extends Serializable>(values: Array<T>): void {\n    this.serializeU32AsUleb128(values.length);\n    values.forEach((item) => {\n      item.serialize(this);\n    });\n  }\n\n  serializeOption<T extends Serializable>(value?: T): void {\n    if (value === undefined) {\n      this.serializeU32AsUleb128(0);\n    } else {\n      this.serializeU32AsUleb128(1);\n      value.serialize(this);\n    }\n  }\n\n  serializeOptionStr(value?: string): void {\n    if (value === undefined) {\n      this.serializeU32AsUleb128(0);\n    } else {\n      this.serializeU32AsUleb128(1);\n      this.serializeStr(value);\n    }\n  }\n}\n\nexport function ensureBoolean(value: unknown): asserts value is boolean {\n  if (typeof value !== \"boolean\") {\n    throw new Error(`${value} is not a boolean value`);\n  }\n}\n\nexport const outOfRangeErrorMessage = (value: AnyNumber, min: AnyNumber, max: AnyNumber) =>\n  `${value} is out of range: [${min}, ${max}]`;\n\nexport function validateNumberInRange<T extends AnyNumber>(value: T, minValue: T, maxValue: T) {\n  const valueBigInt = BigInt(value);\n  if (valueBigInt > BigInt(maxValue) || valueBigInt < BigInt(minValue)) {\n    throw new Error(outOfRangeErrorMessage(value, minValue, maxValue));\n  }\n}\n\n/**\n * A decorator to ensure the input argument for a function is within a range.\n * @param minValue The input argument must be >= minValue\n * @param maxValue The input argument must be <= maxValue\n */\nfunction checkNumberRange<T extends AnyNumber>(minValue: T, maxValue: T) {\n  return (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => {\n    const childFunction = descriptor.value;\n    // eslint-disable-next-line no-param-reassign\n    descriptor.value = function deco(value: AnyNumber) {\n      validateNumberInRange(value, minValue, maxValue);\n      return childFunction.apply(this, [value]);\n    };\n\n    return descriptor;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBO,IAAe,eAAf,MAA4B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQjC,aAAyB;AACvB,UAAM,aAAa,IAAI,WAAW;AAClC,SAAK,UAAU,UAAU;AACzB,WAAO,WAAW,aAAa;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,WAAgB;AACd,UAAM,WAAW,KAAK,WAAW;AACjC,WAAO,IAAI,aAAa,QAAQ;AAAA,EAClC;AACF;AAEO,IAAM,aAAN,MAAiB;AAAA;AAAA;AAAA,EAOtB,YAAY,SAAiB,IAAI;AAC/B,QAAI,UAAU,GAAG;AACf,YAAM,IAAI,MAAM,mCAAmC;AAAA,IACrD;AACA,SAAK,SAAS,IAAI,YAAY,MAAM;AACpC,SAAK,SAAS;AAAA,EAChB;AAAA,EAEQ,2BAA2B,OAAe;AAChD,WAAO,KAAK,OAAO,aAAa,KAAK,SAAS,OAAO;AACnD,YAAM,YAAY,IAAI,YAAY,KAAK,OAAO,aAAa,CAAC;AAC5D,UAAI,WAAW,SAAS,EAAE,IAAI,IAAI,WAAW,KAAK,MAAM,CAAC;AACzD,WAAK,SAAS;AAAA,IAChB;AAAA,EACF;AAAA,EAEU,eAAe,QAAoB;AAC3C,SAAK,2BAA2B,OAAO,MAAM;AAC7C,QAAI,WAAW,KAAK,QAAQ,KAAK,MAAM,EAAE,IAAI,MAAM;AACnD,SAAK,UAAU,OAAO;AAAA,EACxB;AAAA,EAEQ,sBACN,IACA,aACA,OACA;AACA,SAAK,2BAA2B,WAAW;AAC3C,UAAM,KAAK,IAAI,SAAS,KAAK,QAAQ,KAAK,MAAM;AAChD,OAAG,MAAM,IAAI,CAAC,GAAG,OAAO,IAAI,CAAC;AAC7B,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,aAAa,OAAe;AAC1B,UAAM,cAAc,IAAI,YAAY;AACpC,SAAK,eAAe,YAAY,OAAO,KAAK,CAAC;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,eAAe,OAAmB;AAChC,SAAK,sBAAsB,MAAM,MAAM;AACvC,SAAK,eAAe,KAAK;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,oBAAoB,OAAmB;AACrC,SAAK,eAAe,KAAK;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,cAAc,OAAgB;AAC5B,kBAAc,KAAK;AACnB,UAAM,YAAY,QAAQ,IAAI;AAC9B,SAAK,eAAe,IAAI,WAAW,CAAC,SAAS,CAAC,CAAC;AAAA,EACjD;AAAA,EAQA,YAAY,OAAc;AACxB,SAAK,eAAe,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC;AAAA,EAC7C;AAAA,EAcA,aAAa,OAAe;AAC1B,SAAK,sBAAsB,SAAS,UAAU,WAAW,GAAG,KAAK;AAAA,EACnE;AAAA,EAcA,aAAa,OAAe;AAC1B,SAAK,sBAAsB,SAAS,UAAU,WAAW,GAAG,KAAK;AAAA,EACnE;AAAA,EAcA,aAAa,OAAkB;AAC7B,UAAM,MAAM,OAAO,KAAK,IAAI,OAAO,cAAc;AACjD,UAAM,OAAO,OAAO,KAAK,KAAK,OAAO,EAAE;AAGvC,SAAK,aAAa,OAAO,GAAG,CAAC;AAC7B,SAAK,aAAa,OAAO,IAAI,CAAC;AAAA,EAChC;AAAA,EAQA,cAAc,OAAkB;AAC9B,UAAM,MAAM,OAAO,KAAK,IAAI;AAC5B,UAAM,OAAO,OAAO,KAAK,KAAK,OAAO,EAAE;AAGvC,SAAK,aAAa,GAAG;AACrB,SAAK,aAAa,IAAI;AAAA,EACxB;AAAA,EAQA,cAAc,OAAkB;AAC9B,UAAM,MAAM,OAAO,KAAK,IAAI;AAC5B,UAAM,OAAO,OAAO,KAAK,KAAK,OAAO,GAAG;AAGxC,SAAK,cAAc,GAAG;AACtB,SAAK,cAAc,IAAI;AAAA,EACzB;AAAA,EAQA,sBAAsB,KAAa;AACjC,QAAI,QAAQ;AACZ,UAAM,aAAa,CAAC;AACpB,WAAO,UAAU,MAAM,GAAG;AACxB,iBAAW,KAAM,QAAQ,MAAQ,GAAI;AACrC,iBAAW;AAAA,IACb;AACA,eAAW,KAAK,KAAK;AACrB,SAAK,eAAe,IAAI,WAAW,UAAU,CAAC;AAAA,EAChD;AAAA;AAAA;AAAA;AAAA,EAKA,eAA2B;AACzB,WAAO,IAAI,WAAW,KAAK,MAAM,EAAE,MAAM,GAAG,KAAK,MAAM;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAqCA,UAAkC,OAAgB;AAGhD,UAAM,UAAU,IAAI;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAqBA,gBAAwC,QAAwB;AAC9D,SAAK,sBAAsB,OAAO,MAAM;AACxC,WAAO,QAAQ,CAAC,SAAS;AACvB,WAAK,UAAU,IAAI;AAAA,IACrB,CAAC;AAAA,EACH;AAAA,EAEA,gBAAwC,OAAiB;AACvD,QAAI,UAAU,QAAW;AACvB,WAAK,sBAAsB,CAAC;AAAA,IAC9B,OAAO;AACL,WAAK,sBAAsB,CAAC;AAC5B,YAAM,UAAU,IAAI;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,mBAAmB,OAAsB;AACvC,QAAI,UAAU,QAAW;AACvB,WAAK,sBAAsB,CAAC;AAAA,IAC9B,OAAO;AACL,WAAK,sBAAsB,CAAC;AAC5B,WAAK,aAAa,KAAK;AAAA,IACzB;AAAA,EACF;AACF;AAnME;AAAA,EADC,iBAAiB,GAAG,aAAa;AAAA,GAlGvB,WAmGX;AAgBA;AAAA,EADC,iBAAiB,GAAG,cAAc;AAAA,GAlHxB,WAmHX;AAgBA;AAAA,EADC,iBAAiB,GAAG,cAAc;AAAA,GAlIxB,WAmIX;AAgBA;AAAA,EADC,iBAAiB,OAAO,CAAC,GAAG,eAAe;AAAA,GAlJjC,WAmJX;AAeA;AAAA,EADC,iBAAiB,OAAO,CAAC,GAAG,gBAAgB;AAAA,GAjKlC,WAkKX;AAeA;AAAA,EADC,iBAAiB,OAAO,CAAC,GAAG,gBAAgB;AAAA,GAhLlC,WAiLX;AAeA;AAAA,EADC,iBAAiB,GAAG,cAAc;AAAA,GA/LxB,WAgMX;AAwGK,SAAS,cAAc,OAA0C;AACtE,MAAI,OAAO,UAAU,WAAW;AAC9B,UAAM,IAAI,MAAM,GAAG,KAAK,yBAAyB;AAAA,EACnD;AACF;AAEO,IAAM,yBAAyB,CAAC,OAAkB,KAAgB,QACvE,GAAG,KAAK,sBAAsB,GAAG,KAAK,GAAG;AAEpC,SAAS,sBAA2C,OAAU,UAAa,UAAa;AAC7F,QAAM,cAAc,OAAO,KAAK;AAChC,MAAI,cAAc,OAAO,QAAQ,KAAK,cAAc,OAAO,QAAQ,GAAG;AACpE,UAAM,IAAI,MAAM,uBAAuB,OAAO,UAAU,QAAQ,CAAC;AAAA,EACnE;AACF;AAOA,SAAS,iBAAsC,UAAa,UAAa;AACvE,SAAO,CAAC,QAAiB,aAAqB,eAAmC;AAC/E,UAAM,gBAAgB,WAAW;AAEjC,eAAW,QAAQ,SAAS,KAAK,OAAkB;AACjD,4BAAsB,OAAO,UAAU,QAAQ;AAC/C,aAAO,cAAc,MAAM,MAAM,CAAC,KAAK,CAAC;AAAA,IAC1C;AAEA,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/esm/chunk-FXKSE3ZP.mjs

@@ -0,0 +1,25 @@
+import {
+  Serializable
+} from "./chunk-FQQW55X7.mjs";
+import {
+  Hex
+} from "./chunk-YV7M4CFP.mjs";
+
+// src/core/crypto/publicKey.ts
+var PublicKey = class extends Serializable {
+  /**
+   * Get the public key as a hex string with a 0x prefix e.g. 0x123456...
+   */
+  toString() {
+    const bytes = this.toUint8Array();
+    return Hex.fromHexInput(bytes).toString();
+  }
+};
+var AccountPublicKey = class extends PublicKey {
+};
+
+export {
+  PublicKey,
+  AccountPublicKey
+};
+//# sourceMappingURL=chunk-FXKSE3ZP.mjs.map

package/dist/esm/{chunk-COW5IGYC.mjs.map → chunk-FXKSE3ZP.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/crypto/publicKey.ts"],"sourcesContent":["import { Serializable } from \"../../bcs\";\nimport { HexInput } from \"../../types\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { Hex } from \"../hex\";\nimport { Signature } from \"./signature\";\n\n/**\n * Arguments for verifying a signature\n */\nexport interface VerifySignatureArgs {\n  message: HexInput;\n  signature: Signature;\n}\n\n/**\n * An abstract representation of a public key.\n *\n * Provides a common interface for verifying any signature.\n */\nexport abstract class PublicKey extends Serializable {\n  /**\n   * Verifies that the private key associated with this public key signed the message with the given signature.\n   * @param args.message The message that was signed\n   * @param args.signature The signature to verify\n   */\n  abstract verifySignature(args: VerifySignatureArgs): boolean;\n\n  /**\n   * Get the raw public key bytes\n   */\n  abstract toUint8Array(): Uint8Array;\n\n  /**\n   * Get the public key as a hex string with a 0x prefix e.g. 0x123456...\n   */\n  toString(): string {\n    const bytes = this.toUint8Array();\n    return Hex.fromHexInput(bytes).toString();\n  }\n}\n\n/**\n * An abstract representation of an account public key.\n *\n * Provides a common interface for deriving an authentication key.\n */\nexport abstract class AccountPublicKey extends PublicKey {\n  /**\n   * Get the authentication key associated with this public key\n   */\n  abstract authKey(): AuthenticationKey;\n}\n"],"mappings":"kFAmBO,IAAeA,EAAf,cAAiCC,CAAa,CAgBnD,UAAmB,CACjB,IAAMC,EAAQ,KAAK,aAAa,EAChC,OAAOC,EAAI,aAAaD,CAAK,EAAE,SAAS,CAC1C,CACF,EAOsBE,EAAf,cAAwCJ,CAAU,CAKzD","names":["PublicKey","Serializable","bytes","Hex","AccountPublicKey"]}
+{"version":3,"sources":["../../src/core/crypto/publicKey.ts"],"sourcesContent":["import { Serializable } from \"../../bcs\";\nimport { HexInput } from \"../../types\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { Hex } from \"../hex\";\nimport { Signature } from \"./signature\";\n\n/**\n * Arguments for verifying a signature\n */\nexport interface VerifySignatureArgs {\n  message: HexInput;\n  signature: Signature;\n}\n\n/**\n * An abstract representation of a public key.\n *\n * Provides a common interface for verifying any signature.\n */\nexport abstract class PublicKey extends Serializable {\n  /**\n   * Verifies that the private key associated with this public key signed the message with the given signature.\n   * @param args.message The message that was signed\n   * @param args.signature The signature to verify\n   */\n  abstract verifySignature(args: VerifySignatureArgs): boolean;\n\n  /**\n   * Get the raw public key bytes\n   */\n  abstract toUint8Array(): Uint8Array;\n\n  /**\n   * Get the public key as a hex string with a 0x prefix e.g. 0x123456...\n   */\n  toString(): string {\n    const bytes = this.toUint8Array();\n    return Hex.fromHexInput(bytes).toString();\n  }\n}\n\n/**\n * An abstract representation of an account public key.\n *\n * Provides a common interface for deriving an authentication key.\n */\nexport abstract class AccountPublicKey extends PublicKey {\n  /**\n   * Get the authentication key associated with this public key\n   */\n  abstract authKey(): AuthenticationKey;\n}\n"],"mappings":";;;;;;;;AAmBO,IAAe,YAAf,cAAiC,aAAa;AAAA;AAAA;AAAA;AAAA,EAgBnD,WAAmB;AACjB,UAAM,QAAQ,KAAK,aAAa;AAChC,WAAO,IAAI,aAAa,KAAK,EAAE,SAAS;AAAA,EAC1C;AACF;AAOO,IAAe,mBAAf,cAAwC,UAAU;AAKzD;","names":[]}

package/dist/esm/chunk-GBEVD2VM.mjs

@@ -0,0 +1,99 @@
+import {
+  postAptosPepperService,
+  postAptosProvingService
+} from "./chunk-NXFO2W4G.mjs";
+import {
+  KeylessAccount
+} from "./chunk-JV3GSIJW.mjs";
+import {
+  EPK_HORIZON_SECS,
+  Groth16Zkp,
+  ZeroKnowledgeSig,
+  ZkProof
+} from "./chunk-4OYYOYSO.mjs";
+import {
+  EphemeralSignature
+} from "./chunk-B5S6DDUD.mjs";
+import {
+  Hex
+} from "./chunk-YV7M4CFP.mjs";
+
+// src/internal/keyless.ts
+import { jwtDecode } from "jwt-decode";
+async function getPepper(args) {
+  const { aptosConfig, jwt, ephemeralKeyPair, uidKey, derivationPath } = args;
+  const body = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    uid_key: uidKey,
+    derivation_path: derivationPath
+  };
+  const { data } = await postAptosPepperService({
+    aptosConfig,
+    path: "fetch",
+    body,
+    originMethod: "getPepper",
+    overrides: { WITH_CREDENTIALS: false }
+  });
+  return Hex.fromHexInput(data.pepper).toUint8Array();
+}
+async function getProof(args) {
+  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey, extraFieldKey } = args;
+  const json = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),
+    exp_horizon_secs: EPK_HORIZON_SECS,
+    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),
+    extra_field: extraFieldKey,
+    uid_key: uidKey || "sub"
+  };
+  const { data } = await postAptosProvingService({
+    aptosConfig,
+    path: "prove",
+    body: json,
+    originMethod: "getProof",
+    overrides: { WITH_CREDENTIALS: false }
+  });
+  const proofPoints = data.proof;
+  const groth16Zkp = new Groth16Zkp({
+    a: proofPoints.a,
+    b: proofPoints.b,
+    c: proofPoints.c
+  });
+  let extraField;
+  if (extraFieldKey) {
+    const jwtPayload = jwtDecode(jwt);
+    const extraFieldVal = jwtPayload[extraFieldKey];
+    extraField = `"${extraFieldKey}":"${extraFieldVal}",`;
+  }
+  const signedProof = new ZeroKnowledgeSig({
+    proof: new ZkProof(groth16Zkp, 0 /* Groth16 */),
+    extraField,
+    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature)
+  });
+  return signedProof;
+}
+async function deriveKeylessAccount(args) {
+  const { proofFetchCallback } = args;
+  let { pepper } = args;
+  if (pepper === void 0) {
+    pepper = await getPepper(args);
+  } else if (Hex.fromHexInput(pepper).toUint8Array().length !== KeylessAccount.PEPPER_LENGTH) {
+    throw new Error(`Pepper needs to be ${KeylessAccount.PEPPER_LENGTH} bytes`);
+  }
+  const proofPromise = getProof({ ...args, pepper });
+  const proof = proofFetchCallback ? proofPromise : await proofPromise;
+  const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proof, pepper, proofFetchCallback });
+  return keylessAccount;
+}
+
+export {
+  getPepper,
+  getProof,
+  deriveKeylessAccount
+};
+//# sourceMappingURL=chunk-GBEVD2VM.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internal/keyless.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file contains the underlying implementations for exposed API surface in\n * the {@link api/keyless}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * faucet namespace and without having a dependency cycle error.\n */\nimport { jwtDecode } from \"jwt-decode\";\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { postAptosPepperService, postAptosProvingService } from \"../client\";\nimport { EPK_HORIZON_SECS, EphemeralSignature, Groth16Zkp, Hex, ZeroKnowledgeSig, ZkProof } from \"../core\";\nimport { HexInput, ZkpVariant } from \"../types\";\nimport { EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from \"../account\";\nimport { PepperFetchResponse, ProverResponse } from \"../types/keyless\";\n\nexport async function getPepper(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  uidKey?: string;\n  derivationPath?: string;\n  verify?: boolean;\n}): Promise<Uint8Array> {\n  const { aptosConfig, jwt, ephemeralKeyPair, uidKey, derivationPath } = args;\n\n  const body = {\n    jwt_b64: jwt,\n    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),\n    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),\n    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),\n    uid_key: uidKey,\n    derivation_path: derivationPath,\n  };\n  const { data } = await postAptosPepperService<any, PepperFetchResponse>({\n    aptosConfig,\n    path: \"fetch\",\n    body,\n    originMethod: \"getPepper\",\n    overrides: { WITH_CREDENTIALS: false },\n  });\n  return Hex.fromHexInput(data.pepper).toUint8Array();\n}\n\nexport async function getProof(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  pepper: HexInput;\n  uidKey?: string;\n  extraFieldKey?: string;\n}): Promise<ZeroKnowledgeSig> {\n  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey, extraFieldKey } = args;\n  const json = {\n    jwt_b64: jwt,\n    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),\n    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),\n    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),\n    exp_horizon_secs: EPK_HORIZON_SECS,\n    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),\n    extra_field: extraFieldKey,\n    uid_key: uidKey || \"sub\",\n  };\n\n  const { data } = await postAptosProvingService<any, ProverResponse>({\n    aptosConfig,\n    path: \"prove\",\n    body: json,\n    originMethod: \"getProof\",\n    overrides: { WITH_CREDENTIALS: false },\n  });\n\n  const proofPoints = data.proof;\n  const groth16Zkp = new Groth16Zkp({\n    a: proofPoints.a,\n    b: proofPoints.b,\n    c: proofPoints.c,\n  });\n\n  let extraField;\n  if (extraFieldKey) {\n    const jwtPayload = jwtDecode<{ [key: string]: string }>(jwt);\n    const extraFieldVal = jwtPayload[extraFieldKey];\n    extraField = `\"${extraFieldKey}\":\"${extraFieldVal}\",`;\n  }\n\n  const signedProof = new ZeroKnowledgeSig({\n    proof: new ZkProof(groth16Zkp, ZkpVariant.Groth16),\n    extraField,\n    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),\n  });\n  return signedProof;\n}\n\nexport async function deriveKeylessAccount(args: {\n  aptosConfig: AptosConfig;\n  jwt: string;\n  ephemeralKeyPair: EphemeralKeyPair;\n  uidKey?: string;\n  pepper?: HexInput;\n  extraFieldKey?: string;\n  proofFetchCallback?: ProofFetchCallback;\n}): Promise<KeylessAccount> {\n  const { proofFetchCallback } = args;\n  let { pepper } = args;\n  if (pepper === undefined) {\n    pepper = await getPepper(args);\n  } else if (Hex.fromHexInput(pepper).toUint8Array().length !== KeylessAccount.PEPPER_LENGTH) {\n    throw new Error(`Pepper needs to be ${KeylessAccount.PEPPER_LENGTH} bytes`);\n  }\n\n  const proofPromise = getProof({ ...args, pepper });\n  const proof = proofFetchCallback ? proofPromise : await proofPromise;\n\n  const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proof, pepper, proofFetchCallback });\n\n  return keylessAccount;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AASA,SAAS,iBAAiB;AAQ1B,eAAsB,UAAU,MAOR;AACtB,QAAM,EAAE,aAAa,KAAK,kBAAkB,QAAQ,eAAe,IAAI;AAEvE,QAAM,OAAO;AAAA,IACX,SAAS;AAAA,IACT,KAAK,iBAAiB,aAAa,EAAE,SAAS,EAAE,sBAAsB;AAAA,IACtE,eAAe,OAAO,iBAAiB,cAAc;AAAA,IACrD,aAAa,IAAI,aAAa,iBAAiB,OAAO,EAAE,sBAAsB;AAAA,IAC9E,SAAS;AAAA,IACT,iBAAiB;AAAA,EACnB;AACA,QAAM,EAAE,KAAK,IAAI,MAAM,uBAAiD;AAAA,IACtE;AAAA,IACA,MAAM;AAAA,IACN;AAAA,IACA,cAAc;AAAA,IACd,WAAW,EAAE,kBAAkB,MAAM;AAAA,EACvC,CAAC;AACD,SAAO,IAAI,aAAa,KAAK,MAAM,EAAE,aAAa;AACpD;AAEA,eAAsB,SAAS,MAOD;AAC5B,QAAM,EAAE,aAAa,KAAK,kBAAkB,QAAQ,QAAQ,cAAc,IAAI;AAC9E,QAAM,OAAO;AAAA,IACX,SAAS;AAAA,IACT,KAAK,iBAAiB,aAAa,EAAE,SAAS,EAAE,sBAAsB;AAAA,IACtE,aAAa,IAAI,aAAa,iBAAiB,OAAO,EAAE,sBAAsB;AAAA,IAC9E,eAAe,OAAO,iBAAiB,cAAc;AAAA,IACrD,kBAAkB;AAAA,IAClB,QAAQ,IAAI,aAAa,MAAM,EAAE,sBAAsB;AAAA,IACvD,aAAa;AAAA,IACb,SAAS,UAAU;AAAA,EACrB;AAEA,QAAM,EAAE,KAAK,IAAI,MAAM,wBAA6C;AAAA,IAClE;AAAA,IACA,MAAM;AAAA,IACN,MAAM;AAAA,IACN,cAAc;AAAA,IACd,WAAW,EAAE,kBAAkB,MAAM;AAAA,EACvC,CAAC;AAED,QAAM,cAAc,KAAK;AACzB,QAAM,aAAa,IAAI,WAAW;AAAA,IAChC,GAAG,YAAY;AAAA,IACf,GAAG,YAAY;AAAA,IACf,GAAG,YAAY;AAAA,EACjB,CAAC;AAED,MAAI;AACJ,MAAI,eAAe;AACjB,UAAM,aAAa,UAAqC,GAAG;AAC3D,UAAM,gBAAgB,WAAW,aAAa;AAC9C,iBAAa,IAAI,aAAa,MAAM,aAAa;AAAA,EACnD;AAEA,QAAM,cAAc,IAAI,iBAAiB;AAAA,IACvC,OAAO,IAAI,QAAQ,2BAA8B;AAAA,IACjD;AAAA,IACA,yBAAyB,mBAAmB,QAAQ,KAAK,yBAAyB;AAAA,EACpF,CAAC;AACD,SAAO;AACT;AAEA,eAAsB,qBAAqB,MAQf;AAC1B,QAAM,EAAE,mBAAmB,IAAI;AAC/B,MAAI,EAAE,OAAO,IAAI;AACjB,MAAI,WAAW,QAAW;AACxB,aAAS,MAAM,UAAU,IAAI;AAAA,EAC/B,WAAW,IAAI,aAAa,MAAM,EAAE,aAAa,EAAE,WAAW,eAAe,eAAe;AAC1F,UAAM,IAAI,MAAM,sBAAsB,eAAe,aAAa,QAAQ;AAAA,EAC5E;AAEA,QAAM,eAAe,SAAS,EAAE,GAAG,MAAM,OAAO,CAAC;AACjD,QAAM,QAAQ,qBAAqB,eAAe,MAAM;AAExD,QAAM,iBAAiB,eAAe,gBAAgB,EAAE,GAAG,MAAM,OAAO,QAAQ,mBAAmB,CAAC;AAEpG,SAAO;AACT;","names":[]}

package/dist/esm/chunk-GGMTQAQP.mjs

@@ -0,0 +1,11 @@
+// src/utils/helpers.ts
+async function sleep(timeMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeMs);
+  });
+}
+
+export {
+  sleep
+};
+//# sourceMappingURL=chunk-GGMTQAQP.mjs.map

package/dist/esm/{chunk-3JPVQHOR.mjs.map → chunk-GGMTQAQP.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/helpers.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Sleep the current thread for the given amount of time\n * @param timeMs time in milliseconds to sleep\n */\nexport async function sleep(timeMs: number): Promise<null> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, timeMs);\n  });\n}\n"],"mappings":"AAOA,eAAsBA,EAAMC,EAA+B,CACzD,OAAO,IAAI,QAASC,GAAY,CAC9B,WAAWA,EAASD,CAAM,CAC5B,CAAC,CACH","names":["sleep","timeMs","resolve"]}
+{"version":3,"sources":["../../src/utils/helpers.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Sleep the current thread for the given amount of time\n * @param timeMs time in milliseconds to sleep\n */\nexport async function sleep(timeMs: number): Promise<null> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, timeMs);\n  });\n}\n"],"mappings":";AAOA,eAAsB,MAAM,QAA+B;AACzD,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,eAAW,SAAS,MAAM;AAAA,EAC5B,CAAC;AACH;","names":[]}