@aptos-labs/ts-sdk 1.13.3 → 1.14.0-zeta.1

package/dist/esm/chunk-UKU6A2W2.mjs

@@ -0,0 +1,232 @@
+import {
+  Ed25519PublicKey,
+  Ed25519Signature
+} from "./chunk-RX4VG2AT.mjs";
+import {
+  Signature
+} from "./chunk-FDWJNY4U.mjs";
+import {
+  AccountPublicKey
+} from "./chunk-FXKSE3ZP.mjs";
+import {
+  AuthenticationKey
+} from "./chunk-UEBBLQJ5.mjs";
+
+// src/core/crypto/multiEd25519.ts
+var _MultiEd25519PublicKey = class _MultiEd25519PublicKey extends AccountPublicKey {
+  /**
+   * 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.publicKeys A list of public keys
+   * @param args.threshold At least "threshold" signatures must be valid
+   */
+  constructor(args) {
+    super();
+    const { publicKeys, threshold } = args;
+    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
+  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;
+  }
+  authKey() {
+    return AuthenticationKey.fromSchemeAndBytes({
+      scheme: 1 /* MultiEd25519 */,
+      input: this.toUint8Array()
+    });
+  }
+  /**
+   * Converts a PublicKeys into Uint8Array (bytes) with: bytes = p1_bytes | ... | pn_bytes | threshold
+   */
+  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
+  serialize(serializer) {
+    serializer.serializeBytes(this.toUint8Array());
+  }
+  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
+};
+/**
+ * Maximum number of public keys supported
+ */
+_MultiEd25519PublicKey.MAX_KEYS = 32;
+/**
+ * Minimum number of public keys needed
+ */
+_MultiEd25519PublicKey.MIN_KEYS = 2;
+/**
+ * Minimum threshold for the number of valid signatures required
+ */
+_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
+   */
+  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`
+   */
+  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
+   * @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, 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
+ */
+_MultiEd25519Signature.MAX_SIGNATURES_SUPPORTED = 32;
+/**
+ * Number of bytes in the bitmap representing who signed the transaction (32-bits)
+ */
+_MultiEd25519Signature.BITMAP_LEN = 4;
+var MultiEd25519Signature = _MultiEd25519Signature;
+
+export {
+  MultiEd25519PublicKey,
+  MultiEd25519Signature
+};
+//# sourceMappingURL=chunk-UKU6A2W2.mjs.map

package/dist/esm/{chunk-XO3HHRJV.mjs.map → chunk-UKU6A2W2.mjs.map}

@@ -1 +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 { AccountPublicKey, VerifySignatureArgs } from \"./publicKey\";\nimport { Signature } from \"./signature\";\n\n/**\n * Represents the public key of a K-of-N Ed25519 multi-sig transaction.\n */\nexport class MultiEd25519PublicKey extends AccountPublicKey {\n  /**\n   * Maximum number of public keys supported\n   */\n  static readonly MAX_KEYS = 32;\n\n  /**\n   * Minimum number of public keys needed\n   */\n  static readonly MIN_KEYS = 2;\n\n  /**\n   * Minimum threshold for the number of valid signatures required\n   */\n  static readonly MIN_THRESHOLD = 1;\n\n  /**\n   * List of Ed25519 public keys for this LegacyMultiEd25519PublicKey\n   */\n  public readonly publicKeys: Ed25519PublicKey[];\n\n  /**\n   * The minimum number of valid signatures required, for the number of public keys specified\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   *\n   * @param args.publicKeys A list of public keys\n   * @param args.threshold At least \"threshold\" signatures must be valid\n   */\n  constructor(args: { publicKeys: Ed25519PublicKey[]; threshold: number }) {\n    super();\n    const { publicKeys, threshold } = args;\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  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  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   */\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  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.toUint8Array());\n  }\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/**\n * Represents the signature of a K-of-N Ed25519 multi-sig transaction.\n */\nexport class MultiEd25519Signature extends Signature {\n  /**\n   * Maximum number of Ed25519 signatures supported\n   */\n  static MAX_SIGNATURES_SUPPORTED = 32;\n\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   * The list of underlying Ed25519 signatures\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   */\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   */\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   */\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   * @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, 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":["_MultiEd25519PublicKey","AccountPublicKey","args","publicKeys","threshold","message","signature","MultiEd25519Signature","indices","j","index","AuthenticationKey","bytes","Ed25519PublicKey","k","i","serializer","deserializer","keys","begin","MultiEd25519PublicKey","_MultiEd25519Signature","Signature","signatures","bitmap","Ed25519Signature","bits","firstBitInByte","dupCheckSet","bit","byteOffset","byte"]}
+{"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 { AccountPublicKey, VerifySignatureArgs } from \"./publicKey\";\nimport { Signature } from \"./signature\";\n\n/**\n * Represents the public key of a K-of-N Ed25519 multi-sig transaction.\n */\nexport class MultiEd25519PublicKey extends AccountPublicKey {\n  /**\n   * Maximum number of public keys supported\n   */\n  static readonly MAX_KEYS = 32;\n\n  /**\n   * Minimum number of public keys needed\n   */\n  static readonly MIN_KEYS = 2;\n\n  /**\n   * Minimum threshold for the number of valid signatures required\n   */\n  static readonly MIN_THRESHOLD = 1;\n\n  /**\n   * List of Ed25519 public keys for this LegacyMultiEd25519PublicKey\n   */\n  public readonly publicKeys: Ed25519PublicKey[];\n\n  /**\n   * The minimum number of valid signatures required, for the number of public keys specified\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   *\n   * @param args.publicKeys A list of public keys\n   * @param args.threshold At least \"threshold\" signatures must be valid\n   */\n  constructor(args: { publicKeys: Ed25519PublicKey[]; threshold: number }) {\n    super();\n    const { publicKeys, threshold } = args;\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  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  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   */\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  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.toUint8Array());\n  }\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/**\n * Represents the signature of a K-of-N Ed25519 multi-sig transaction.\n */\nexport class MultiEd25519Signature extends Signature {\n  /**\n   * Maximum number of Ed25519 signatures supported\n   */\n  static MAX_SIGNATURES_SUPPORTED = 32;\n\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   * The list of underlying Ed25519 signatures\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   */\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   */\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   */\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   * @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, 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":[]}

package/dist/esm/chunk-UX5NSZEN.mjs

@@ -0,0 +1,134 @@
+import {
+  getCurrentFungibleAssetBalances,
+  getFungibleAssetActivities,
+  getFungibleAssetMetadata,
+  transferFungibleAsset
+} from "./chunk-NYL77J4X.mjs";
+import {
+  waitForIndexerOnVersion
+} from "./chunk-CC4DQ6NH.mjs";
+
+// src/api/fungibleAsset.ts
+var FungibleAsset = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Queries all fungible asset metadata.
+   *
+   * @example
+   * const fungibleAsset = await aptos.getFungibleAssetMetadata()
+   *
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+   * @param args.options Optional configuration for pagination and filtering
+   *
+   * @returns A list of fungible asset metadata
+   */
+  async getFungibleAssetMetadata(args) {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorType: "fungible_asset_processor" /* FUNGIBLE_ASSET_PROCESSOR */
+    });
+    return getFungibleAssetMetadata({ aptosConfig: this.config, ...args });
+  }
+  /**
+   * Queries a fungible asset metadata
+   *
+   * This query returns the fungible asset metadata for a specific fungible asset.
+   *
+   * @example
+   * const fungibleAsset = await aptos.getFungibleAssetMetadataByAssetType({assetType:"0x123::test_coin::TestCoin"})
+   *
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+   * @param args.assetType The asset type of the fungible asset.
+   * e.g
+   * "0x1::aptos_coin::AptosCoin" for Aptos Coin
+   * "0xc2948283c2ce03aafbb294821de7ee684b06116bb378ab614fa2de07a99355a8" - address format if this is fungible asset
+   *
+   * @returns A fungible asset metadata item
+   */
+  async getFungibleAssetMetadataByAssetType(args) {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorType: "fungible_asset_processor" /* FUNGIBLE_ASSET_PROCESSOR */
+    });
+    const data = await getFungibleAssetMetadata({
+      aptosConfig: this.config,
+      options: {
+        where: {
+          asset_type: { _eq: args.assetType }
+        }
+      }
+    });
+    return data[0];
+  }
+  /**
+   * Queries all fungible asset activities
+   *
+   * @example
+   * const fungibleAssetActivities = await aptos.getFungibleAssetActivities()
+   *
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+   * @param args.options Optional configuration for pagination and filtering
+   *
+   * @returns A list of fungible asset metadata
+   */
+  async getFungibleAssetActivities(args) {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorType: "fungible_asset_processor" /* FUNGIBLE_ASSET_PROCESSOR */
+    });
+    return getFungibleAssetActivities({ aptosConfig: this.config, ...args });
+  }
+  /**
+   * Queries all fungible asset balances
+   *
+   * @example
+   * const fungibleAssetBalances = await aptos.getCurrentFungibleAssetBalances()
+   *
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+   * @param args.options Optional configuration for pagination and filtering
+   *
+   * @returns A list of fungible asset metadata
+   */
+  async getCurrentFungibleAssetBalances(args) {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args?.minimumLedgerVersion,
+      processorType: "fungible_asset_processor" /* FUNGIBLE_ASSET_PROCESSOR */
+    });
+    return getCurrentFungibleAssetBalances({ aptosConfig: this.config, ...args });
+  }
+  /**
+   * Transfer `amount` of fungible asset from sender's primary store to recipient's primary store.
+   *
+   * Use this method to transfer any fungible asset including fungible token.
+   *
+   * @example
+   * const transaction = await aptos.transferFungibleAsset({
+   *  sender: alice,
+   *  fungibleAssetMetadataAddress: "0x123",
+   *  recipient: "0x456",
+   *  amount: 5
+   * })
+   *
+   * @param sender The sender account
+   * @param fungibleAssetMetadataAddress The fungible asset account address.
+   * For example if you’re transferring USDT this would be the USDT address
+   * @param recipient The recipient account address
+   * @param amount Number of assets to transfer
+   *
+   * @returns A SimpleTransaction that can be simulated or submitted to chain.
+   */
+  async transferFungibleAsset(args) {
+    return transferFungibleAsset({ aptosConfig: this.config, ...args });
+  }
+};
+
+export {
+  FungibleAsset
+};
+//# sourceMappingURL=chunk-UX5NSZEN.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api/fungibleAsset.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  AnyNumber,\n  GetCurrentFungibleAssetBalancesResponse,\n  GetFungibleAssetActivitiesResponse,\n  GetFungibleAssetMetadataResponse,\n  PaginationArgs,\n  WhereArg,\n} from \"../types\";\nimport {\n  getCurrentFungibleAssetBalances,\n  getFungibleAssetActivities,\n  getFungibleAssetMetadata,\n  transferFungibleAsset,\n} from \"../internal/fungibleAsset\";\nimport {\n  CurrentFungibleAssetBalancesBoolExp,\n  FungibleAssetActivitiesBoolExp,\n  FungibleAssetMetadataBoolExp,\n} from \"../types/generated/types\";\nimport { ProcessorType } from \"../utils/const\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { waitForIndexerOnVersion } from \"./utils\";\nimport { Account } from \"../account\";\nimport { AccountAddressInput } from \"../core\";\nimport { InputGenerateTransactionOptions } from \"../transactions\";\nimport { SimpleTransaction } from \"../transactions/instances/simpleTransaction\";\n\n/**\n * A class to query all `FungibleAsset` related queries on Aptos.\n */\nexport class FungibleAsset {\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Queries all fungible asset metadata.\n   *\n   * @example\n   * const fungibleAsset = await aptos.getFungibleAssetMetadata()\n   *\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options Optional configuration for pagination and filtering\n   *\n   * @returns A list of fungible asset metadata\n   */\n  async getFungibleAssetMetadata(args?: {\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & WhereArg<FungibleAssetMetadataBoolExp>;\n  }): Promise<GetFungibleAssetMetadataResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args?.minimumLedgerVersion,\n      processorType: ProcessorType.FUNGIBLE_ASSET_PROCESSOR,\n    });\n    return getFungibleAssetMetadata({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries a fungible asset metadata\n   *\n   * This query returns the fungible asset metadata for a specific fungible asset.\n   *\n   * @example\n   * const fungibleAsset = await aptos.getFungibleAssetMetadataByAssetType({assetType:\"0x123::test_coin::TestCoin\"})\n   *\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.assetType The asset type of the fungible asset.\n   * e.g\n   * \"0x1::aptos_coin::AptosCoin\" for Aptos Coin\n   * \"0xc2948283c2ce03aafbb294821de7ee684b06116bb378ab614fa2de07a99355a8\" - address format if this is fungible asset\n   *\n   * @returns A fungible asset metadata item\n   */\n  async getFungibleAssetMetadataByAssetType(args: {\n    assetType: string;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<GetFungibleAssetMetadataResponse[0]> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args?.minimumLedgerVersion,\n      processorType: ProcessorType.FUNGIBLE_ASSET_PROCESSOR,\n    });\n    const data = await getFungibleAssetMetadata({\n      aptosConfig: this.config,\n      options: {\n        where: {\n          asset_type: { _eq: args.assetType },\n        },\n      },\n    });\n\n    return data[0];\n  }\n\n  /**\n   * Queries all fungible asset activities\n   *\n   * @example\n   * const fungibleAssetActivities = await aptos.getFungibleAssetActivities()\n   *\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options Optional configuration for pagination and filtering\n   *\n   * @returns A list of fungible asset metadata\n   */\n  async getFungibleAssetActivities(args?: {\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & WhereArg<FungibleAssetActivitiesBoolExp>;\n  }): Promise<GetFungibleAssetActivitiesResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args?.minimumLedgerVersion,\n      processorType: ProcessorType.FUNGIBLE_ASSET_PROCESSOR,\n    });\n    return getFungibleAssetActivities({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries all fungible asset balances\n   *\n   * @example\n   * const fungibleAssetBalances = await aptos.getCurrentFungibleAssetBalances()\n   *\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options Optional configuration for pagination and filtering\n   *\n   * @returns A list of fungible asset metadata\n   */\n  async getCurrentFungibleAssetBalances(args?: {\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & WhereArg<CurrentFungibleAssetBalancesBoolExp>;\n  }): Promise<GetCurrentFungibleAssetBalancesResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args?.minimumLedgerVersion,\n      processorType: ProcessorType.FUNGIBLE_ASSET_PROCESSOR,\n    });\n    return getCurrentFungibleAssetBalances({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Transfer `amount` of fungible asset from sender's primary store to recipient's primary store.\n   *\n   * Use this method to transfer any fungible asset including fungible token.\n   *\n   * @example\n   * const transaction = await aptos.transferFungibleAsset({\n   *  sender: alice,\n   *  fungibleAssetMetadataAddress: \"0x123\",\n   *  recipient: \"0x456\",\n   *  amount: 5\n   * })\n   *\n   * @param sender The sender account\n   * @param fungibleAssetMetadataAddress The fungible asset account address.\n   * For example if you’re transferring USDT this would be the USDT address\n   * @param recipient The recipient account address\n   * @param amount Number of assets to transfer\n   *\n   * @returns A SimpleTransaction that can be simulated or submitted to chain.\n   */\n  async transferFungibleAsset(args: {\n    sender: Account;\n    fungibleAssetMetadataAddress: AccountAddressInput;\n    recipient: AccountAddressInput;\n    amount: AnyNumber;\n    options?: InputGenerateTransactionOptions;\n  }): Promise<SimpleTransaction> {\n    return transferFungibleAsset({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":";;;;;;;;;;;AAiCO,IAAM,gBAAN,MAAoB;AAAA,EACzB,YAAqB,QAAqB;AAArB;AAAA,EAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAa3C,MAAM,yBAAyB,MAGe;AAC5C,UAAM,wBAAwB;AAAA,MAC5B,QAAQ,KAAK;AAAA,MACb,sBAAsB,MAAM;AAAA,MAC5B;AAAA,IACF,CAAC;AACD,WAAO,yBAAyB,EAAE,aAAa,KAAK,QAAQ,GAAG,KAAK,CAAC;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,MAAM,oCAAoC,MAGO;AAC/C,UAAM,wBAAwB;AAAA,MAC5B,QAAQ,KAAK;AAAA,MACb,sBAAsB,MAAM;AAAA,MAC5B;AAAA,IACF,CAAC;AACD,UAAM,OAAO,MAAM,yBAAyB;AAAA,MAC1C,aAAa,KAAK;AAAA,MAClB,SAAS;AAAA,QACP,OAAO;AAAA,UACL,YAAY,EAAE,KAAK,KAAK,UAAU;AAAA,QACpC;AAAA,MACF;AAAA,IACF,CAAC;AAED,WAAO,KAAK,CAAC;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,MAAM,2BAA2B,MAGe;AAC9C,UAAM,wBAAwB;AAAA,MAC5B,QAAQ,KAAK;AAAA,MACb,sBAAsB,MAAM;AAAA,MAC5B;AAAA,IACF,CAAC;AACD,WAAO,2BAA2B,EAAE,aAAa,KAAK,QAAQ,GAAG,KAAK,CAAC;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,MAAM,gCAAgC,MAGe;AACnD,UAAM,wBAAwB;AAAA,MAC5B,QAAQ,KAAK;AAAA,MACb,sBAAsB,MAAM;AAAA,MAC5B;AAAA,IACF,CAAC;AACD,WAAO,gCAAgC,EAAE,aAAa,KAAK,QAAQ,GAAG,KAAK,CAAC;AAAA,EAC9E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuBA,MAAM,sBAAsB,MAMG;AAC7B,WAAO,sBAAsB,EAAE,aAAa,KAAK,QAAQ,GAAG,KAAK,CAAC;AAAA,EACpE;AACF;","names":[]}

package/dist/esm/chunk-VDJBDX3A.mjs

@@ -0,0 +1,79 @@
+import {
+  Ed25519Account
+} from "./chunk-KMXSRHJ6.mjs";
+import {
+  SingleKeyAccount
+} from "./chunk-JHDHNGJ3.mjs";
+import {
+  Ed25519PrivateKey
+} from "./chunk-RX4VG2AT.mjs";
+
+// src/account/Account.ts
+var Account = class {
+  static generate(args = {}) {
+    const { scheme = 0 /* Ed25519 */, legacy = true } = args;
+    if (scheme === 0 /* Ed25519 */ && legacy) {
+      return Ed25519Account.generate();
+    }
+    return SingleKeyAccount.generate({ scheme });
+  }
+  static fromPrivateKey(args) {
+    const { privateKey, address, legacy = true } = args;
+    if (privateKey instanceof Ed25519PrivateKey && legacy) {
+      return new Ed25519Account({
+        privateKey,
+        address
+      });
+    }
+    return new SingleKeyAccount({ privateKey, address });
+  }
+  /**
+   * @deprecated use `fromPrivateKey` instead.
+   * Instantiates an account given a private key and a specified account address.
+   * This is primarily used to instantiate an `Account` that has had its authentication key rotated.
+   *
+   * @param args.privateKey PrivateKey - the underlying private key for the account
+   * @param args.address AccountAddress - The account address the `Account` will sign for
+   * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
+   * to generating a Legacy Ed25519 keypair
+   *
+   * @returns Account
+   */
+  static fromPrivateKeyAndAddress(args) {
+    return this.fromPrivateKey(args);
+  }
+  static fromDerivationPath(args) {
+    const { scheme = 0 /* Ed25519 */, mnemonic, path, legacy = true } = args;
+    if (scheme === 0 /* Ed25519 */ && legacy) {
+      return Ed25519Account.fromDerivationPath({ mnemonic, path });
+    }
+    return SingleKeyAccount.fromDerivationPath({ scheme, mnemonic, path });
+  }
+  /**
+   * @deprecated use `publicKey.authKey()` instead.
+   * This key enables account owners to rotate their private key(s)
+   * associated with the account without changing the address that hosts their account.
+   * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}
+   *
+   * @param args.publicKey PublicKey - public key of the account
+   * @returns The authentication key for the associated account
+   */
+  static authKey(args) {
+    const { publicKey } = args;
+    return publicKey.authKey();
+  }
+  /**
+   * Verify the given message and signature with the public key.
+   * @param args.message raw message data in HexInput format
+   * @param args.signature signed message Signature
+   * @returns
+   */
+  verifySignature(args) {
+    return this.publicKey.verifySignature(args);
+  }
+};
+
+export {
+  Account
+};
+//# sourceMappingURL=chunk-VDJBDX3A.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/account/Account.ts"],"sourcesContent":["import type { AccountAuthenticator } from \"../transactions/authenticator/account\";\nimport { HexInput, SigningScheme, SigningSchemeInput } from \"../types\";\nimport type { AccountAddress, AccountAddressInput } from \"../core/accountAddress\";\nimport { AuthenticationKey } from \"../core/authenticationKey\";\nimport { AccountPublicKey, Ed25519PrivateKey, PrivateKey, Signature, VerifySignatureArgs } from \"../core/crypto\";\nimport { Ed25519Account } from \"./Ed25519Account\";\nimport { SingleKeyAccount } from \"./SingleKeyAccount\";\nimport { AnyRawTransaction } from \"../transactions/types\";\n\n/**\n * Arguments for creating an `Ed25519Account` from an `Ed25519PrivateKey`.\n * This is the default input type when passing an `Ed25519PrivateKey`.\n * In order to use the SingleKey authentication scheme, `legacy` needs to be explicitly set to false.\n */\nexport interface CreateEd25519AccountFromPrivateKeyArgs {\n  privateKey: Ed25519PrivateKey;\n  address?: AccountAddressInput;\n  legacy?: true;\n}\n\n/**\n * Arguments for creating an `SingleKeyAccount` from an `Ed25519PrivateKey`.\n * The `legacy` argument needs to be explicitly set to false in order to\n * use the `SingleKey` authentication scheme.\n */\nexport interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs {\n  privateKey: Ed25519PrivateKey;\n  address?: AccountAddressInput;\n  legacy: false;\n}\n\n/**\n * Arguments for creating an `SingleKeyAccount` from any supported private key\n * that is not an `Ed25519PrivateKey`.\n * The `legacy` argument defaults to false and cannot be explicitly set to true.\n */\nexport interface CreateSingleKeyAccountFromPrivateKeyArgs {\n  privateKey: Exclude<PrivateKey, Ed25519PrivateKey>;\n  address?: AccountAddressInput;\n  legacy?: false;\n}\n\n/**\n * Arguments for creating an opaque `Account` from any supported private key.\n * This is used when the private key type is not known at compilation time.\n */\nexport interface CreateAccountFromPrivateKeyArgs {\n  privateKey: PrivateKey;\n  address?: AccountAddressInput;\n  legacy?: boolean;\n}\n\n/**\n * Arguments for generating an `Ed25519Account`.\n * This is the input type used by default.\n */\nexport interface GenerateEd25519AccountArgs {\n  scheme?: SigningSchemeInput.Ed25519;\n  legacy?: true;\n}\n\n/**\n * Arguments for generating an `SingleKeyAccount` with ah underlying `Ed25519PrivateKey`.\n * The `legacy` argument needs to be explicitly set to false,\n * otherwise an `Ed25519Account` will be returned instead.\n */\nexport interface GenerateEd25519SingleKeyAccountArgs {\n  scheme?: SigningSchemeInput.Ed25519;\n  legacy: false;\n}\n\n/**\n * Arguments for generating an `SingleKeyAccount` with any supported private key\n * that is not an `Ed25519PrivateKey`.\n * The `legacy` argument defaults to false and cannot be explicitly set to true.\n */\nexport interface GenerateSingleKeyAccountArgs {\n  scheme: Exclude<SigningSchemeInput, SigningSchemeInput.Ed25519>;\n  legacy?: false;\n}\n\n/**\n * Arguments for generating an opaque `Account`.\n * This is used when the input signature scheme is not known at compilation time.\n */\nexport interface GenerateAccountArgs {\n  scheme?: SigningSchemeInput;\n  legacy?: boolean;\n}\n\n/**\n * Arguments for deriving a private key from a mnemonic phrase and a BIP44 path.\n */\nexport interface PrivateKeyFromDerivationPathArgs {\n  path: string;\n  mnemonic: string;\n}\n\n/**\n * Interface for a generic Aptos account.\n *\n * The interface is defined as abstract class to provide a single entrypoint for account generation,\n * either through `Account.generate()` or `Account.fromDerivationPath`.\n * Despite this being an abstract class, it should be treated as an interface and enforced using\n * the `implements` keyword.\n *\n * Note: Generating an account instance does not create the account on-chain.\n */\nexport abstract class Account {\n  /**\n   * Public key associated with the account\n   */\n  abstract readonly publicKey: AccountPublicKey;\n\n  /**\n   * Account address associated with the account\n   */\n  abstract readonly accountAddress: AccountAddress;\n\n  /**\n   * Signing scheme used to sign transactions\n   */\n  abstract signingScheme: SigningScheme;\n\n  /**\n   * Derives an account from a randomly generated private key.\n   * @param args.scheme The signature scheme to use, to generate the private key\n   * @param args.legacy Whether to use a legacy authentication scheme, when applicable\n   * @returns An account compatible with the provided signature scheme\n   */\n  static generate(args?: GenerateEd25519AccountArgs): Ed25519Account;\n  static generate(args: GenerateEd25519SingleKeyAccountArgs): SingleKeyAccount;\n  static generate(args: GenerateSingleKeyAccountArgs): SingleKeyAccount;\n  static generate(args: GenerateAccountArgs): Account;\n  static generate(args: GenerateAccountArgs = {}) {\n    const { scheme = SigningSchemeInput.Ed25519, legacy = true } = args;\n    if (scheme === SigningSchemeInput.Ed25519 && legacy) {\n      return Ed25519Account.generate();\n    }\n    return SingleKeyAccount.generate({ scheme });\n  }\n\n  /**\n   * Creates an account from the provided private key.\n   *\n   * @param args.privateKey a valid private key\n   * @param args.address the account's address. If not provided, it will be derived from the public key.\n   * @param args.legacy Whether to use a legacy authentication scheme, when applicable\n   */\n  static fromPrivateKey(args: CreateEd25519AccountFromPrivateKeyArgs): Ed25519Account;\n  static fromPrivateKey(args: CreateEd25519SingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;\n  static fromPrivateKey(args: CreateSingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;\n  static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs): Account;\n  static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs) {\n    const { privateKey, address, legacy = true } = args;\n    if (privateKey instanceof Ed25519PrivateKey && legacy) {\n      return new Ed25519Account({\n        privateKey,\n        address,\n      });\n    }\n    return new SingleKeyAccount({ privateKey, address });\n  }\n\n  /**\n   * @deprecated use `fromPrivateKey` instead.\n   * Instantiates an account given a private key and a specified account address.\n   * This is primarily used to instantiate an `Account` that has had its authentication key rotated.\n   *\n   * @param args.privateKey PrivateKey - the underlying private key for the account\n   * @param args.address AccountAddress - The account address the `Account` will sign for\n   * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults\n   * to generating a Legacy Ed25519 keypair\n   *\n   * @returns Account\n   */\n  static fromPrivateKeyAndAddress(args: CreateAccountFromPrivateKeyArgs) {\n    return this.fromPrivateKey(args);\n  }\n\n  /**\n   * Derives an account with bip44 path and mnemonics\n   *\n   * @param args.scheme The signature scheme to derive the private key with\n   * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,\n   * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1\n   * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}\n   * @param args.mnemonic the mnemonic seed phrase of the account\n   */\n  static fromDerivationPath(args: GenerateEd25519AccountArgs & PrivateKeyFromDerivationPathArgs): Ed25519Account;\n  static fromDerivationPath(\n    args: GenerateEd25519SingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs,\n  ): SingleKeyAccount;\n  static fromDerivationPath(args: GenerateSingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;\n  static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs): Account;\n  static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs) {\n    const { scheme = SigningSchemeInput.Ed25519, mnemonic, path, legacy = true } = args;\n    if (scheme === SigningSchemeInput.Ed25519 && legacy) {\n      return Ed25519Account.fromDerivationPath({ mnemonic, path });\n    }\n    return SingleKeyAccount.fromDerivationPath({ scheme, mnemonic, path });\n  }\n\n  /**\n   * @deprecated use `publicKey.authKey()` instead.\n   * This key enables account owners to rotate their private key(s)\n   * associated with the account without changing the address that hosts their account.\n   * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}\n   *\n   * @param args.publicKey PublicKey - public key of the account\n   * @returns The authentication key for the associated account\n   */\n  static authKey(args: { publicKey: AccountPublicKey }): AuthenticationKey {\n    const { publicKey } = args;\n    return publicKey.authKey();\n  }\n\n  /**\n   * Sign a message using the available signing capabilities.\n   * @param message the signing message, as binary input\n   * @return the AccountAuthenticator containing the signature, together with the account's public key\n   */\n  abstract signWithAuthenticator(message: HexInput): AccountAuthenticator;\n\n  /**\n   * Sign a transaction using the available signing capabilities.\n   * @param transaction the raw transaction\n   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key\n   */\n  abstract signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticator;\n\n  /**\n   * Sign the given message using the available signing capabilities.\n   * @param message in HexInput format\n   * @returns Signature\n   */\n  abstract sign(message: HexInput): Signature;\n\n  /**\n   * Sign the given transaction using the available signing capabilities.\n   * @param transaction the transaction to be signed\n   * @returns Signature\n   */\n  abstract signTransaction(transaction: AnyRawTransaction): Signature;\n\n  /**\n   * Verify the given message and signature with the public key.\n   * @param args.message raw message data in HexInput format\n   * @param args.signature signed message Signature\n   * @returns\n   */\n  verifySignature(args: VerifySignatureArgs): boolean {\n    return this.publicKey.verifySignature(args);\n  }\n}\n"],"mappings":";;;;;;;;;;;AA4GO,IAAe,UAAf,MAAuB;AAAA,EA0B5B,OAAO,SAAS,OAA4B,CAAC,GAAG;AAC9C,UAAM,EAAE,0BAAqC,SAAS,KAAK,IAAI;AAC/D,QAAI,8BAAyC,QAAQ;AACnD,aAAO,eAAe,SAAS;AAAA,IACjC;AACA,WAAO,iBAAiB,SAAS,EAAE,OAAO,CAAC;AAAA,EAC7C;AAAA,EAaA,OAAO,eAAe,MAAuC;AAC3D,UAAM,EAAE,YAAY,SAAS,SAAS,KAAK,IAAI;AAC/C,QAAI,sBAAsB,qBAAqB,QAAQ;AACrD,aAAO,IAAI,eAAe;AAAA,QACxB;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH;AACA,WAAO,IAAI,iBAAiB,EAAE,YAAY,QAAQ,CAAC;AAAA,EACrD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,OAAO,yBAAyB,MAAuC;AACrE,WAAO,KAAK,eAAe,IAAI;AAAA,EACjC;AAAA,EAiBA,OAAO,mBAAmB,MAA8D;AACtF,UAAM,EAAE,0BAAqC,UAAU,MAAM,SAAS,KAAK,IAAI;AAC/E,QAAI,8BAAyC,QAAQ;AACnD,aAAO,eAAe,mBAAmB,EAAE,UAAU,KAAK,CAAC;AAAA,IAC7D;AACA,WAAO,iBAAiB,mBAAmB,EAAE,QAAQ,UAAU,KAAK,CAAC;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,OAAO,QAAQ,MAA0D;AACvE,UAAM,EAAE,UAAU,IAAI;AACtB,WAAO,UAAU,QAAQ;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoCA,gBAAgB,MAAoC;AAClD,WAAO,KAAK,UAAU,gBAAgB,IAAI;AAAA,EAC5C;AACF;","names":[]}

package/dist/esm/chunk-VJP2VWMF.mjs

@@ -0,0 +1,58 @@
+import {
+  FeePayerRawTransaction,
+  MultiAgentRawTransaction
+} from "./chunk-2OQW7BMN.mjs";
+import {
+  RAW_TRANSACTION_SALT,
+  RAW_TRANSACTION_WITH_DATA_SALT
+} from "./chunk-NFJCQRVK.mjs";
+
+// src/transactions/transactionBuilder/signingMessage.ts
+import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
+function deriveTransactionType(transaction) {
+  if (transaction.feePayerAddress) {
+    return new FeePayerRawTransaction(
+      transaction.rawTransaction,
+      transaction.secondarySignerAddresses ?? [],
+      transaction.feePayerAddress
+    );
+  }
+  if (transaction.secondarySignerAddresses) {
+    return new MultiAgentRawTransaction(transaction.rawTransaction, transaction.secondarySignerAddresses);
+  }
+  return transaction.rawTransaction;
+}
+function generateSigningMessage(bytes, domainSeparator) {
+  const hash = sha3Hash.create();
+  if (!domainSeparator.startsWith("APTOS::")) {
+    throw new Error(`Domain separator needs to start with 'APTOS::'.  Provided - ${domainSeparator}`);
+  }
+  hash.update(domainSeparator);
+  const prefix = hash.digest();
+  const body = bytes;
+  const mergedArray = new Uint8Array(prefix.length + body.length);
+  mergedArray.set(prefix);
+  mergedArray.set(body, prefix.length);
+  return mergedArray;
+}
+function generateSigningMessageForSerializable(serializable) {
+  return generateSigningMessage(serializable.bcsToBytes(), `APTOS::${serializable.constructor.name}`);
+}
+function generateSigningMessageForTransaction(transaction) {
+  const rawTxn = deriveTransactionType(transaction);
+  if (transaction.feePayerAddress) {
+    return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_WITH_DATA_SALT);
+  }
+  if (transaction.secondarySignerAddresses) {
+    return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_WITH_DATA_SALT);
+  }
+  return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_SALT);
+}
+
+export {
+  deriveTransactionType,
+  generateSigningMessage,
+  generateSigningMessageForSerializable,
+  generateSigningMessageForTransaction
+};
+//# sourceMappingURL=chunk-VJP2VWMF.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/transactionBuilder/signingMessage.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file handles the generation of the signing message.\n */\nimport { sha3_256 as sha3Hash } from \"@noble/hashes/sha3\";\nimport { RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT } from \"../../utils/const\";\nimport { FeePayerRawTransaction, MultiAgentRawTransaction } from \"../instances\";\nimport { AnyRawTransaction, AnyRawTransactionInstance } from \"../types\";\nimport { Serializable } from \"../../bcs\";\n\n/**\n * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction\n *\n * @param transaction A aptos transaction type\n *\n * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction\n */\nexport function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance {\n  if (transaction.feePayerAddress) {\n    return new FeePayerRawTransaction(\n      transaction.rawTransaction,\n      transaction.secondarySignerAddresses ?? [],\n      transaction.feePayerAddress,\n    );\n  }\n  if (transaction.secondarySignerAddresses) {\n    return new MultiAgentRawTransaction(transaction.rawTransaction, transaction.secondarySignerAddresses);\n  }\n\n  return transaction.rawTransaction;\n}\n\n/**\n * Generates the 'signing message' form of a message to be signed.\n *\n * @param bytes The byte representation of the message to be signed and sent to the chain\n * @param domainSeparator A domain separator that starts with 'APTOS::'\n *\n * @returns The Uint8Array of the signing message\n */\nexport function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array {\n  const hash = sha3Hash.create();\n\n  if (!domainSeparator.startsWith(\"APTOS::\")) {\n    throw new Error(`Domain separator needs to start with 'APTOS::'.  Provided - ${domainSeparator}`);\n  }\n\n  hash.update(domainSeparator);\n\n  const prefix = hash.digest();\n\n  const body = bytes;\n\n  const mergedArray = new Uint8Array(prefix.length + body.length);\n  mergedArray.set(prefix);\n  mergedArray.set(body, prefix.length);\n\n  return mergedArray;\n}\n\n/**\n * Generates the 'signing message' form of a serilizable value. It bcs serializes the value and uses the name of\n * its constructor as the domain separator.\n *\n * @param serializable An object that has a bcs serialized form\n *\n * @returns The Uint8Array of the signing message\n */\nexport function generateSigningMessageForSerializable(serializable: Serializable): Uint8Array {\n  return generateSigningMessage(serializable.bcsToBytes(), `APTOS::${serializable.constructor.name}`);\n}\n\n/**\n * Generates the 'signing message' form of a transaction. It derives the type of transaction and\n * applies the appropriate domain separator based on if there is extra data such as a fee payer or\n * secondary signers.\n *\n * @param transaction A transaction that is to be signed\n *\n * @returns The Uint8Array of the signing message\n */\nexport function generateSigningMessageForTransaction(transaction: AnyRawTransaction): Uint8Array {\n  const rawTxn = deriveTransactionType(transaction);\n  if (transaction.feePayerAddress) {\n    return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_WITH_DATA_SALT);\n  }\n  if (transaction.secondarySignerAddresses) {\n    return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_WITH_DATA_SALT);\n  }\n  return generateSigningMessage(rawTxn.bcsToBytes(), RAW_TRANSACTION_SALT);\n}\n"],"mappings":";;;;;;;;;;AAMA,SAAS,YAAY,gBAAgB;AAa9B,SAAS,sBAAsB,aAA2D;AAC/F,MAAI,YAAY,iBAAiB;AAC/B,WAAO,IAAI;AAAA,MACT,YAAY;AAAA,MACZ,YAAY,4BAA4B,CAAC;AAAA,MACzC,YAAY;AAAA,IACd;AAAA,EACF;AACA,MAAI,YAAY,0BAA0B;AACxC,WAAO,IAAI,yBAAyB,YAAY,gBAAgB,YAAY,wBAAwB;AAAA,EACtG;AAEA,SAAO,YAAY;AACrB;AAUO,SAAS,uBAAuB,OAAmB,iBAAqC;AAC7F,QAAM,OAAO,SAAS,OAAO;AAE7B,MAAI,CAAC,gBAAgB,WAAW,SAAS,GAAG;AAC1C,UAAM,IAAI,MAAM,+DAA+D,eAAe,EAAE;AAAA,EAClG;AAEA,OAAK,OAAO,eAAe;AAE3B,QAAM,SAAS,KAAK,OAAO;AAE3B,QAAM,OAAO;AAEb,QAAM,cAAc,IAAI,WAAW,OAAO,SAAS,KAAK,MAAM;AAC9D,cAAY,IAAI,MAAM;AACtB,cAAY,IAAI,MAAM,OAAO,MAAM;AAEnC,SAAO;AACT;AAUO,SAAS,sCAAsC,cAAwC;AAC5F,SAAO,uBAAuB,aAAa,WAAW,GAAG,UAAU,aAAa,YAAY,IAAI,EAAE;AACpG;AAWO,SAAS,qCAAqC,aAA4C;AAC/F,QAAM,SAAS,sBAAsB,WAAW;AAChD,MAAI,YAAY,iBAAiB;AAC/B,WAAO,uBAAuB,OAAO,WAAW,GAAG,8BAA8B;AAAA,EACnF;AACA,MAAI,YAAY,0BAA0B;AACxC,WAAO,uBAAuB,OAAO,WAAW,GAAG,8BAA8B;AAAA,EACnF;AACA,SAAO,uBAAuB,OAAO,WAAW,GAAG,oBAAoB;AACzE;","names":[]}