@aptos-labs/ts-sdk 1.26.0 → 1.27.1-zeta.0

package/dist/esm/{chunk-A63SMUOU.mjs.map → chunk-UZXDD3QH.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  /**\n   * Serializes a BCS Serializable values into a serializer instance or undefined.\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   *\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeOption(new AccountAddress(...));\n   * const serializedBytes = serializer.toUint8Array();\n   * // serializedBytes is now the BCS-serialized byte representation of AccountAddress\n   *\n   * const serializer = new Serializer();\n   * serializer.serializeOption(undefined);\n   * assert(serializer.toUint8Array() === new Uint8Array([0x00]));\n   * ```\n   */\n  serializeOption<T extends Serializable>(value?: T): void {\n    const hasValue = value !== undefined;\n    this.serializeBool(hasValue);\n    if (hasValue) {\n      value.serialize(this);\n    }\n  }\n\n  /**\n   * Serializes an optional string. UTF8 string is supported.\n   *\n   * The existence of the string is encoded first, 0 if undefined and 1 if it exists.\n   * Them the number of bytes in the string content is serialized, as a uleb128-encoded u32 integer.\n   * Then the string content is serialized as UTF8 encoded bytes.\n   *\n   * BCS layout for optional \"string\": 1 | 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   * BCS layout for undefined: 0\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeOptionStr(\"1234abcd\");\n   * assert(serializer.toUint8Array() === new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));\n   *\n   * const serializer = new Serializer();\n   * serializer.serializeOptionStr(undefined);\n   * assert(serializer.toUint8Array() === new Uint8Array([0]));\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":"yJAkBO,IAAeA,EAAf,KAA4B,CAQjC,YAAyB,CACvB,IAAMC,EAAa,IAAIC,EACvB,YAAK,UAAUD,CAAU,EAClBA,EAAW,aAAa,CACjC,CAMA,UAAgB,CACd,IAAME,EAAW,KAAK,WAAW,EACjC,OAAOC,EAAI,aAAaD,CAAQ,CAClC,CACF,EAEaD,EAAN,KAAiB,CAOtB,YAAYG,EAAiB,GAAI,CAC/B,GAAIA,GAAU,EACZ,MAAM,IAAI,MAAM,mCAAmC,EAErD,KAAK,OAAS,IAAI,YAAYA,CAAM,EACpC,KAAK,OAAS,CAChB,CAEQ,2BAA2BC,EAAe,CAChD,KAAO,KAAK,OAAO,WAAa,KAAK,OAASA,GAAO,CACnD,IAAMC,EAAY,IAAI,YAAY,KAAK,OAAO,WAAa,CAAC,EAC5D,IAAI,WAAWA,CAAS,EAAE,IAAI,IAAI,WAAW,KAAK,MAAM,CAAC,EACzD,KAAK,OAASA,CAChB,CACF,CAEU,eAAeC,EAAoB,CAC3C,KAAK,2BAA2BA,EAAO,MAAM,EAC7C,IAAI,WAAW,KAAK,OAAQ,KAAK,MAAM,EAAE,IAAIA,CAAM,EACnD,KAAK,QAAUA,EAAO,MACxB,CAEQ,sBACNC,EACAC,EACAC,EACA,CACA,KAAK,2BAA2BD,CAAW,EAC3C,IAAME,EAAK,IAAI,SAAS,KAAK,OAAQ,KAAK,MAAM,EAChDH,EAAG,MAAMG,EAAI,CAAC,EAAGD,EAAO,EAAI,CAAC,EAC7B,KAAK,QAAUD,CACjB,CAkBA,aAAaC,EAAe,CAC1B,IAAME,EAAc,IAAI,YACxB,KAAK,eAAeA,EAAY,OAAOF,CAAK,CAAC,CAC/C,CAQA,eAAeA,EAAmB,CAChC,KAAK,sBAAsBA,EAAM,MAAM,EACvC,KAAK,eAAeA,CAAK,CAC3B,CAQA,oBAAoBA,EAAmB,CACrC,KAAK,eAAeA,CAAK,CAC3B,CAOA,cAAcA,EAAgB,CAC5BG,EAAcH,CAAK,EACnB,IAAMI,EAAYJ,EAAQ,EAAI,EAC9B,KAAK,eAAe,IAAI,WAAW,CAACI,CAAS,CAAC,CAAC,CACjD,CAQA,YAAYJ,EAAc,CACxB,KAAK,eAAe,IAAI,WAAW,CAACA,CAAK,CAAC,CAAC,CAC7C,CAcA,aAAaA,EAAe,CAC1B,KAAK,sBAAsB,SAAS,UAAU,UAAW,EAAGA,CAAK,CACnE,CAcA,aAAaA,EAAe,CAC1B,KAAK,sBAAsB,SAAS,UAAU,UAAW,EAAGA,CAAK,CACnE,CAcA,aAAaA,EAAkB,CAC7B,IAAMK,EAAM,OAAOL,CAAK,EAAI,OAAOM,CAAc,EAC3CC,EAAO,OAAOP,CAAK,GAAK,OAAO,EAAE,EAGvC,KAAK,aAAa,OAAOK,CAAG,CAAC,EAC7B,KAAK,aAAa,OAAOE,CAAI,CAAC,CAChC,CAQA,cAAcP,EAAkB,CAC9B,IAAMK,EAAM,OAAOL,CAAK,EAAIQ,EACtBD,EAAO,OAAOP,CAAK,GAAK,OAAO,EAAE,EAGvC,KAAK,aAAaK,CAAG,EACrB,KAAK,aAAaE,CAAI,CACxB,CAQA,cAAcP,EAAkB,CAC9B,IAAMK,EAAM,OAAOL,CAAK,EAAIS,EACtBF,EAAO,OAAOP,CAAK,GAAK,OAAO,GAAG,EAGxC,KAAK,cAAcK,CAAG,EACtB,KAAK,cAAcE,CAAI,CACzB,CAQA,sBAAsBG,EAAa,CACjC,IAAIV,EAAQU,EACNC,EAAa,CAAC,EACpB,KAAOX,IAAU,GACfW,EAAW,KAAMX,EAAQ,IAAQ,GAAI,EACrCA,KAAW,EAEbW,EAAW,KAAKX,CAAK,EACrB,KAAK,eAAe,IAAI,WAAWW,CAAU,CAAC,CAChD,CAKA,cAA2B,CACzB,OAAO,IAAI,WAAW,KAAK,MAAM,EAAE,MAAM,EAAG,KAAK,MAAM,CACzD,CAqCA,UAAkCX,EAAgB,CAGhDA,EAAM,UAAU,IAAI,CACtB,CAqBA,gBAAwCH,EAAwB,CAC9D,KAAK,sBAAsBA,EAAO,MAAM,EACxCA,EAAO,QAASe,GAAS,CACvBA,EAAK,UAAU,IAAI,CACrB,CAAC,CACH,CAoBA,gBAAwCZ,EAAiB,CACvD,IAAMa,EAAWb,IAAU,OAC3B,KAAK,cAAca,CAAQ,EACvBA,GACFb,EAAM,UAAU,IAAI,CAExB,CAwBA,mBAAmBA,EAAsB,CACnCA,IAAU,OACZ,KAAK,sBAAsB,CAAC,GAE5B,KAAK,sBAAsB,CAAC,EAC5B,KAAK,aAAaA,CAAK,EAE3B,CACF,EA1OEc,EAAA,CADCC,EAAiB,EAAGC,CAAa,GAlGvBzB,EAmGX,2BAgBAuB,EAAA,CADCC,EAAiB,EAAGE,CAAc,GAlHxB1B,EAmHX,4BAgBAuB,EAAA,CADCC,EAAiB,EAAGT,CAAc,GAlIxBf,EAmIX,4BAgBAuB,EAAA,CADCC,EAAiB,OAAO,CAAC,EAAGP,CAAe,GAlJjCjB,EAmJX,4BAeAuB,EAAA,CADCC,EAAiB,OAAO,CAAC,EAAGN,CAAgB,GAjKlClB,EAkKX,6BAeAuB,EAAA,CADCC,EAAiB,OAAO,CAAC,EAAGG,CAAgB,GAhLlC3B,EAiLX,6BAeAuB,EAAA,CADCC,EAAiB,EAAGT,CAAc,GA/LxBf,EAgMX,qCA+IK,SAASY,EAAcH,EAA0C,CACtE,GAAI,OAAOA,GAAU,UACnB,MAAM,IAAI,MAAM,GAAGA,CAAK,yBAAyB,CAErD,CAEO,IAAMmB,EAAyB,CAACnB,EAAkBoB,EAAgBC,IACvE,GAAGrB,CAAK,sBAAsBoB,CAAG,KAAKC,CAAG,IAEpC,SAASC,EAA2CtB,EAAUuB,EAAaC,EAAa,CAC7F,IAAMC,EAAc,OAAOzB,CAAK,EAChC,GAAIyB,EAAc,OAAOD,CAAQ,GAAKC,EAAc,OAAOF,CAAQ,EACjE,MAAM,IAAI,MAAMJ,EAAuBnB,EAAOuB,EAAUC,CAAQ,CAAC,CAErE,CAOA,SAAST,EAAsCQ,EAAaC,EAAa,CACvE,MAAO,CAACE,EAAiBC,EAAqBC,IAAmC,CAC/E,IAAMC,EAAgBD,EAAW,MAEjC,OAAAA,EAAW,MAAQ,SAAc5B,EAAkB,CACjD,OAAAsB,EAAsBtB,EAAOuB,EAAUC,CAAQ,EACxCK,EAAc,MAAM,KAAM,CAAC7B,CAAK,CAAC,CAC1C,EAEO4B,CACT,CACF","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","hasValue","__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  /**\n   * Serializes a BCS Serializable values into a serializer instance or undefined.\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   *\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeOption(new AccountAddress(...));\n   * const serializedBytes = serializer.toUint8Array();\n   * // serializedBytes is now the BCS-serialized byte representation of AccountAddress\n   *\n   * const serializer = new Serializer();\n   * serializer.serializeOption(undefined);\n   * assert(serializer.toUint8Array() === new Uint8Array([0x00]));\n   * ```\n   */\n  serializeOption<T extends Serializable>(value?: T): void {\n    const hasValue = value !== undefined;\n    this.serializeBool(hasValue);\n    if (hasValue) {\n      value.serialize(this);\n    }\n  }\n\n  /**\n   * Serializes an optional string. UTF8 string is supported.\n   *\n   * The existence of the string is encoded first, 0 if undefined and 1 if it exists.\n   * Them the number of bytes in the string content is serialized, as a uleb128-encoded u32 integer.\n   * Then the string content is serialized as UTF8 encoded bytes.\n   *\n   * BCS layout for optional \"string\": 1 | 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   * BCS layout for undefined: 0\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeOptionStr(\"1234abcd\");\n   * assert(serializer.toUint8Array() === new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));\n   *\n   * const serializer = new Serializer();\n   * serializer.serializeOptionStr(undefined);\n   * assert(serializer.toUint8Array() === new Uint8Array([0]));\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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBA,gBAAwC,OAAiB;AACvD,UAAM,WAAW,UAAU;AAC3B,SAAK,cAAc,QAAQ;AAC3B,QAAI,UAAU;AACZ,YAAM,UAAU,IAAI;AAAA,IACtB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAwBA,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;AA1OE;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;AA+IK,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-V2LEZDNS.mjs

@@ -0,0 +1,29 @@
+import {
+  AccountAddress
+} from "./chunk-IUC6XUYA.mjs";
+
+// src/core/account/utils/address.ts
+import { sha3_256 } from "@noble/hashes/sha3";
+var createObjectAddress = (creatorAddress, seed) => {
+  const creatorBytes = creatorAddress.bcsToBytes();
+  const seedBytes = typeof seed === "string" ? Buffer.from(seed, "utf8") : seed;
+  const bytes = new Uint8Array([...creatorBytes, ...seedBytes, 254 /* DeriveObjectAddressFromSeed */]);
+  return new AccountAddress(sha3_256(bytes));
+};
+var createResourceAddress = (creatorAddress, seed) => {
+  const creatorBytes = creatorAddress.bcsToBytes();
+  const seedBytes = typeof seed === "string" ? Buffer.from(seed, "utf8") : seed;
+  const bytes = new Uint8Array([...creatorBytes, ...seedBytes, 255 /* DeriveResourceAccountAddress */]);
+  return new AccountAddress(sha3_256(bytes));
+};
+var createTokenAddress = (creatorAddress, collectionName, tokenName) => {
+  const seed = `${collectionName}::${tokenName}`;
+  return createObjectAddress(creatorAddress, seed);
+};
+
+export {
+  createObjectAddress,
+  createResourceAddress,
+  createTokenAddress
+};
+//# sourceMappingURL=chunk-V2LEZDNS.mjs.map

package/dist/esm/{chunk-WRRQ7L5K.mjs.map → chunk-V2LEZDNS.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/account/utils/address.ts"],"sourcesContent":["import { sha3_256 } from \"@noble/hashes/sha3\";\nimport { AccountAddress } from \"../../accountAddress\";\nimport { DeriveScheme } from \"../../../types\";\n\n/**\n * Creates an object address from creator address and seed\n *\n * @param creatorAddress The object creator account address\n * @param seed The seed in either Uint8Array | string type\n *\n * @returns The object account address\n */\nexport const createObjectAddress = (creatorAddress: AccountAddress, seed: Uint8Array | string): AccountAddress => {\n  const creatorBytes = creatorAddress.bcsToBytes();\n\n  const seedBytes = typeof seed === \"string\" ? Buffer.from(seed, \"utf8\") : seed;\n\n  const bytes = new Uint8Array([...creatorBytes, ...seedBytes, DeriveScheme.DeriveObjectAddressFromSeed]);\n\n  return new AccountAddress(sha3_256(bytes));\n};\n\n/**\n * Creates an resource address from creator address and seed\n *\n * @param creatorAddress The creator account address\n * @param seed The seed in either Uint8Array | string type\n *\n * @returns The resource account address\n */\nexport const createResourceAddress = (creatorAddress: AccountAddress, seed: Uint8Array | string): AccountAddress => {\n  const creatorBytes = creatorAddress.bcsToBytes();\n\n  const seedBytes = typeof seed === \"string\" ? Buffer.from(seed, \"utf8\") : seed;\n\n  const bytes = new Uint8Array([...creatorBytes, ...seedBytes, DeriveScheme.DeriveResourceAccountAddress]);\n\n  return new AccountAddress(sha3_256(bytes));\n};\n\n/**\n * Creates a token object address from creator address, collection name and token name\n *\n * @param creatorAddress The token creator account address\n * @param collectionName The collection name\n * @param tokenName The token name\n *\n * @returns The token account address\n */\nexport const createTokenAddress = (\n  creatorAddress: AccountAddress,\n  collectionName: string,\n  tokenName: string,\n): AccountAddress => {\n  const seed = `${collectionName}::${tokenName}`;\n  return createObjectAddress(creatorAddress, seed);\n};\n"],"mappings":"yCAAA,OAAS,YAAAA,MAAgB,qBAYlB,IAAMC,EAAsB,CAACC,EAAgCC,IAA8C,CAChH,IAAMC,EAAeF,EAAe,WAAW,EAEzCG,EAAY,OAAOF,GAAS,SAAW,OAAO,KAAKA,EAAM,MAAM,EAAIA,EAEnEG,EAAQ,IAAI,WAAW,CAAC,GAAGF,EAAc,GAAGC,KAAmD,CAAC,EAEtG,OAAO,IAAIE,EAAeC,EAASF,CAAK,CAAC,CAC3C,EAUaG,EAAwB,CAACP,EAAgCC,IAA8C,CAClH,IAAMC,EAAeF,EAAe,WAAW,EAEzCG,EAAY,OAAOF,GAAS,SAAW,OAAO,KAAKA,EAAM,MAAM,EAAIA,EAEnEG,EAAQ,IAAI,WAAW,CAAC,GAAGF,EAAc,GAAGC,KAAoD,CAAC,EAEvG,OAAO,IAAIE,EAAeC,EAASF,CAAK,CAAC,CAC3C,EAWaI,EAAqB,CAChCR,EACAS,EACAC,IACmB,CACnB,IAAMT,EAAO,GAAGQ,CAAc,KAAKC,CAAS,GAC5C,OAAOX,EAAoBC,EAAgBC,CAAI,CACjD","names":["sha3_256","createObjectAddress","creatorAddress","seed","creatorBytes","seedBytes","bytes","AccountAddress","sha3_256","createResourceAddress","createTokenAddress","collectionName","tokenName"]}
+{"version":3,"sources":["../../src/core/account/utils/address.ts"],"sourcesContent":["import { sha3_256 } from \"@noble/hashes/sha3\";\nimport { AccountAddress } from \"../../accountAddress\";\nimport { DeriveScheme } from \"../../../types\";\n\n/**\n * Creates an object address from creator address and seed\n *\n * @param creatorAddress The object creator account address\n * @param seed The seed in either Uint8Array | string type\n *\n * @returns The object account address\n */\nexport const createObjectAddress = (creatorAddress: AccountAddress, seed: Uint8Array | string): AccountAddress => {\n  const creatorBytes = creatorAddress.bcsToBytes();\n\n  const seedBytes = typeof seed === \"string\" ? Buffer.from(seed, \"utf8\") : seed;\n\n  const bytes = new Uint8Array([...creatorBytes, ...seedBytes, DeriveScheme.DeriveObjectAddressFromSeed]);\n\n  return new AccountAddress(sha3_256(bytes));\n};\n\n/**\n * Creates an resource address from creator address and seed\n *\n * @param creatorAddress The creator account address\n * @param seed The seed in either Uint8Array | string type\n *\n * @returns The resource account address\n */\nexport const createResourceAddress = (creatorAddress: AccountAddress, seed: Uint8Array | string): AccountAddress => {\n  const creatorBytes = creatorAddress.bcsToBytes();\n\n  const seedBytes = typeof seed === \"string\" ? Buffer.from(seed, \"utf8\") : seed;\n\n  const bytes = new Uint8Array([...creatorBytes, ...seedBytes, DeriveScheme.DeriveResourceAccountAddress]);\n\n  return new AccountAddress(sha3_256(bytes));\n};\n\n/**\n * Creates a token object address from creator address, collection name and token name\n *\n * @param creatorAddress The token creator account address\n * @param collectionName The collection name\n * @param tokenName The token name\n *\n * @returns The token account address\n */\nexport const createTokenAddress = (\n  creatorAddress: AccountAddress,\n  collectionName: string,\n  tokenName: string,\n): AccountAddress => {\n  const seed = `${collectionName}::${tokenName}`;\n  return createObjectAddress(creatorAddress, seed);\n};\n"],"mappings":";;;;;AAAA,SAAS,gBAAgB;AAYlB,IAAM,sBAAsB,CAAC,gBAAgC,SAA8C;AAChH,QAAM,eAAe,eAAe,WAAW;AAE/C,QAAM,YAAY,OAAO,SAAS,WAAW,OAAO,KAAK,MAAM,MAAM,IAAI;AAEzE,QAAM,QAAQ,IAAI,WAAW,CAAC,GAAG,cAAc,GAAG,gDAAmD,CAAC;AAEtG,SAAO,IAAI,eAAe,SAAS,KAAK,CAAC;AAC3C;AAUO,IAAM,wBAAwB,CAAC,gBAAgC,SAA8C;AAClH,QAAM,eAAe,eAAe,WAAW;AAE/C,QAAM,YAAY,OAAO,SAAS,WAAW,OAAO,KAAK,MAAM,MAAM,IAAI;AAEzE,QAAM,QAAQ,IAAI,WAAW,CAAC,GAAG,cAAc,GAAG,iDAAoD,CAAC;AAEvG,SAAO,IAAI,eAAe,SAAS,KAAK,CAAC;AAC3C;AAWO,IAAM,qBAAqB,CAChC,gBACA,gBACA,cACmB;AACnB,QAAM,OAAO,GAAG,cAAc,KAAK,SAAS;AAC5C,SAAO,oBAAoB,gBAAgB,IAAI;AACjD;","names":[]}

package/dist/esm/chunk-WKNU6EPA.mjs

@@ -0,0 +1,40 @@
+import {
+  getObjectDataByObjectAddress
+} from "./chunk-U6N546EH.mjs";
+import {
+  waitForIndexerOnVersion
+} from "./chunk-PSRD6U34.mjs";
+
+// src/api/object.ts
+var AptosObject = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Fetch the object data based on the oabject address
+   *
+   * @example
+   * const object = await aptos.getObjectDataByObjectAddress({objectAddress:"0x123"})
+   *
+   * @param args.objectAddress The object address
+   * @param args.options Configuration options for waitForTransaction
+   *
+   * @returns The object data
+   */
+  async getObjectDataByObjectAddress(args) {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorType: "objects_processor" /* OBJECT_PROCESSOR */
+    });
+    return getObjectDataByObjectAddress({
+      aptosConfig: this.config,
+      ...args
+    });
+  }
+};
+
+export {
+  AptosObject
+};
+//# sourceMappingURL=chunk-WKNU6EPA.mjs.map

package/dist/esm/{chunk-LHJBQVU4.mjs.map → chunk-WKNU6EPA.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/api/object.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AnyNumber, GetObjectDataQueryResponse, OrderByArg, PaginationArgs } from \"../types\";\nimport { AccountAddressInput } from \"../core\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { ProcessorType } from \"../utils\";\nimport { waitForIndexerOnVersion } from \"./utils\";\nimport { getObjectDataByObjectAddress } from \"../internal/object\";\n\n/**\n * A class to query all `Object` related queries on Aptos.\n */\nexport class AptosObject {\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Fetch the object data based on the oabject address\n   *\n   * @example\n   * const object = await aptos.getObjectDataByObjectAddress({objectAddress:\"0x123\"})\n   *\n   * @param args.objectAddress The object address\n   * @param args.options Configuration options for waitForTransaction\n   *\n   * @returns The object data\n   */\n  async getObjectDataByObjectAddress(args: {\n    objectAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & OrderByArg<GetObjectDataQueryResponse[0]>;\n  }): Promise<GetObjectDataQueryResponse[0]> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.OBJECT_PROCESSOR,\n    });\n    return getObjectDataByObjectAddress({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n}\n"],"mappings":"kFAaO,IAAMA,EAAN,KAAkB,CACvB,YAAqBC,EAAqB,CAArB,YAAAA,CAAsB,CAa3C,MAAM,6BAA6BC,EAIQ,CACzC,aAAMC,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBD,EAAK,qBAC3B,iCACF,CAAC,EACME,EAA6B,CAClC,YAAa,KAAK,OAClB,GAAGF,CACL,CAAC,CACH,CACF","names":["AptosObject","config","args","waitForIndexerOnVersion","getObjectDataByObjectAddress"]}
+{"version":3,"sources":["../../src/api/object.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AnyNumber, GetObjectDataQueryResponse, OrderByArg, PaginationArgs } from \"../types\";\nimport { AccountAddressInput } from \"../core\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { ProcessorType } from \"../utils\";\nimport { waitForIndexerOnVersion } from \"./utils\";\nimport { getObjectDataByObjectAddress } from \"../internal/object\";\n\n/**\n * A class to query all `Object` related queries on Aptos.\n */\nexport class AptosObject {\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Fetch the object data based on the oabject address\n   *\n   * @example\n   * const object = await aptos.getObjectDataByObjectAddress({objectAddress:\"0x123\"})\n   *\n   * @param args.objectAddress The object address\n   * @param args.options Configuration options for waitForTransaction\n   *\n   * @returns The object data\n   */\n  async getObjectDataByObjectAddress(args: {\n    objectAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & OrderByArg<GetObjectDataQueryResponse[0]>;\n  }): Promise<GetObjectDataQueryResponse[0]> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorType: ProcessorType.OBJECT_PROCESSOR,\n    });\n    return getObjectDataByObjectAddress({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n}\n"],"mappings":";;;;;;;;AAaO,IAAM,cAAN,MAAkB;AAAA,EACvB,YAAqB,QAAqB;AAArB;AAAA,EAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAa3C,MAAM,6BAA6B,MAIQ;AACzC,UAAM,wBAAwB;AAAA,MAC5B,QAAQ,KAAK;AAAA,MACb,sBAAsB,KAAK;AAAA,MAC3B;AAAA,IACF,CAAC;AACD,WAAO,6BAA6B;AAAA,MAClC,aAAa,KAAK;AAAA,MAClB,GAAG;AAAA,IACL,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/esm/chunk-WVT25KQR.mjs

@@ -0,0 +1,51 @@
+import {
+  RawTransaction
+} from "./chunk-NGUFBDTH.mjs";
+import {
+  AccountAddress
+} from "./chunk-IUC6XUYA.mjs";
+import {
+  Serializable
+} from "./chunk-UZXDD3QH.mjs";
+
+// src/transactions/instances/simpleTransaction.ts
+var SimpleTransaction = class _SimpleTransaction extends Serializable {
+  /**
+   * SimpleTransaction represents a simple transaction type of a single signer that
+   * can be submitted to Aptos chain for execution.
+   *
+   * SimpleTransaction metadata contains the Raw Transaction and an optional
+   * sponsor Account Address to pay the gas fees.
+   *
+   * @param rawTransaction The Raw Tranasaction
+   * @param feePayerAddress The sponsor Account Address
+   */
+  constructor(rawTransaction, feePayerAddress) {
+    super();
+    this.rawTransaction = rawTransaction;
+    this.feePayerAddress = feePayerAddress;
+  }
+  serialize(serializer) {
+    this.rawTransaction.serialize(serializer);
+    if (this.feePayerAddress === void 0) {
+      serializer.serializeBool(false);
+    } else {
+      serializer.serializeBool(true);
+      this.feePayerAddress.serialize(serializer);
+    }
+  }
+  static deserialize(deserializer) {
+    const rawTransaction = RawTransaction.deserialize(deserializer);
+    const feepayerPresent = deserializer.deserializeBool();
+    let feePayerAddress;
+    if (feepayerPresent) {
+      feePayerAddress = AccountAddress.deserialize(deserializer);
+    }
+    return new _SimpleTransaction(rawTransaction, feePayerAddress);
+  }
+};
+
+export {
+  SimpleTransaction
+};
+//# sourceMappingURL=chunk-WVT25KQR.mjs.map

package/dist/esm/{chunk-ZXPBRVOA.mjs.map → chunk-WVT25KQR.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/transactions/instances/simpleTransaction.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/* eslint-disable @typescript-eslint/naming-convention */\n\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializable, Serializer } from \"../../bcs/serializer\";\nimport { AccountAddress } from \"../../core\";\nimport { RawTransaction } from \"./rawTransaction\";\n\n/**\n * Representation of a SimpleTransaction that can serialized and deserialized\n */\nexport class SimpleTransaction extends Serializable {\n  public rawTransaction: RawTransaction;\n\n  public feePayerAddress?: AccountAddress | undefined;\n\n  // We dont really need it, we add it for type checkings we do\n  // throughout the SDK\n  public readonly secondarySignerAddresses: undefined;\n\n  /**\n   * SimpleTransaction represents a simple transaction type of a single signer that\n   * can be submitted to Aptos chain for execution.\n   *\n   * SimpleTransaction metadata contains the Raw Transaction and an optional\n   * sponsor Account Address to pay the gas fees.\n   *\n   * @param rawTransaction The Raw Tranasaction\n   * @param feePayerAddress The sponsor Account Address\n   */\n  constructor(rawTransaction: RawTransaction, feePayerAddress?: AccountAddress) {\n    super();\n    this.rawTransaction = rawTransaction;\n    this.feePayerAddress = feePayerAddress;\n  }\n\n  serialize(serializer: Serializer): void {\n    this.rawTransaction.serialize(serializer);\n\n    if (this.feePayerAddress === undefined) {\n      serializer.serializeBool(false);\n    } else {\n      serializer.serializeBool(true);\n      this.feePayerAddress.serialize(serializer);\n    }\n  }\n\n  static deserialize(deserializer: Deserializer): SimpleTransaction {\n    const rawTransaction = RawTransaction.deserialize(deserializer);\n    const feepayerPresent = deserializer.deserializeBool();\n    let feePayerAddress;\n    if (feepayerPresent) {\n      feePayerAddress = AccountAddress.deserialize(deserializer);\n    }\n\n    return new SimpleTransaction(rawTransaction, feePayerAddress);\n  }\n}\n"],"mappings":"2HAaO,IAAMA,EAAN,MAAMC,UAA0BC,CAAa,CAmBlD,YAAYC,EAAgCC,EAAkC,CAC5E,MAAM,EACN,KAAK,eAAiBD,EACtB,KAAK,gBAAkBC,CACzB,CAEA,UAAUC,EAA8B,CACtC,KAAK,eAAe,UAAUA,CAAU,EAEpC,KAAK,kBAAoB,OAC3BA,EAAW,cAAc,EAAK,GAE9BA,EAAW,cAAc,EAAI,EAC7B,KAAK,gBAAgB,UAAUA,CAAU,EAE7C,CAEA,OAAO,YAAYC,EAA+C,CAChE,IAAMH,EAAiBI,EAAe,YAAYD,CAAY,EACxDE,EAAkBF,EAAa,gBAAgB,EACjDF,EACJ,OAAII,IACFJ,EAAkBK,EAAe,YAAYH,CAAY,GAGpD,IAAIL,EAAkBE,EAAgBC,CAAe,CAC9D,CACF","names":["SimpleTransaction","_SimpleTransaction","Serializable","rawTransaction","feePayerAddress","serializer","deserializer","RawTransaction","feepayerPresent","AccountAddress"]}
+{"version":3,"sources":["../../src/transactions/instances/simpleTransaction.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/* eslint-disable @typescript-eslint/naming-convention */\n\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializable, Serializer } from \"../../bcs/serializer\";\nimport { AccountAddress } from \"../../core\";\nimport { RawTransaction } from \"./rawTransaction\";\n\n/**\n * Representation of a SimpleTransaction that can serialized and deserialized\n */\nexport class SimpleTransaction extends Serializable {\n  public rawTransaction: RawTransaction;\n\n  public feePayerAddress?: AccountAddress | undefined;\n\n  // We dont really need it, we add it for type checkings we do\n  // throughout the SDK\n  public readonly secondarySignerAddresses: undefined;\n\n  /**\n   * SimpleTransaction represents a simple transaction type of a single signer that\n   * can be submitted to Aptos chain for execution.\n   *\n   * SimpleTransaction metadata contains the Raw Transaction and an optional\n   * sponsor Account Address to pay the gas fees.\n   *\n   * @param rawTransaction The Raw Tranasaction\n   * @param feePayerAddress The sponsor Account Address\n   */\n  constructor(rawTransaction: RawTransaction, feePayerAddress?: AccountAddress) {\n    super();\n    this.rawTransaction = rawTransaction;\n    this.feePayerAddress = feePayerAddress;\n  }\n\n  serialize(serializer: Serializer): void {\n    this.rawTransaction.serialize(serializer);\n\n    if (this.feePayerAddress === undefined) {\n      serializer.serializeBool(false);\n    } else {\n      serializer.serializeBool(true);\n      this.feePayerAddress.serialize(serializer);\n    }\n  }\n\n  static deserialize(deserializer: Deserializer): SimpleTransaction {\n    const rawTransaction = RawTransaction.deserialize(deserializer);\n    const feepayerPresent = deserializer.deserializeBool();\n    let feePayerAddress;\n    if (feepayerPresent) {\n      feePayerAddress = AccountAddress.deserialize(deserializer);\n    }\n\n    return new SimpleTransaction(rawTransaction, feePayerAddress);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAaO,IAAM,oBAAN,MAAM,2BAA0B,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBlD,YAAY,gBAAgC,iBAAkC;AAC5E,UAAM;AACN,SAAK,iBAAiB;AACtB,SAAK,kBAAkB;AAAA,EACzB;AAAA,EAEA,UAAU,YAA8B;AACtC,SAAK,eAAe,UAAU,UAAU;AAExC,QAAI,KAAK,oBAAoB,QAAW;AACtC,iBAAW,cAAc,KAAK;AAAA,IAChC,OAAO;AACL,iBAAW,cAAc,IAAI;AAC7B,WAAK,gBAAgB,UAAU,UAAU;AAAA,IAC3C;AAAA,EACF;AAAA,EAEA,OAAO,YAAY,cAA+C;AAChE,UAAM,iBAAiB,eAAe,YAAY,YAAY;AAC9D,UAAM,kBAAkB,aAAa,gBAAgB;AACrD,QAAI;AACJ,QAAI,iBAAiB;AACnB,wBAAkB,eAAe,YAAY,YAAY;AAAA,IAC3D;AAEA,WAAO,IAAI,mBAAkB,gBAAgB,eAAe;AAAA,EAC9D;AACF;","names":[]}

package/dist/esm/chunk-XBY4UM6M.mjs

@@ -0,0 +1,206 @@
+import {
+  AnyPublicKey,
+  AnySignature
+} from "./chunk-NYELBSVO.mjs";
+import {
+  AccountPublicKey
+} from "./chunk-L3E7YJBM.mjs";
+import {
+  Signature
+} from "./chunk-6BI4XTJN.mjs";
+import {
+  AuthenticationKey
+} from "./chunk-ANOJYMO2.mjs";
+
+// src/core/crypto/multiKey.ts
+function bitCount(byte) {
+  let n = byte;
+  n -= n >> 1 & 1431655765;
+  n = (n & 858993459) + (n >> 2 & 858993459);
+  return (n + (n >> 4) & 252645135) * 16843009 >> 24;
+}
+var MultiKey = class _MultiKey extends AccountPublicKey {
+  // region Constructors
+  constructor(args) {
+    super();
+    const { publicKeys, signaturesRequired } = args;
+    if (signaturesRequired < 1) {
+      throw new Error("The number of required signatures needs to be greater than 0");
+    }
+    if (publicKeys.length < signaturesRequired) {
+      throw new Error(
+        `Provided ${publicKeys.length} public keys is smaller than the ${signaturesRequired} required signatures`
+      );
+    }
+    this.publicKeys = publicKeys.map(
+      (publicKey) => publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey)
+    );
+    this.signaturesRequired = signaturesRequired;
+  }
+  // endregion
+  // region AccountPublicKey
+  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+  verifySignature(args) {
+    throw new Error("not implemented");
+  }
+  authKey() {
+    return AuthenticationKey.fromSchemeAndBytes({
+      scheme: 3 /* MultiKey */,
+      input: this.toUint8Array()
+    });
+  }
+  toUint8Array() {
+    return this.bcsToBytes();
+  }
+  // endregion
+  // region Serializable
+  serialize(serializer) {
+    serializer.serializeVector(this.publicKeys);
+    serializer.serializeU8(this.signaturesRequired);
+  }
+  static deserialize(deserializer) {
+    const keys = deserializer.deserializeVector(AnyPublicKey);
+    const signaturesRequired = deserializer.deserializeU8();
+    return new _MultiKey({ publicKeys: keys, signaturesRequired });
+  }
+  // endregion
+  /**
+   * Create a bitmap that holds the mapping from the original public keys
+   * to the signatures passed in
+   *
+   * @param args.bits array of the index mapping to the matching public keys
+   * @returns Uint8array bit map
+   */
+  createBitmap(args) {
+    const { bits } = args;
+    const firstBitInByte = 128;
+    const bitmap = new Uint8Array([0, 0, 0, 0]);
+    const dupCheckSet = /* @__PURE__ */ new Set();
+    bits.forEach((bit, idx) => {
+      if (idx + 1 > this.publicKeys.length) {
+        throw new Error(`Signature index ${idx + 1} is out of public keys range, ${this.publicKeys.length}.`);
+      }
+      if (dupCheckSet.has(bit)) {
+        throw new Error(`Duplicate bit ${bit} detected.`);
+      }
+      dupCheckSet.add(bit);
+      const byteOffset = Math.floor(bit / 8);
+      let byte = bitmap[byteOffset];
+      byte |= firstBitInByte >> bit % 8;
+      bitmap[byteOffset] = byte;
+    });
+    return bitmap;
+  }
+  /**
+   * Get the index of the provided public key.
+   *
+   * @param publicKey array of the index mapping to the matching public keys
+   * @returns the corresponding index of the publicKey, if it exists
+   */
+  getIndex(publicKey) {
+    const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey);
+    const index = this.publicKeys.findIndex((pk) => pk.toString() === anyPublicKey.toString());
+    if (index !== -1) {
+      return index;
+    }
+    throw new Error("Public key not found in MultiKey");
+  }
+};
+var _MultiKeySignature = class _MultiKeySignature extends Signature {
+  /**
+   * Signature for a K-of-N multi-sig transaction.
+   *
+   * @see {@link
+   * https://aptos.dev/integration/creating-a-signed-transaction/#multisignature-transactions | Creating a Signed Transaction}
+   *
+   * @param args.signatures A list of signatures
+   * @param args.bitmap 4 bytes, at most 32 signatures are supported. If Nth bit value is `1`, the Nth
+   * signature should be provided in `signatures`. Bits are read from left to right
+   */
+  constructor(args) {
+    super();
+    const { signatures, bitmap } = args;
+    if (signatures.length > _MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {
+      throw new Error(`The number of signatures cannot be greater than ${_MultiKeySignature.MAX_SIGNATURES_SUPPORTED}`);
+    }
+    this.signatures = signatures.map(
+      (signature) => signature instanceof AnySignature ? signature : new AnySignature(signature)
+    );
+    if (!(bitmap instanceof Uint8Array)) {
+      this.bitmap = _MultiKeySignature.createBitmap({ bits: bitmap });
+    } else if (bitmap.length !== _MultiKeySignature.BITMAP_LEN) {
+      throw new Error(`"bitmap" length should be ${_MultiKeySignature.BITMAP_LEN}`);
+    } else {
+      this.bitmap = bitmap;
+    }
+    const nSignatures = this.bitmap.reduce((acc, byte) => acc + bitCount(byte), 0);
+    if (nSignatures !== this.signatures.length) {
+      throw new Error(`Expecting ${nSignatures} signatures from the bitmap, but got ${this.signatures.length}`);
+    }
+  }
+  /**
+   * Helper method to create a bitmap out of the specified bit positions
+   * @param args.bits The bitmap positions that should be set. A position starts at index 0.
+   * Valid position should range between 0 and 31.
+   * @example
+   * Here's an example of valid `bits`
+   * ```
+   * [0, 2, 31]
+   * ```
+   * `[0, 2, 31]` means the 1st, 3rd and 32nd bits should be set in the bitmap.
+   * The result bitmap should be 0b1010000000000000000000000000001
+   *
+   * @returns bitmap that is 32bit long
+   */
+  static createBitmap(args) {
+    const { bits } = args;
+    const firstBitInByte = 128;
+    const bitmap = new Uint8Array([0, 0, 0, 0]);
+    const dupCheckSet = /* @__PURE__ */ new Set();
+    bits.forEach((bit) => {
+      if (bit >= _MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {
+        throw new Error(`Cannot have a signature larger than ${_MultiKeySignature.MAX_SIGNATURES_SUPPORTED - 1}.`);
+      }
+      if (dupCheckSet.has(bit)) {
+        throw new Error("Duplicate bits detected.");
+      }
+      dupCheckSet.add(bit);
+      const byteOffset = Math.floor(bit / 8);
+      let byte = bitmap[byteOffset];
+      byte |= firstBitInByte >> bit % 8;
+      bitmap[byteOffset] = byte;
+    });
+    return bitmap;
+  }
+  // region Signature
+  toUint8Array() {
+    return this.bcsToBytes();
+  }
+  // endregion
+  // region Serializable
+  serialize(serializer) {
+    serializer.serializeVector(this.signatures);
+    serializer.serializeBytes(this.bitmap);
+  }
+  static deserialize(deserializer) {
+    const signatures = deserializer.deserializeVector(AnySignature);
+    const bitmap = deserializer.deserializeBytes();
+    return new _MultiKeySignature({ signatures, bitmap });
+  }
+  // endregion
+};
+/**
+ * Number of bytes in the bitmap representing who signed the transaction (32-bits)
+ */
+_MultiKeySignature.BITMAP_LEN = 4;
+/**
+ * Maximum number of Ed25519 signatures supported
+ */
+_MultiKeySignature.MAX_SIGNATURES_SUPPORTED = _MultiKeySignature.BITMAP_LEN * 8;
+var MultiKeySignature = _MultiKeySignature;
+
+export {
+  MultiKey,
+  MultiKeySignature
+};
+//# sourceMappingURL=chunk-XBY4UM6M.mjs.map

package/dist/esm/{chunk-R3IDASOF.mjs.map → chunk-XBY4UM6M.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/crypto/multiKey.ts"],"sourcesContent":["import { SigningScheme as AuthenticationKeyScheme } from \"../../types\";\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializer } from \"../../bcs/serializer\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { AccountPublicKey, PublicKey, VerifySignatureArgs } from \"./publicKey\";\nimport { Signature } from \"./signature\";\nimport { AnyPublicKey, AnySignature } from \"./singleKey\";\n\n/* eslint-disable no-bitwise */\n\nfunction bitCount(byte: number) {\n  let n = byte;\n  n -= (n >> 1) & 0x55555555;\n  n = (n & 0x33333333) + ((n >> 2) & 0x33333333);\n  return (((n + (n >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24;\n}\n\n/* eslint-enable no-bitwise */\n\n/**\n * Represents the public key of a multi-agent account.\n *\n * The public keys of each individual agent can be any type of public key supported by Aptos.\n * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports\n * `Legacy` and `Unified` authentication keys.\n */\nexport class MultiKey extends AccountPublicKey {\n  /**\n   * List of any public keys\n   */\n  public readonly publicKeys: AnyPublicKey[];\n\n  /**\n   * The minimum number of valid signatures required, for the number of public keys specified\n   */\n  public readonly signaturesRequired: number;\n\n  // region Constructors\n\n  constructor(args: { publicKeys: Array<PublicKey>; signaturesRequired: number }) {\n    super();\n    const { publicKeys, signaturesRequired } = args;\n\n    // Validate number of public keys is greater than signature required\n    if (signaturesRequired < 1) {\n      throw new Error(\"The number of required signatures needs to be greater than 0\");\n    }\n\n    // Validate number of public keys is greater than signature required\n    if (publicKeys.length < signaturesRequired) {\n      throw new Error(\n        `Provided ${publicKeys.length} public keys is smaller than the ${signaturesRequired} required signatures`,\n      );\n    }\n\n    // Make sure that all keys are normalized to the SingleKey authentication scheme\n    this.publicKeys = publicKeys.map((publicKey) =>\n      publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey),\n    );\n\n    this.signaturesRequired = signaturesRequired;\n  }\n\n  // endregion\n\n  // region AccountPublicKey\n\n  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars\n  verifySignature(args: VerifySignatureArgs): boolean {\n    throw new Error(\"not implemented\");\n  }\n\n  authKey(): AuthenticationKey {\n    return AuthenticationKey.fromSchemeAndBytes({\n      scheme: AuthenticationKeyScheme.MultiKey,\n      input: this.toUint8Array(),\n    });\n  }\n\n  toUint8Array(): Uint8Array {\n    return this.bcsToBytes();\n  }\n\n  // endregion\n\n  // region Serializable\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeVector(this.publicKeys);\n    serializer.serializeU8(this.signaturesRequired);\n  }\n\n  static deserialize(deserializer: Deserializer): MultiKey {\n    const keys = deserializer.deserializeVector(AnyPublicKey);\n    const signaturesRequired = deserializer.deserializeU8();\n\n    return new MultiKey({ publicKeys: keys, signaturesRequired });\n  }\n\n  // endregion\n\n  /**\n   * Create a bitmap that holds the mapping from the original public keys\n   * to the signatures passed in\n   *\n   * @param args.bits array of the index mapping to the matching public keys\n   * @returns Uint8array bit map\n   */\n  createBitmap(args: { bits: number[] }): Uint8Array {\n    const { bits } = args;\n    // Bits are read from left to right. e.g. 0b10000000 represents the first bit is set in one byte.\n    // The decimal value of 0b10000000 is 128.\n    const firstBitInByte = 128;\n    const bitmap = new Uint8Array([0, 0, 0, 0]);\n\n    // Check if duplicates exist in bits\n    const dupCheckSet = new Set();\n\n    bits.forEach((bit: number, idx: number) => {\n      if (idx + 1 > this.publicKeys.length) {\n        throw new Error(`Signature index ${idx + 1} is out of public keys range, ${this.publicKeys.length}.`);\n      }\n\n      if (dupCheckSet.has(bit)) {\n        throw new Error(`Duplicate bit ${bit} detected.`);\n      }\n\n      dupCheckSet.add(bit);\n\n      const byteOffset = Math.floor(bit / 8);\n\n      let byte = bitmap[byteOffset];\n\n      // eslint-disable-next-line no-bitwise\n      byte |= firstBitInByte >> bit % 8;\n\n      bitmap[byteOffset] = byte;\n    });\n\n    return bitmap;\n  }\n\n  /**\n   * Get the index of the provided public key.\n   *\n   * @param publicKey array of the index mapping to the matching public keys\n   * @returns the corresponding index of the publicKey, if it exists\n   */\n  getIndex(publicKey: PublicKey): number {\n    const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey);\n    const index = this.publicKeys.findIndex((pk) => pk.toString() === anyPublicKey.toString());\n\n    if (index !== -1) {\n      return index;\n    }\n    throw new Error(\"Public key not found in MultiKey\");\n  }\n}\n\nexport class MultiKeySignature extends Signature {\n  /**\n   * Number of bytes in the bitmap representing who signed the transaction (32-bits)\n   */\n  static BITMAP_LEN: number = 4;\n\n  /**\n   * Maximum number of Ed25519 signatures supported\n   */\n  static MAX_SIGNATURES_SUPPORTED = MultiKeySignature.BITMAP_LEN * 8;\n\n  /**\n   * The list of underlying Ed25519 signatures\n   */\n  public readonly signatures: AnySignature[];\n\n  /**\n   * 32-bit Bitmap representing who signed the transaction\n   *\n   * This is represented where each public key can be masked to determine whether the message was signed by that key.\n   */\n  public readonly bitmap: Uint8Array;\n\n  /**\n   * Signature for a K-of-N multi-sig transaction.\n   *\n   * @see {@link\n   * https://aptos.dev/integration/creating-a-signed-transaction/#multisignature-transactions | Creating a Signed Transaction}\n   *\n   * @param args.signatures A list of signatures\n   * @param args.bitmap 4 bytes, at most 32 signatures are supported. If Nth bit value is `1`, the Nth\n   * signature should be provided in `signatures`. Bits are read from left to right\n   */\n  constructor(args: { signatures: Array<Signature | AnySignature>; bitmap: Uint8Array | number[] }) {\n    super();\n    const { signatures, bitmap } = args;\n\n    if (signatures.length > MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {\n      throw new Error(`The number of signatures cannot be greater than ${MultiKeySignature.MAX_SIGNATURES_SUPPORTED}`);\n    }\n\n    // Make sure that all signatures are normalized to the SingleKey authentication scheme\n    this.signatures = signatures.map((signature) =>\n      signature instanceof AnySignature ? signature : new AnySignature(signature),\n    );\n\n    if (!(bitmap instanceof Uint8Array)) {\n      this.bitmap = MultiKeySignature.createBitmap({ bits: bitmap });\n    } else if (bitmap.length !== MultiKeySignature.BITMAP_LEN) {\n      throw new Error(`\"bitmap\" length should be ${MultiKeySignature.BITMAP_LEN}`);\n    } else {\n      this.bitmap = bitmap;\n    }\n\n    const nSignatures = this.bitmap.reduce((acc, byte) => acc + bitCount(byte), 0);\n    if (nSignatures !== this.signatures.length) {\n      throw new Error(`Expecting ${nSignatures} signatures from the bitmap, but got ${this.signatures.length}`);\n    }\n  }\n\n  /**\n   * Helper method to create a bitmap out of the specified bit positions\n   * @param args.bits The bitmap positions that should be set. A position starts at index 0.\n   * Valid position should range between 0 and 31.\n   * @example\n   * Here's an example of valid `bits`\n   * ```\n   * [0, 2, 31]\n   * ```\n   * `[0, 2, 31]` means the 1st, 3rd and 32nd bits should be set in the bitmap.\n   * The result bitmap should be 0b1010000000000000000000000000001\n   *\n   * @returns bitmap that is 32bit long\n   */\n  static createBitmap(args: { bits: number[] }): Uint8Array {\n    const { bits } = args;\n    // Bits are read from left to right. e.g. 0b10000000 represents the first bit is set in one byte.\n    // The decimal value of 0b10000000 is 128.\n    const firstBitInByte = 128;\n    const bitmap = new Uint8Array([0, 0, 0, 0]);\n\n    // Check if duplicates exist in bits\n    const dupCheckSet = new Set();\n\n    bits.forEach((bit: number) => {\n      if (bit >= MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {\n        throw new Error(`Cannot have a signature larger than ${MultiKeySignature.MAX_SIGNATURES_SUPPORTED - 1}.`);\n      }\n\n      if (dupCheckSet.has(bit)) {\n        throw new Error(\"Duplicate bits detected.\");\n      }\n\n      dupCheckSet.add(bit);\n\n      const byteOffset = Math.floor(bit / 8);\n\n      let byte = bitmap[byteOffset];\n\n      // eslint-disable-next-line no-bitwise\n      byte |= firstBitInByte >> bit % 8;\n\n      bitmap[byteOffset] = byte;\n    });\n\n    return bitmap;\n  }\n\n  // region Signature\n\n  toUint8Array(): Uint8Array {\n    return this.bcsToBytes();\n  }\n\n  // endregion\n\n  // region Serializable\n\n  serialize(serializer: Serializer): void {\n    // Note: we should not need to serialize the vector length, as it can be derived from the bitmap\n    serializer.serializeVector(this.signatures);\n    serializer.serializeBytes(this.bitmap);\n  }\n\n  static deserialize(deserializer: Deserializer): MultiKeySignature {\n    const signatures = deserializer.deserializeVector(AnySignature);\n    const bitmap = deserializer.deserializeBytes();\n    return new MultiKeySignature({ signatures, bitmap });\n  }\n\n  // endregion\n}\n"],"mappings":"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","names":["bitCount","byte","n","MultiKey","_MultiKey","AccountPublicKey","args","publicKeys","signaturesRequired","publicKey","AnyPublicKey","AuthenticationKey","serializer","deserializer","keys","bits","firstBitInByte","bitmap","dupCheckSet","bit","idx","byteOffset","anyPublicKey","index","pk","_MultiKeySignature","Signature","signatures","signature","AnySignature","nSignatures","acc","MultiKeySignature"]}
+{"version":3,"sources":["../../src/core/crypto/multiKey.ts"],"sourcesContent":["import { SigningScheme as AuthenticationKeyScheme } from \"../../types\";\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializer } from \"../../bcs/serializer\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { AccountPublicKey, PublicKey, VerifySignatureArgs } from \"./publicKey\";\nimport { Signature } from \"./signature\";\nimport { AnyPublicKey, AnySignature } from \"./singleKey\";\n\n/* eslint-disable no-bitwise */\n\nfunction bitCount(byte: number) {\n  let n = byte;\n  n -= (n >> 1) & 0x55555555;\n  n = (n & 0x33333333) + ((n >> 2) & 0x33333333);\n  return (((n + (n >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24;\n}\n\n/* eslint-enable no-bitwise */\n\n/**\n * Represents the public key of a multi-agent account.\n *\n * The public keys of each individual agent can be any type of public key supported by Aptos.\n * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports\n * `Legacy` and `Unified` authentication keys.\n */\nexport class MultiKey extends AccountPublicKey {\n  /**\n   * List of any public keys\n   */\n  public readonly publicKeys: AnyPublicKey[];\n\n  /**\n   * The minimum number of valid signatures required, for the number of public keys specified\n   */\n  public readonly signaturesRequired: number;\n\n  // region Constructors\n\n  constructor(args: { publicKeys: Array<PublicKey>; signaturesRequired: number }) {\n    super();\n    const { publicKeys, signaturesRequired } = args;\n\n    // Validate number of public keys is greater than signature required\n    if (signaturesRequired < 1) {\n      throw new Error(\"The number of required signatures needs to be greater than 0\");\n    }\n\n    // Validate number of public keys is greater than signature required\n    if (publicKeys.length < signaturesRequired) {\n      throw new Error(\n        `Provided ${publicKeys.length} public keys is smaller than the ${signaturesRequired} required signatures`,\n      );\n    }\n\n    // Make sure that all keys are normalized to the SingleKey authentication scheme\n    this.publicKeys = publicKeys.map((publicKey) =>\n      publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey),\n    );\n\n    this.signaturesRequired = signaturesRequired;\n  }\n\n  // endregion\n\n  // region AccountPublicKey\n\n  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars\n  verifySignature(args: VerifySignatureArgs): boolean {\n    throw new Error(\"not implemented\");\n  }\n\n  authKey(): AuthenticationKey {\n    return AuthenticationKey.fromSchemeAndBytes({\n      scheme: AuthenticationKeyScheme.MultiKey,\n      input: this.toUint8Array(),\n    });\n  }\n\n  toUint8Array(): Uint8Array {\n    return this.bcsToBytes();\n  }\n\n  // endregion\n\n  // region Serializable\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeVector(this.publicKeys);\n    serializer.serializeU8(this.signaturesRequired);\n  }\n\n  static deserialize(deserializer: Deserializer): MultiKey {\n    const keys = deserializer.deserializeVector(AnyPublicKey);\n    const signaturesRequired = deserializer.deserializeU8();\n\n    return new MultiKey({ publicKeys: keys, signaturesRequired });\n  }\n\n  // endregion\n\n  /**\n   * Create a bitmap that holds the mapping from the original public keys\n   * to the signatures passed in\n   *\n   * @param args.bits array of the index mapping to the matching public keys\n   * @returns Uint8array bit map\n   */\n  createBitmap(args: { bits: number[] }): Uint8Array {\n    const { bits } = args;\n    // Bits are read from left to right. e.g. 0b10000000 represents the first bit is set in one byte.\n    // The decimal value of 0b10000000 is 128.\n    const firstBitInByte = 128;\n    const bitmap = new Uint8Array([0, 0, 0, 0]);\n\n    // Check if duplicates exist in bits\n    const dupCheckSet = new Set();\n\n    bits.forEach((bit: number, idx: number) => {\n      if (idx + 1 > this.publicKeys.length) {\n        throw new Error(`Signature index ${idx + 1} is out of public keys range, ${this.publicKeys.length}.`);\n      }\n\n      if (dupCheckSet.has(bit)) {\n        throw new Error(`Duplicate bit ${bit} detected.`);\n      }\n\n      dupCheckSet.add(bit);\n\n      const byteOffset = Math.floor(bit / 8);\n\n      let byte = bitmap[byteOffset];\n\n      // eslint-disable-next-line no-bitwise\n      byte |= firstBitInByte >> bit % 8;\n\n      bitmap[byteOffset] = byte;\n    });\n\n    return bitmap;\n  }\n\n  /**\n   * Get the index of the provided public key.\n   *\n   * @param publicKey array of the index mapping to the matching public keys\n   * @returns the corresponding index of the publicKey, if it exists\n   */\n  getIndex(publicKey: PublicKey): number {\n    const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey);\n    const index = this.publicKeys.findIndex((pk) => pk.toString() === anyPublicKey.toString());\n\n    if (index !== -1) {\n      return index;\n    }\n    throw new Error(\"Public key not found in MultiKey\");\n  }\n}\n\nexport class MultiKeySignature extends Signature {\n  /**\n   * Number of bytes in the bitmap representing who signed the transaction (32-bits)\n   */\n  static BITMAP_LEN: number = 4;\n\n  /**\n   * Maximum number of Ed25519 signatures supported\n   */\n  static MAX_SIGNATURES_SUPPORTED = MultiKeySignature.BITMAP_LEN * 8;\n\n  /**\n   * The list of underlying Ed25519 signatures\n   */\n  public readonly signatures: AnySignature[];\n\n  /**\n   * 32-bit Bitmap representing who signed the transaction\n   *\n   * This is represented where each public key can be masked to determine whether the message was signed by that key.\n   */\n  public readonly bitmap: Uint8Array;\n\n  /**\n   * Signature for a K-of-N multi-sig transaction.\n   *\n   * @see {@link\n   * https://aptos.dev/integration/creating-a-signed-transaction/#multisignature-transactions | Creating a Signed Transaction}\n   *\n   * @param args.signatures A list of signatures\n   * @param args.bitmap 4 bytes, at most 32 signatures are supported. If Nth bit value is `1`, the Nth\n   * signature should be provided in `signatures`. Bits are read from left to right\n   */\n  constructor(args: { signatures: Array<Signature | AnySignature>; bitmap: Uint8Array | number[] }) {\n    super();\n    const { signatures, bitmap } = args;\n\n    if (signatures.length > MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {\n      throw new Error(`The number of signatures cannot be greater than ${MultiKeySignature.MAX_SIGNATURES_SUPPORTED}`);\n    }\n\n    // Make sure that all signatures are normalized to the SingleKey authentication scheme\n    this.signatures = signatures.map((signature) =>\n      signature instanceof AnySignature ? signature : new AnySignature(signature),\n    );\n\n    if (!(bitmap instanceof Uint8Array)) {\n      this.bitmap = MultiKeySignature.createBitmap({ bits: bitmap });\n    } else if (bitmap.length !== MultiKeySignature.BITMAP_LEN) {\n      throw new Error(`\"bitmap\" length should be ${MultiKeySignature.BITMAP_LEN}`);\n    } else {\n      this.bitmap = bitmap;\n    }\n\n    const nSignatures = this.bitmap.reduce((acc, byte) => acc + bitCount(byte), 0);\n    if (nSignatures !== this.signatures.length) {\n      throw new Error(`Expecting ${nSignatures} signatures from the bitmap, but got ${this.signatures.length}`);\n    }\n  }\n\n  /**\n   * Helper method to create a bitmap out of the specified bit positions\n   * @param args.bits The bitmap positions that should be set. A position starts at index 0.\n   * Valid position should range between 0 and 31.\n   * @example\n   * Here's an example of valid `bits`\n   * ```\n   * [0, 2, 31]\n   * ```\n   * `[0, 2, 31]` means the 1st, 3rd and 32nd bits should be set in the bitmap.\n   * The result bitmap should be 0b1010000000000000000000000000001\n   *\n   * @returns bitmap that is 32bit long\n   */\n  static createBitmap(args: { bits: number[] }): Uint8Array {\n    const { bits } = args;\n    // Bits are read from left to right. e.g. 0b10000000 represents the first bit is set in one byte.\n    // The decimal value of 0b10000000 is 128.\n    const firstBitInByte = 128;\n    const bitmap = new Uint8Array([0, 0, 0, 0]);\n\n    // Check if duplicates exist in bits\n    const dupCheckSet = new Set();\n\n    bits.forEach((bit: number) => {\n      if (bit >= MultiKeySignature.MAX_SIGNATURES_SUPPORTED) {\n        throw new Error(`Cannot have a signature larger than ${MultiKeySignature.MAX_SIGNATURES_SUPPORTED - 1}.`);\n      }\n\n      if (dupCheckSet.has(bit)) {\n        throw new Error(\"Duplicate bits detected.\");\n      }\n\n      dupCheckSet.add(bit);\n\n      const byteOffset = Math.floor(bit / 8);\n\n      let byte = bitmap[byteOffset];\n\n      // eslint-disable-next-line no-bitwise\n      byte |= firstBitInByte >> bit % 8;\n\n      bitmap[byteOffset] = byte;\n    });\n\n    return bitmap;\n  }\n\n  // region Signature\n\n  toUint8Array(): Uint8Array {\n    return this.bcsToBytes();\n  }\n\n  // endregion\n\n  // region Serializable\n\n  serialize(serializer: Serializer): void {\n    // Note: we should not need to serialize the vector length, as it can be derived from the bitmap\n    serializer.serializeVector(this.signatures);\n    serializer.serializeBytes(this.bitmap);\n  }\n\n  static deserialize(deserializer: Deserializer): MultiKeySignature {\n    const signatures = deserializer.deserializeVector(AnySignature);\n    const bitmap = deserializer.deserializeBytes();\n    return new MultiKeySignature({ signatures, bitmap });\n  }\n\n  // endregion\n}\n"],"mappings":"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","names":[]}