@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0

package/dist/esm/chunk-DMFRIING.mjs

@@ -1,286 +0,0 @@
-import {
-  AnyPublicKey,
-  AnySignature
-} from "./chunk-IPUAVRGL.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-R4JTQQBX.mjs";
-import {
-  Signature
-} from "./chunk-KLUO6XPE.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-PKUXOBIV.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 AbstractMultiKey = class extends AccountPublicKey {
-  constructor(args) {
-    super();
-    this.publicKeys = args.publicKeys;
-  }
-  /**
-   * 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
-   * @group Implementation
-   * @category Serialization
-   */
-  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.
-   *
-   * 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
-   * @category Serialization
-   */
-  getIndex(publicKey) {
-    const index = this.publicKeys.findIndex((pk) => pk.toString() === publicKey.toString());
-    if (index !== -1) {
-      return index;
-    }
-    throw new Error(`Public key ${publicKey} not found in multi key set ${this.publicKeys}`);
-  }
-};
-var MultiKey = class _MultiKey extends AbstractMultiKey {
-  /**
-   * Signature for a K-of-N multi-sig transaction.
-   * This constructor initializes a multi-signature transaction with the provided signatures and bitmap.
-   *
-   * @param args An object containing the parameters for the multi-signature transaction.
-   * @param args.signatures A list of signatures.
-   * @param args.bitmap A bitmap represented as a Uint8Array or an array of numbers, where each bit indicates whether a
-   * corresponding signature is present. A maximum of 32 signatures is supported, and the length of the bitmap must be 4 bytes.
-   *
-   * @throws Error if the number of signatures exceeds the maximum supported, if the bitmap length is incorrect, or if the number
-   * of signatures does not match the bitmap.
-   * @group Implementation
-   * @category Serialization
-   */
-  // region Constructors
-  constructor(args) {
-    const { publicKeys, signaturesRequired } = args;
-    super({ publicKeys });
-    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
-  /**
-   * Verifies the provided signature against the given message.
-   * This function helps ensure the integrity and authenticity of the message by checking if the signature is valid.
-   *
-   * @param args - The arguments for verifying the signature.
-   * @param args.message - The message that was signed.
-   * @param args.signature - The signature to verify.
-   * @group Implementation
-   * @category Serialization
-   */
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  verifySignature(args) {
-    throw new Error("not implemented");
-  }
-  /**
-   * Generates an authentication key based on the current instance's byte representation.
-   * This key can be used for secure authentication processes within the system.
-   *
-   * @returns {AuthenticationKey} The generated authentication key.
-   * @group Implementation
-   * @category Serialization
-   */
-  authKey() {
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 3 /* MultiKey */,
-      input: this.toUint8Array()
-    });
-  }
-  // endregion
-  // region Serializable
-  /**
-   * Serializes the object by writing its signatures and bitmap to the provided serializer.
-   * This allows the object to be converted into a format suitable for transmission or storage.
-   *
-   * @param serializer - The serializer instance used to perform the serialization.
-   * @group Implementation
-   * @category Serialization
-   */
-  serialize(serializer) {
-    serializer.serializeVector(this.publicKeys);
-    serializer.serializeU8(this.signaturesRequired);
-  }
-  /**
-   * Deserializes a MultiKeySignature from the provided deserializer.
-   * This function retrieves the signatures and bitmap necessary for creating a MultiKeySignature object.
-   *
-   * @param deserializer - The deserializer instance used to read the serialized data.
-   * @group Implementation
-   * @category Serialization
-   */
-  static deserialize(deserializer) {
-    const keys = deserializer.deserializeVector(AnyPublicKey);
-    const signaturesRequired = deserializer.deserializeU8();
-    return new _MultiKey({ publicKeys: keys, signaturesRequired });
-  }
-  // 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) {
-    const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey);
-    return super.getIndex(anyPublicKey);
-  }
-  static isInstance(value) {
-    return "publicKeys" in value && "signaturesRequired" in value;
-  }
-};
-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
-   * @group Implementation
-   * @category Serialization
-   */
-  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
-   * @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) => {
-      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 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)
- * @group Implementation
- * @category Serialization
- */
-_MultiKeySignature.BITMAP_LEN = 4;
-/**
- * Maximum number of Ed25519 signatures supported
- * @group Implementation
- * @category Serialization
- */
-_MultiKeySignature.MAX_SIGNATURES_SUPPORTED = _MultiKeySignature.BITMAP_LEN * 8;
-var MultiKeySignature = _MultiKeySignature;
-
-export {
-  AbstractMultiKey,
-  MultiKey,
-  MultiKeySignature
-};
-//# sourceMappingURL=chunk-DMFRIING.mjs.map

package/dist/esm/chunk-EBFKT35C.mjs

@@ -1,66 +0,0 @@
-import {
-  RawTransaction
-} from "./chunk-XX6C2QGI.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  Serializable
-} from "./chunk-C7T6GW5P.mjs";
-
-// src/transactions/instances/simpleTransaction.ts
-var SimpleTransaction = class _SimpleTransaction extends Serializable {
-  /**
-   * SimpleTransaction represents a transaction signed by a single account that
-   * can be submitted to the Aptos chain for execution.
-   *
-   * @param rawTransaction The Raw Transaction.
-   * @param feePayerAddress The optional sponsor Account Address to pay the gas fees.
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(rawTransaction, feePayerAddress) {
-    super();
-    this.rawTransaction = rawTransaction;
-    this.feePayerAddress = feePayerAddress;
-  }
-  /**
-   * Serializes the transaction data using the provided serializer.
-   * This function ensures that the raw transaction and fee payer address are properly serialized for further processing.
-   *
-   * @param serializer - The serializer instance used to serialize the transaction data.
-   * @group Implementation
-   * @category Transactions
-   */
-  serialize(serializer) {
-    this.rawTransaction.serialize(serializer);
-    if (this.feePayerAddress === void 0) {
-      serializer.serializeBool(false);
-    } else {
-      serializer.serializeBool(true);
-      this.feePayerAddress.serialize(serializer);
-    }
-  }
-  /**
-   * Deserializes a SimpleTransaction from the given deserializer.
-   * This function helps in reconstructing a SimpleTransaction object from its serialized form.
-   *
-   * @param deserializer - The deserializer instance used to read the serialized data.
-   * @group Implementation
-   * @category Transactions
-   */
-  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-EBFKT35C.mjs.map

package/dist/esm/chunk-ECTX2FGD.mjs

@@ -1,355 +0,0 @@
-import {
-  convertSigningMessage
-} from "./chunk-THWEBWUC.mjs";
-import {
-  isValidBIP44Path,
-  mnemonicToSeed
-} from "./chunk-F7W7KS5C.mjs";
-import {
-  PrivateKey
-} from "./chunk-YU65LNIC.mjs";
-import {
-  PublicKey
-} from "./chunk-R4JTQQBX.mjs";
-import {
-  Signature
-} from "./chunk-KLUO6XPE.mjs";
-import {
-  Serializable
-} from "./chunk-C7T6GW5P.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/core/crypto/secp256k1.ts
-import { sha3_256 } from "@noble/hashes/sha3";
-import { secp256k1 } from "@noble/curves/secp256k1";
-import { HDKey } from "@scure/bip32";
-var _Secp256k1PublicKey = class _Secp256k1PublicKey extends PublicKey {
-  /**
-   * Create a new PublicKey instance from a HexInput, which can be a string or Uint8Array.
-   * This constructor validates the length of the provided signature data.
-   *
-   * @param hexInput - A HexInput (string or Uint8Array) representing the signature data.
-   * @throws Error if the length of the signature data is not equal to Secp256k1Signature.LENGTH.
-   * @group Implementation
-   * @category Serialization
-   */
-  constructor(hexInput) {
-    super();
-    const hex = Hex.fromHexInput(hexInput);
-    const { length } = hex.toUint8Array();
-    if (length === _Secp256k1PublicKey.LENGTH) {
-      this.key = hex;
-    } else if (length === _Secp256k1PublicKey.COMPRESSED_LENGTH) {
-      const point = secp256k1.ProjectivePoint.fromHex(hex.toUint8Array());
-      this.key = Hex.fromHexInput(point.toRawBytes(false));
-    } else {
-      throw new Error(
-        `PublicKey length should be ${_Secp256k1PublicKey.LENGTH} or ${_Secp256k1PublicKey.COMPRESSED_LENGTH}, received ${length}`
-      );
-    }
-  }
-  // region PublicKey
-  /**
-   * Verifies a Secp256k1 signature against the public key.
-   *
-   * This function checks the validity of a signature for a given message, ensuring that the signature is canonical as a malleability check.
-   *
-   * @param args - The arguments for verifying the signature.
-   * @param args.message - The message that was signed.
-   * @param args.signature - The signature to verify against the public key.
-   * @group Implementation
-   * @category Serialization
-   */
-  verifySignature(args) {
-    const { message, signature } = args;
-    const messageToVerify = convertSigningMessage(message);
-    const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
-    const messageSha3Bytes = sha3_256(messageBytes);
-    const signatureBytes = signature.toUint8Array();
-    return secp256k1.verify(signatureBytes, messageSha3Bytes, this.key.toUint8Array(), { lowS: true });
-  }
-  /**
-   * Get the data as a Uint8Array representation.
-   *
-   * @returns Uint8Array representation of the data.
-   * @group Implementation
-   * @category Serialization
-   */
-  toUint8Array() {
-    return this.key.toUint8Array();
-  }
-  // endregion
-  // region Serializable
-  /**
-   * Serializes the data into a byte array using the provided serializer.
-   * This function is essential for converting data into a format suitable for transmission or storage.
-   *
-   * @param serializer - The serializer instance used to convert the data.
-   * @group Implementation
-   * @category Serialization
-   */
-  serialize(serializer) {
-    serializer.serializeBytes(this.key.toUint8Array());
-  }
-  /**
-   * Deserializes a Secp256k1Signature from the provided deserializer.
-   * This function allows you to reconstruct a Secp256k1Signature object from its serialized byte representation.
-   *
-   * @param deserializer - The deserializer instance used to read the serialized data.
-   * @group Implementation
-   * @category Serialization
-   */
-  // eslint-disable-next-line class-methods-use-this
-  deserialize(deserializer) {
-    const hex = deserializer.deserializeBytes();
-    return new Secp256k1Signature(hex);
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    return new _Secp256k1PublicKey(bytes);
-  }
-  // endregion
-  /**
-   * Determine if the provided public key is an instance of Secp256k1PublicKey.
-   *
-   * @deprecated use `instanceof Secp256k1PublicKey` instead
-   * @param publicKey - The public key to check.
-   * @group Implementation
-   * @category Serialization
-   */
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _Secp256k1PublicKey;
-  }
-  /**
-   * Determines if the provided public key is a valid instance of a Secp256k1 public key.
-   * This function checks for the presence of a "key" property and validates the length of the key data.
-   *
-   * @param publicKey - The public key to validate.
-   * @returns A boolean indicating whether the public key is a valid Secp256k1 public key.
-   * @group Implementation
-   * @category Serialization
-   */
-  static isInstance(publicKey) {
-    return "key" in publicKey && publicKey.key?.data?.length === _Secp256k1PublicKey.LENGTH;
-  }
-};
-// Secp256k1 ecdsa public keys contain a prefix indicating compression and two 32-byte coordinates.
-_Secp256k1PublicKey.LENGTH = 65;
-// If it's compressed, it is only 33 bytes
-_Secp256k1PublicKey.COMPRESSED_LENGTH = 33;
-var Secp256k1PublicKey = _Secp256k1PublicKey;
-var _Secp256k1PrivateKey = class _Secp256k1PrivateKey extends Serializable {
-  // region Constructors
-  /**
-   * Create a new PrivateKey instance from a Uint8Array or String.
-   *
-   * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
-   *
-   * @param hexInput A HexInput (string or Uint8Array)
-   * @param strict If true, private key must AIP-80 compliant.
-   * @group Implementation
-   * @category Serialization
-   */
-  constructor(hexInput, strict) {
-    super();
-    const privateKeyHex = PrivateKey.parseHexInput(hexInput, "secp256k1" /* Secp256k1 */, strict);
-    if (privateKeyHex.toUint8Array().length !== _Secp256k1PrivateKey.LENGTH) {
-      throw new Error(`PrivateKey length should be ${_Secp256k1PrivateKey.LENGTH}`);
-    }
-    this.key = privateKeyHex;
-  }
-  /**
-   * Generate a new random private key.
-   *
-   * @returns Secp256k1PrivateKey - A newly generated Secp256k1 private key.
-   * @group Implementation
-   * @category Serialization
-   */
-  static generate() {
-    const hexInput = secp256k1.utils.randomPrivateKey();
-    return new _Secp256k1PrivateKey(hexInput, false);
-  }
-  /**
-   * Derives a private key from a mnemonic seed phrase using a specified BIP44 path.
-   *
-   * @param path - The BIP44 path to derive the key from.
-   * @param mnemonics - The mnemonic seed phrase used for key generation.
-   *
-   * @returns The generated private key.
-   *
-   * @throws Error if the provided path is not a valid BIP44 path.
-   * @group Implementation
-   * @category Serialization
-   */
-  static fromDerivationPath(path, mnemonics) {
-    if (!isValidBIP44Path(path)) {
-      throw new Error(`Invalid derivation path ${path}`);
-    }
-    return _Secp256k1PrivateKey.fromDerivationPathInner(path, mnemonicToSeed(mnemonics));
-  }
-  /**
-   * Derives a private key from a specified BIP44 path using a given seed.
-   * This function is essential for generating keys that follow the hierarchical deterministic (HD) wallet structure.
-   *
-   * @param path - The BIP44 path used for key derivation.
-   * @param seed - The seed phrase created by the mnemonics, represented as a Uint8Array.
-   * @returns The generated private key as an instance of Secp256k1PrivateKey.
-   * @throws Error if the derived private key is invalid.
-   * @group Implementation
-   * @category Serialization
-   */
-  static fromDerivationPathInner(path, seed) {
-    const { privateKey } = HDKey.fromMasterSeed(seed).derive(path);
-    if (privateKey === null) {
-      throw new Error("Invalid key");
-    }
-    return new _Secp256k1PrivateKey(privateKey, false);
-  }
-  // endregion
-  // region PrivateKey
-  /**
-   * Sign the given message with the private key.
-   * This function generates a cryptographic signature for the provided message, ensuring the signature is canonical and non-malleable.
-   *
-   * @param message - A message in HexInput format to be signed.
-   * @returns Signature - The generated signature for the provided message.
-   * @group Implementation
-   * @category Serialization
-   */
-  sign(message) {
-    const messageToSign = convertSigningMessage(message);
-    const messageBytes = Hex.fromHexInput(messageToSign);
-    const messageHashBytes = sha3_256(messageBytes.toUint8Array());
-    const signature = secp256k1.sign(messageHashBytes, this.key.toUint8Array(), { lowS: true });
-    return new Secp256k1Signature(signature.toCompactRawBytes());
-  }
-  /**
-   * Derive the Secp256k1PublicKey from this private key.
-   *
-   * @returns Secp256k1PublicKey The derived public key.
-   * @group Implementation
-   * @category Serialization
-   */
-  publicKey() {
-    const bytes = secp256k1.getPublicKey(this.key.toUint8Array(), false);
-    return new Secp256k1PublicKey(bytes);
-  }
-  /**
-   * Get the private key in bytes (Uint8Array).
-   *
-   * @returns
-   * @group Implementation
-   * @category Serialization
-   */
-  toUint8Array() {
-    return this.key.toUint8Array();
-  }
-  /**
-   * Get the private key as a string representation.
-   *
-   * @returns string representation of the private key
-   * @group Implementation
-   * @category Serialization
-   */
-  toString() {
-    return this.toHexString();
-  }
-  /**
-   * Get the private key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the private key.
-   */
-  toHexString() {
-    return this.key.toString();
-  }
-  /**
-   * Get the private key as a AIP-80 compliant hex string.
-   *
-   * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
-   *
-   * @returns AIP-80 compliant string representation of the private key.
-   */
-  toAIP80String() {
-    return PrivateKey.formatPrivateKey(this.key.toString(), "secp256k1" /* Secp256k1 */);
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    return new _Secp256k1PrivateKey(bytes, false);
-  }
-  // endregion
-  /**
-   * Determines if the provided private key is an instance of Secp256k1PrivateKey.
-   *
-   * @param privateKey - The private key to be checked.
-   *
-   * @deprecated use `instanceof Secp256k1PrivateKey` instead
-   * @group Implementation
-   * @category Serialization
-   */
-  static isPrivateKey(privateKey) {
-    return privateKey instanceof _Secp256k1PrivateKey;
-  }
-};
-/**
- * Length of Secp256k1 ecdsa private key
- * @group Implementation
- * @category Serialization
- */
-_Secp256k1PrivateKey.LENGTH = 32;
-var Secp256k1PrivateKey = _Secp256k1PrivateKey;
-var _Secp256k1Signature = class _Secp256k1Signature extends Signature {
-  // region Constructors
-  /**
-   * Create a new Signature instance from a Uint8Array or String.
-   *
-   * @param hexInput A HexInput (string or Uint8Array)
-   * @group Implementation
-   * @category Serialization
-   */
-  constructor(hexInput) {
-    super();
-    const data = Hex.fromHexInput(hexInput);
-    if (data.toUint8Array().length !== _Secp256k1Signature.LENGTH) {
-      throw new Error(
-        `Signature length should be ${_Secp256k1Signature.LENGTH}, received ${data.toUint8Array().length}`
-      );
-    }
-    this.data = data;
-  }
-  // endregion
-  // region Signature
-  toUint8Array() {
-    return this.data.toUint8Array();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.data.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const hex = deserializer.deserializeBytes();
-    return new _Secp256k1Signature(hex);
-  }
-  // endregion
-};
-/**
- * Secp256k1 ecdsa signatures are 256-bit.
- * @group Implementation
- * @category Serialization
- */
-_Secp256k1Signature.LENGTH = 64;
-var Secp256k1Signature = _Secp256k1Signature;
-
-export {
-  Secp256k1PublicKey,
-  Secp256k1PrivateKey,
-  Secp256k1Signature
-};
-//# sourceMappingURL=chunk-ECTX2FGD.mjs.map