@aptos-labs/ts-sdk 1.33.2 → 1.35.0-zeta.0

package/dist/esm/chunk-3TUV6YMI.mjs

@@ -0,0 +1,305 @@
+import {
+  AbstractMultiKey
+} from "./chunk-DMFRIING.mjs";
+import {
+  Ed25519PublicKey,
+  Ed25519Signature
+} from "./chunk-TFW6N66T.mjs";
+import {
+  Signature
+} from "./chunk-KLUO6XPE.mjs";
+import {
+  AuthenticationKey
+} from "./chunk-PKUXOBIV.mjs";
+
+// src/core/crypto/multiEd25519.ts
+var _MultiEd25519PublicKey = class _MultiEd25519PublicKey extends AbstractMultiKey {
+  /**
+   * Public key for a K-of-N multi-sig transaction. A K-of-N multi-sig transaction means that for such a
+   * transaction to be executed, at least K out of the N authorized signers have signed the transaction
+   * and passed the check conducted by the chain.
+   *
+   * @see {@link
+   * https://aptos.dev/integration/creating-a-signed-transaction/ | Creating a Signed Transaction}
+   * @param args - A wrapper to let you choose the param order.
+   * @param args.publicKeys A list of public keys
+   * @param args.threshold At least "threshold" signatures must be valid
+   * @group Implementation
+   * @category Serialization
+   */
+  constructor(args) {
+    const { publicKeys, threshold } = args;
+    super({ publicKeys });
+    if (publicKeys.length > _MultiEd25519PublicKey.MAX_KEYS || publicKeys.length < _MultiEd25519PublicKey.MIN_KEYS) {
+      throw new Error(
+        `Must have between ${_MultiEd25519PublicKey.MIN_KEYS} and ${_MultiEd25519PublicKey.MAX_KEYS} public keys, inclusive`
+      );
+    }
+    if (threshold < _MultiEd25519PublicKey.MIN_THRESHOLD || threshold > publicKeys.length) {
+      throw new Error(
+        `Threshold must be between ${_MultiEd25519PublicKey.MIN_THRESHOLD} and ${publicKeys.length}, inclusive`
+      );
+    }
+    this.publicKeys = publicKeys;
+    this.threshold = threshold;
+  }
+  // region AccountPublicKey
+  /**
+   * Verifies a multi-signature against a given message.
+   * This function ensures that the provided signatures meet the required threshold and are valid for the given message.
+   *
+   * @param args - The arguments for verifying the signature.
+   * @param args.message - The message that was signed.
+   * @param args.signature - The multi-signature containing multiple signatures and a bitmap indicating which signatures are valid.
+   * @returns True if the signature is valid; otherwise, false.
+   * @throws Error if the bitmap and signatures length mismatch or if there are not enough valid signatures.
+   * @group Implementation
+   * @category Serialization
+   */
+  verifySignature(args) {
+    const { message, signature } = args;
+    if (!(signature instanceof MultiEd25519Signature)) {
+      return false;
+    }
+    const indices = [];
+    for (let i = 0; i < 4; i += 1) {
+      for (let j = 0; j < 8; j += 1) {
+        const bitIsSet = (signature.bitmap[i] & 1 << 7 - j) !== 0;
+        if (bitIsSet) {
+          const index = i * 8 + j;
+          indices.push(index);
+        }
+      }
+    }
+    if (indices.length !== signature.signatures.length) {
+      throw new Error("Bitmap and signatures length mismatch");
+    }
+    if (indices.length < this.threshold) {
+      throw new Error("Not enough signatures");
+    }
+    for (let i = 0; i < indices.length; i += 1) {
+      const publicKey = this.publicKeys[indices[i]];
+      if (!publicKey.verifySignature({ message, signature: signature.signatures[i] })) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Generates an authentication key based on the current instance's byte representation.
+   * This function is essential for creating a secure authentication key that can be used for various cryptographic operations.
+   *
+   * @returns {AuthenticationKey} The generated authentication key.
+   * @group Implementation
+   * @category Serialization
+   */
+  authKey() {
+    return AuthenticationKey.fromSchemeAndBytes({
+      scheme: 1 /* MultiEd25519 */,
+      input: this.toUint8Array()
+    });
+  }
+  /**
+   * Converts a PublicKeys into Uint8Array (bytes) with: bytes = p1_bytes | ... | pn_bytes | threshold
+   * @group Implementation
+   * @category Serialization
+   */
+  toUint8Array() {
+    const bytes = new Uint8Array(this.publicKeys.length * Ed25519PublicKey.LENGTH + 1);
+    this.publicKeys.forEach((k, i) => {
+      bytes.set(k.toUint8Array(), i * Ed25519PublicKey.LENGTH);
+    });
+    bytes[this.publicKeys.length * Ed25519PublicKey.LENGTH] = this.threshold;
+    return bytes;
+  }
+  // endregion
+  // region Serializable
+  /**
+   * Serializes the current instance into bytes using the provided serializer.
+   * This allows for the conversion of the instance's data into a format suitable for transmission or storage.
+   *
+   * @param serializer - The serializer used to convert the instance into bytes.
+   * @group Implementation
+   * @category Serialization
+   */
+  serialize(serializer) {
+    serializer.serializeBytes(this.toUint8Array());
+  }
+  /**
+   * Deserializes a MultiEd25519Signature from the provided deserializer.
+   * This function helps in reconstructing a MultiEd25519Signature object from its serialized byte representation.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   * @group Implementation
+   * @category Serialization
+   */
+  static deserialize(deserializer) {
+    const bytes = deserializer.deserializeBytes();
+    const threshold = bytes[bytes.length - 1];
+    const keys = [];
+    for (let i = 0; i < bytes.length - 1; i += Ed25519PublicKey.LENGTH) {
+      const begin = i;
+      keys.push(new Ed25519PublicKey(bytes.subarray(begin, begin + Ed25519PublicKey.LENGTH)));
+    }
+    return new _MultiEd25519PublicKey({ publicKeys: keys, threshold });
+  }
+  // endregion
+  /**
+   * Get the index of the provided public key.
+   *
+   * This function retrieves the index of a specified public key within the MultiKey.
+   * If the public key does not exist, it throws an error.
+   *
+   * @param publicKey - The public key to find the index for.
+   * @returns The corresponding index of the public key, if it exists.
+   * @throws Error - If the public key is not found in the MultiKey.
+   * @group Implementation
+   */
+  getIndex(publicKey) {
+    return super.getIndex(publicKey);
+  }
+};
+/**
+ * Maximum number of public keys supported
+ * @group Implementation
+ * @category Serialization
+ */
+_MultiEd25519PublicKey.MAX_KEYS = 32;
+/**
+ * Minimum number of public keys needed
+ * @group Implementation
+ * @category Serialization
+ */
+_MultiEd25519PublicKey.MIN_KEYS = 2;
+/**
+ * Minimum threshold for the number of valid signatures required
+ * @group Implementation
+ * @category Serialization
+ */
+_MultiEd25519PublicKey.MIN_THRESHOLD = 1;
+var MultiEd25519PublicKey = _MultiEd25519PublicKey;
+var _MultiEd25519Signature = class _MultiEd25519Signature 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.
+   * Alternatively, you can specify an array of bitmap positions.
+   * Valid position should range between 0 and 31.
+   * @see MultiEd25519Signature.createBitmap
+   * @group Implementation
+   * @category Serialization
+   */
+  constructor(args) {
+    super();
+    const { signatures, bitmap } = args;
+    if (signatures.length > _MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED) {
+      throw new Error(
+        `The number of signatures cannot be greater than ${_MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED}`
+      );
+    }
+    this.signatures = signatures;
+    if (!(bitmap instanceof Uint8Array)) {
+      this.bitmap = _MultiEd25519Signature.createBitmap({ bits: bitmap });
+    } else if (bitmap.length !== _MultiEd25519Signature.BITMAP_LEN) {
+      throw new Error(`"bitmap" length should be ${_MultiEd25519Signature.BITMAP_LEN}`);
+    } else {
+      this.bitmap = bitmap;
+    }
+  }
+  // region AccountSignature
+  /**
+   * Converts a MultiSignature into Uint8Array (bytes) with `bytes = s1_bytes | ... | sn_bytes | bitmap`
+   * @group Implementation
+   * @category Serialization
+   */
+  toUint8Array() {
+    const bytes = new Uint8Array(this.signatures.length * Ed25519Signature.LENGTH + _MultiEd25519Signature.BITMAP_LEN);
+    this.signatures.forEach((k, i) => {
+      bytes.set(k.toUint8Array(), i * Ed25519Signature.LENGTH);
+    });
+    bytes.set(this.bitmap, this.signatures.length * Ed25519Signature.LENGTH);
+    return bytes;
+  }
+  // endregion
+  // region Serializable
+  serialize(serializer) {
+    serializer.serializeBytes(this.toUint8Array());
+  }
+  static deserialize(deserializer) {
+    const bytes = deserializer.deserializeBytes();
+    const bitmap = bytes.subarray(bytes.length - 4);
+    const signatures = [];
+    for (let i = 0; i < bytes.length - bitmap.length; i += Ed25519Signature.LENGTH) {
+      const begin = i;
+      signatures.push(new Ed25519Signature(bytes.subarray(begin, begin + Ed25519Signature.LENGTH)));
+    }
+    return new _MultiEd25519Signature({ signatures, bitmap });
+  }
+  // endregion
+  /**
+   * Helper method to create a bitmap out of the specified bit positions.
+   * This function allows you to set specific bits in a 32-bit long bitmap based on the provided positions.
+   *
+   * @param args The arguments for creating the bitmap.
+   * @param args.bits The bitmap positions that should be set. A position starts at index 0. Valid positions 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 32 bits long.
+   * @group Implementation
+   * @category Serialization
+   */
+  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, index) => {
+      if (bit >= _MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED) {
+        throw new Error(`Cannot have a signature larger than ${_MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED - 1}.`);
+      }
+      if (dupCheckSet.has(bit)) {
+        throw new Error("Duplicate bits detected.");
+      }
+      if (index > 0 && bit <= bits[index - 1]) {
+        throw new Error("The bits need to be sorted in ascending order.");
+      }
+      dupCheckSet.add(bit);
+      const byteOffset = Math.floor(bit / 8);
+      let byte = bitmap[byteOffset];
+      byte |= firstBitInByte >> bit % 8;
+      bitmap[byteOffset] = byte;
+    });
+    return bitmap;
+  }
+};
+/**
+ * Maximum number of Ed25519 signatures supported
+ * @group Implementation
+ * @category Serialization
+ */
+_MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED = 32;
+/**
+ * Number of bytes in the bitmap representing who signed the transaction (32-bits)
+ * @group Implementation
+ * @category Serialization
+ */
+_MultiEd25519Signature.BITMAP_LEN = 4;
+var MultiEd25519Signature = _MultiEd25519Signature;
+
+export {
+  MultiEd25519PublicKey,
+  MultiEd25519Signature
+};
+//# sourceMappingURL=chunk-3TUV6YMI.mjs.map

package/dist/esm/chunk-3TUV6YMI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/crypto/multiEd25519.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Deserializer, Serializer } from \"../../bcs\";\nimport { SigningScheme as AuthenticationKeyScheme } from \"../../types\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { Ed25519PublicKey, Ed25519Signature } from \"./ed25519\";\nimport { AbstractMultiKey } from \"./multiKey\";\nimport { VerifySignatureArgs } from \"./publicKey\";\nimport { Signature } from \"./signature\";\n\n/**\n * Represents the public key of a K-of-N Ed25519 multi-sig transaction.\n *\n * A K-of-N multi-sig transaction requires at least K out of N authorized signers to sign the transaction\n * for it to be executed. This class encapsulates the logic for managing the public keys and the threshold\n * for valid signatures.\n *\n * @see {@link https://aptos.dev/integration/creating-a-signed-transaction/ | Creating a Signed Transaction}\n * @group Implementation\n * @category Serialization\n */\nexport class MultiEd25519PublicKey extends AbstractMultiKey {\n  /**\n   * Maximum number of public keys supported\n   * @group Implementation\n   * @category Serialization\n   */\n  static readonly MAX_KEYS = 32;\n\n  /**\n   * Minimum number of public keys needed\n   * @group Implementation\n   * @category Serialization\n   */\n  static readonly MIN_KEYS = 2;\n\n  /**\n   * Minimum threshold for the number of valid signatures required\n   * @group Implementation\n   * @category Serialization\n   */\n  static readonly MIN_THRESHOLD = 1;\n\n  /**\n   * List of Ed25519 public keys for this LegacyMultiEd25519PublicKey\n   * @group Implementation\n   * @category Serialization\n   */\n  public readonly publicKeys: Ed25519PublicKey[];\n\n  /**\n   * The minimum number of valid signatures required, for the number of public keys specified\n   * @group Implementation\n   * @category Serialization\n   */\n  public readonly threshold: number;\n\n  /**\n   * Public key for a K-of-N multi-sig transaction. A K-of-N multi-sig transaction means that for such a\n   * transaction to be executed, at least K out of the N authorized signers have signed the transaction\n   * and passed the check conducted by the chain.\n   *\n   * @see {@link\n   * https://aptos.dev/integration/creating-a-signed-transaction/ | Creating a Signed Transaction}\n   * @param args - A wrapper to let you choose the param order.\n   * @param args.publicKeys A list of public keys\n   * @param args.threshold At least \"threshold\" signatures must be valid\n   * @group Implementation\n   * @category Serialization\n   */\n  constructor(args: { publicKeys: Ed25519PublicKey[]; threshold: number }) {\n    const { publicKeys, threshold } = args;\n    super({ publicKeys });\n\n    // Validate number of public keys\n    if (publicKeys.length > MultiEd25519PublicKey.MAX_KEYS || publicKeys.length < MultiEd25519PublicKey.MIN_KEYS) {\n      throw new Error(\n        `Must have between ${MultiEd25519PublicKey.MIN_KEYS} and ` +\n          `${MultiEd25519PublicKey.MAX_KEYS} public keys, inclusive`,\n      );\n    }\n\n    // Validate threshold: must be between 1 and the number of public keys, inclusive\n    if (threshold < MultiEd25519PublicKey.MIN_THRESHOLD || threshold > publicKeys.length) {\n      throw new Error(\n        `Threshold must be between ${MultiEd25519PublicKey.MIN_THRESHOLD} and ${publicKeys.length}, inclusive`,\n      );\n    }\n\n    this.publicKeys = publicKeys;\n    this.threshold = threshold;\n  }\n\n  // region AccountPublicKey\n\n  /**\n   * Verifies a multi-signature against a given message.\n   * This function ensures that the provided signatures meet the required threshold and are valid for the given message.\n   *\n   * @param args - The arguments for verifying the signature.\n   * @param args.message - The message that was signed.\n   * @param args.signature - The multi-signature containing multiple signatures and a bitmap indicating which signatures are valid.\n   * @returns True if the signature is valid; otherwise, false.\n   * @throws Error if the bitmap and signatures length mismatch or if there are not enough valid signatures.\n   * @group Implementation\n   * @category Serialization\n   */\n  verifySignature(args: VerifySignatureArgs): boolean {\n    const { message, signature } = args;\n    if (!(signature instanceof MultiEd25519Signature)) {\n      return false;\n    }\n\n    const indices: number[] = [];\n    for (let i = 0; i < 4; i += 1) {\n      for (let j = 0; j < 8; j += 1) {\n        // eslint-disable-next-line no-bitwise\n        const bitIsSet = (signature.bitmap[i] & (1 << (7 - j))) !== 0;\n        if (bitIsSet) {\n          const index = i * 8 + j;\n          indices.push(index);\n        }\n      }\n    }\n\n    if (indices.length !== signature.signatures.length) {\n      throw new Error(\"Bitmap and signatures length mismatch\");\n    }\n\n    if (indices.length < this.threshold) {\n      throw new Error(\"Not enough signatures\");\n    }\n\n    for (let i = 0; i < indices.length; i += 1) {\n      const publicKey = this.publicKeys[indices[i]];\n      if (!publicKey.verifySignature({ message, signature: signature.signatures[i] })) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Generates an authentication key based on the current instance's byte representation.\n   * This function is essential for creating a secure authentication key that can be used for various cryptographic operations.\n   *\n   * @returns {AuthenticationKey} The generated authentication key.\n   * @group Implementation\n   * @category Serialization\n   */\n  authKey(): AuthenticationKey {\n    return AuthenticationKey.fromSchemeAndBytes({\n      scheme: AuthenticationKeyScheme.MultiEd25519,\n      input: this.toUint8Array(),\n    });\n  }\n\n  /**\n   * Converts a PublicKeys into Uint8Array (bytes) with: bytes = p1_bytes | ... | pn_bytes | threshold\n   * @group Implementation\n   * @category Serialization\n   */\n  toUint8Array(): Uint8Array {\n    const bytes = new Uint8Array(this.publicKeys.length * Ed25519PublicKey.LENGTH + 1);\n    this.publicKeys.forEach((k: Ed25519PublicKey, i: number) => {\n      bytes.set(k.toUint8Array(), i * Ed25519PublicKey.LENGTH);\n    });\n\n    bytes[this.publicKeys.length * Ed25519PublicKey.LENGTH] = this.threshold;\n\n    return bytes;\n  }\n\n  // endregion\n\n  // region Serializable\n\n  /**\n   * Serializes the current instance into bytes using the provided serializer.\n   * This allows for the conversion of the instance's data into a format suitable for transmission or storage.\n   *\n   * @param serializer - The serializer used to convert the instance into bytes.\n   * @group Implementation\n   * @category Serialization\n   */\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.toUint8Array());\n  }\n\n  /**\n   * Deserializes a MultiEd25519Signature from the provided deserializer.\n   * This function helps in reconstructing a MultiEd25519Signature object from its serialized byte representation.\n   *\n   * @param deserializer - The deserializer instance used to read the serialized data.\n   * @group Implementation\n   * @category Serialization\n   */\n  static deserialize(deserializer: Deserializer): MultiEd25519PublicKey {\n    const bytes = deserializer.deserializeBytes();\n    const threshold = bytes[bytes.length - 1];\n\n    const keys: Ed25519PublicKey[] = [];\n\n    for (let i = 0; i < bytes.length - 1; i += Ed25519PublicKey.LENGTH) {\n      const begin = i;\n      keys.push(new Ed25519PublicKey(bytes.subarray(begin, begin + Ed25519PublicKey.LENGTH)));\n    }\n    return new MultiEd25519PublicKey({ publicKeys: keys, threshold });\n  }\n\n  // endregion\n\n  /**\n   * Get the index of the provided public key.\n   *\n   * This function retrieves the index of a specified public key within the MultiKey.\n   * If the public key does not exist, it throws an error.\n   *\n   * @param publicKey - The public key to find the index for.\n   * @returns The corresponding index of the public key, if it exists.\n   * @throws Error - If the public key is not found in the MultiKey.\n   * @group Implementation\n   */\n  getIndex(publicKey: Ed25519PublicKey): number {\n    return super.getIndex(publicKey);\n  }\n}\n\n/**\n * Represents the signature of a K-of-N Ed25519 multi-sig transaction.\n *\n * @see {@link https://aptos.dev/integration/creating-a-signed-transaction/#multisignature-transactions | Creating a Signed Transaction}\n * @group Implementation\n * @category Serialization\n */\nexport class MultiEd25519Signature extends Signature {\n  /**\n   * Maximum number of Ed25519 signatures supported\n   * @group Implementation\n   * @category Serialization\n   */\n  static MAX_SIGNATURES_SUPPORTED = 32;\n\n  /**\n   * Number of bytes in the bitmap representing who signed the transaction (32-bits)\n   * @group Implementation\n   * @category Serialization\n   */\n  static BITMAP_LEN: number = 4;\n\n  /**\n   * The list of underlying Ed25519 signatures\n   * @group Implementation\n   * @category Serialization\n   */\n  public readonly signatures: Ed25519Signature[];\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   * @group Implementation\n   * @category Serialization\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   * Alternatively, you can specify an array of bitmap positions.\n   * Valid position should range between 0 and 31.\n   * @see MultiEd25519Signature.createBitmap\n   * @group Implementation\n   * @category Serialization\n   */\n  constructor(args: { signatures: Ed25519Signature[]; bitmap: Uint8Array | number[] }) {\n    super();\n    const { signatures, bitmap } = args;\n\n    if (signatures.length > MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED) {\n      throw new Error(\n        `The number of signatures cannot be greater than ${MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED}`,\n      );\n    }\n    this.signatures = signatures;\n\n    if (!(bitmap instanceof Uint8Array)) {\n      this.bitmap = MultiEd25519Signature.createBitmap({ bits: bitmap });\n    } else if (bitmap.length !== MultiEd25519Signature.BITMAP_LEN) {\n      throw new Error(`\"bitmap\" length should be ${MultiEd25519Signature.BITMAP_LEN}`);\n    } else {\n      this.bitmap = bitmap;\n    }\n  }\n\n  // region AccountSignature\n\n  /**\n   * Converts a MultiSignature into Uint8Array (bytes) with `bytes = s1_bytes | ... | sn_bytes | bitmap`\n   * @group Implementation\n   * @category Serialization\n   */\n  toUint8Array(): Uint8Array {\n    const bytes = new Uint8Array(this.signatures.length * Ed25519Signature.LENGTH + MultiEd25519Signature.BITMAP_LEN);\n    this.signatures.forEach((k: Ed25519Signature, i: number) => {\n      bytes.set(k.toUint8Array(), i * Ed25519Signature.LENGTH);\n    });\n\n    bytes.set(this.bitmap, this.signatures.length * Ed25519Signature.LENGTH);\n\n    return bytes;\n  }\n\n  // endregion\n\n  // region Serializable\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): MultiEd25519Signature {\n    const bytes = deserializer.deserializeBytes();\n    const bitmap = bytes.subarray(bytes.length - 4);\n\n    const signatures: Ed25519Signature[] = [];\n\n    for (let i = 0; i < bytes.length - bitmap.length; i += Ed25519Signature.LENGTH) {\n      const begin = i;\n      signatures.push(new Ed25519Signature(bytes.subarray(begin, begin + Ed25519Signature.LENGTH)));\n    }\n    return new MultiEd25519Signature({ signatures, bitmap });\n  }\n\n  // endregion\n\n  /**\n   * Helper method to create a bitmap out of the specified bit positions.\n   * This function allows you to set specific bits in a 32-bit long bitmap based on the provided positions.\n   *\n   * @param args The arguments for creating the bitmap.\n   * @param args.bits The bitmap positions that should be set. A position starts at index 0. Valid positions should range between 0 and 31.\n   *\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 32 bits long.\n   * @group Implementation\n   * @category Serialization\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, index) => {\n      if (bit >= MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED) {\n        throw new Error(`Cannot have a signature larger than ${MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED - 1}.`);\n      }\n\n      if (dupCheckSet.has(bit)) {\n        throw new Error(\"Duplicate bits detected.\");\n      }\n\n      if (index > 0 && bit <= bits[index - 1]) {\n        throw new Error(\"The bits need to be sorted in ascending order.\");\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"],"mappings":"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","names":[]}