@opendatalabs/vana-sdk 0.1.0-alpha.d7fc764 → 0.1.0-alpha.dc68f39

package/dist/crypto/ecies/interface.d.ts

@@ -18,7 +18,7 @@
  * This structure maintains backward compatibility with data encrypted using
  * the legacy eccrypto library.
  */
-interface ECIESEncrypted {
+export interface ECIESEncrypted {
     /** Initialization vector (16 bytes) */
     iv: Uint8Array;
     /** Ephemeral public key (65 bytes uncompressed) */
@@ -37,7 +37,7 @@ interface ECIESEncrypted {
  *
  * @category Cryptography
  */
-interface ECIESProvider {
+export interface ECIESProvider {
     /**
      * Encrypts data using ECIES with secp256k1.
      *
@@ -51,7 +51,7 @@ interface ECIESProvider {
      * @example
      * ```typescript
      * const encrypted = await provider.encrypt(
-     *   hexToBytes(publicKey),
+     *   fromHex(publicKey, 'bytes'),
      *   new TextEncoder().encode('sensitive data')
      * );
      * ```
@@ -69,7 +69,7 @@ interface ECIESProvider {
      * @example
      * ```typescript
      * const decrypted = await provider.decrypt(
-     *   hexToBytes(privateKey),
+     *   fromHex(privateKey, 'bytes'),
      *   encrypted
      * );
      * const message = new TextDecoder().decode(decrypted);
@@ -112,7 +112,7 @@ interface ECIESProvider {
 /**
  * Configures ECIES operation behavior.
  */
-interface ECIESOptions {
+export interface ECIESOptions {
     /** Use compressed public keys (33 bytes) instead of uncompressed (65 bytes) */
     useCompressed?: boolean;
 }
@@ -125,7 +125,7 @@ interface ECIESOptions {
  *
  * @category Errors
  */
-declare class ECIESError extends Error {
+export declare class ECIESError extends Error {
     readonly code: "INVALID_KEY" | "ENCRYPTION_FAILED" | "DECRYPTION_FAILED" | "MAC_MISMATCH" | "ECDH_FAILED";
     readonly cause?: Error | undefined;
     constructor(message: string, code: "INVALID_KEY" | "ENCRYPTION_FAILED" | "DECRYPTION_FAILED" | "MAC_MISMATCH" | "ECDH_FAILED", cause?: Error | undefined);
@@ -143,7 +143,7 @@ declare class ECIESError extends Error {
  * }
  * ```
  */
-declare function isECIESEncrypted(obj: unknown): obj is ECIESEncrypted;
+export declare function isECIESEncrypted(obj: unknown): obj is ECIESEncrypted;
 /**
  * Serializes ECIESEncrypted to hex string for storage or transmission.
  *
@@ -156,7 +156,7 @@ declare function isECIESEncrypted(obj: unknown): obj is ECIESEncrypted;
  * // Store hexString in database or send over network
  * ```
  */
-declare function serializeECIES(encrypted: ECIESEncrypted): string;
+export declare function serializeECIES(encrypted: ECIESEncrypted): string;
 /**
  * Deserializes hex string to ECIESEncrypted structure.
  *
@@ -171,6 +171,4 @@ declare function serializeECIES(encrypted: ECIESEncrypted): string;
  * const decrypted = await provider.decrypt(privateKey, encrypted);
  * ```
  */
-declare function deserializeECIES(hex: string): ECIESEncrypted;
-
-export { type ECIESEncrypted, ECIESError, type ECIESOptions, type ECIESProvider, deserializeECIES, isECIESEncrypted, serializeECIES };
+export declare function deserializeECIES(hex: string): ECIESEncrypted;

package/dist/crypto/ecies/interface.js

@@ -1,4 +1,5 @@
 import { CIPHER, CURVE, MAC, FORMAT } from "./constants";
+import { fromHex, toHex } from "viem";
 class ECIESError extends Error {
   constructor(message, code, cause) {
     super(message);
@@ -27,13 +28,11 @@ function serializeECIES(encrypted) {
   combined.set(encrypted.ciphertext, offset);
   offset += encrypted.ciphertext.length;
   combined.set(encrypted.mac, offset);
-  return Array.from(combined).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return toHex(combined).slice(2);
 }
 function deserializeECIES(hex) {
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-  }
+  const hexWithPrefix = hex.startsWith("0x") ? hex : `0x${hex}`;
+  const bytes = fromHex(hexWithPrefix, "bytes");
   const ephemKeySize = bytes[FORMAT.EPHEMERAL_KEY_OFFSET] === CURVE.PREFIX.UNCOMPRESSED ? CURVE.UNCOMPRESSED_PUBLIC_KEY_LENGTH : CURVE.COMPRESSED_PUBLIC_KEY_LENGTH;
   const minLength = FORMAT.IV_LENGTH + ephemKeySize + MAC.LENGTH + 1;
   if (bytes.length < minLength) {

package/dist/crypto/ecies/interface.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/crypto/ecies/interface.ts"],"sourcesContent":["/**\n * ECIES (Elliptic Curve Integrated Encryption Scheme) Interface\n *\n * @remarks\n * Defines the contract for platform-specific ECIES implementations.\n * All implementations maintain compatibility with the eccrypto format to ensure\n * backward compatibility with existing encrypted data.\n *\n * **Format specification:**\n * `[iv (16 bytes)][ephemPublicKey (65 bytes)][ciphertext (variable)][mac (32 bytes)]`\n *\n * @category Cryptography\n */\n\nimport { CIPHER, CURVE, MAC, FORMAT } from \"./constants\";\n\n/**\n * Represents ECIES encrypted data in eccrypto-compatible format.\n *\n * @remarks\n * This structure maintains backward compatibility with data encrypted using\n * the legacy eccrypto library.\n */\nexport interface ECIESEncrypted {\n  /** Initialization vector (16 bytes) */\n  iv: Uint8Array;\n  /** Ephemeral public key (65 bytes uncompressed) */\n  ephemPublicKey: Uint8Array;\n  /** Encrypted data */\n  ciphertext: Uint8Array;\n  /** Message authentication code (32 bytes) */\n  mac: Uint8Array;\n}\n\n/**\n * Provides ECIES encryption and decryption operations.\n *\n * @remarks\n * Platform-specific implementations handle the underlying cryptographic primitives\n * while maintaining consistent data format across environments.\n *\n * @category Cryptography\n */\nexport interface ECIESProvider {\n  /**\n   * Encrypts data using ECIES with secp256k1.\n   *\n   * @param publicKey - Recipient's public key (65 bytes uncompressed or 33 bytes compressed).\n   *   Obtain via `vana.server.getIdentity(userAddress).public_key`.\n   * @param message - Data to encrypt.\n   * @returns Encrypted data structure compatible with eccrypto format.\n   * @throws {ECIESError} When public key is invalid.\n   *   Verify key format matches secp256k1 requirements.\n   *\n   * @example\n   * ```typescript\n   * const encrypted = await provider.encrypt(\n   *   hexToBytes(publicKey),\n   *   new TextEncoder().encode('sensitive data')\n   * );\n   * ```\n   */\n  encrypt(publicKey: Uint8Array, message: Uint8Array): Promise<ECIESEncrypted>;\n\n  /**\n   * Decrypts ECIES encrypted data.\n   *\n   * @param privateKey - Recipient's private key (32 bytes).\n   * @param encrypted - Encrypted data structure from `encrypt()` or legacy eccrypto.\n   * @returns Decrypted message as Uint8Array.\n   * @throws {ECIESError} When MAC verification fails.\n   *   Ensure the private key matches the public key used for encryption.\n   *\n   * @example\n   * ```typescript\n   * const decrypted = await provider.decrypt(\n   *   hexToBytes(privateKey),\n   *   encrypted\n   * );\n   * const message = new TextDecoder().decode(decrypted);\n   * ```\n   */\n  decrypt(\n    privateKey: Uint8Array,\n    encrypted: ECIESEncrypted,\n  ): Promise<Uint8Array>;\n\n  /**\n   * Normalizes a public key to uncompressed format (65 bytes with 0x04 prefix).\n   *\n   * @remarks\n   * Strict policy: Only accepts properly formatted compressed (33 bytes) or\n   * uncompressed (65 bytes) public keys. Does not accept 64-byte raw coordinates\n   * to ensure data integrity and prevent masking of malformed inputs.\n   *\n   * @param publicKey - Public key in compressed or uncompressed format\n   * @returns Normalized uncompressed public key (65 bytes with 0x04 prefix)\n   * @throws {Error} When public key format is invalid, including raw coordinates (64 bytes)\n   * @throws {Error} When decompression of compressed key fails\n   *\n   * @example\n   * ```typescript\n   * // Compressed key (33 bytes)\n   * const compressed = new Uint8Array(33);\n   * compressed[0] = 0x02;\n   * const uncompressed = provider.normalizeToUncompressed(compressed);\n   * console.log(uncompressed.length); // 65\n   * console.log(uncompressed[0]); // 0x04\n   *\n   * // Already uncompressed (65 bytes)\n   * const already = provider.normalizeToUncompressed(uncompressedKey);\n   * console.log(already === uncompressedKey); // true (returns same reference)\n   *\n   * // Raw coordinates rejected (64 bytes)\n   * const raw = new Uint8Array(64);\n   * provider.normalizeToUncompressed(raw); // Throws error\n   * ```\n   */\n  normalizeToUncompressed(publicKey: Uint8Array): Uint8Array;\n}\n\n/**\n * Configures ECIES operation behavior.\n */\nexport interface ECIESOptions {\n  /** Use compressed public keys (33 bytes) instead of uncompressed (65 bytes) */\n  useCompressed?: boolean;\n}\n\n/**\n * Represents failures in ECIES cryptographic operations.\n *\n * @remarks\n * Provides specific error codes to help identify and recover from\n * different failure scenarios.\n *\n * @category Errors\n */\nexport class ECIESError extends Error {\n  constructor(\n    message: string,\n    public readonly code:\n      | \"INVALID_KEY\"\n      | \"ENCRYPTION_FAILED\"\n      | \"DECRYPTION_FAILED\"\n      | \"MAC_MISMATCH\"\n      | \"ECDH_FAILED\",\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"ECIESError\";\n  }\n}\n\n/**\n * Validates if an object conforms to the ECIESEncrypted structure.\n *\n * @param obj - Object to validate.\n * @returns `true` if object is a valid ECIESEncrypted structure.\n *\n * @example\n * ```typescript\n * if (isECIESEncrypted(data)) {\n *   const decrypted = await provider.decrypt(privateKey, data);\n * }\n * ```\n */\nexport function isECIESEncrypted(obj: unknown): obj is ECIESEncrypted {\n  if (!obj || typeof obj !== \"object\") return false;\n  const enc = obj as Record<string, unknown>;\n\n  const isUint8Array = (value: unknown): value is Uint8Array => {\n    return (\n      value instanceof Uint8Array ||\n      (typeof Buffer !== \"undefined\" && Buffer.isBuffer(value))\n    );\n  };\n\n  return (\n    isUint8Array(enc.iv) &&\n    enc.iv.length === CIPHER.IV_LENGTH &&\n    isUint8Array(enc.ephemPublicKey) &&\n    (enc.ephemPublicKey.length === CURVE.UNCOMPRESSED_PUBLIC_KEY_LENGTH ||\n      enc.ephemPublicKey.length === CURVE.COMPRESSED_PUBLIC_KEY_LENGTH) &&\n    isUint8Array(enc.ciphertext) &&\n    enc.ciphertext.length > 0 &&\n    isUint8Array(enc.mac) &&\n    enc.mac.length === MAC.LENGTH\n  );\n}\n\n/**\n * Serializes ECIESEncrypted to hex string for storage or transmission.\n *\n * @param encrypted - Encrypted data structure from `encrypt()`.\n * @returns Hex string representation.\n *\n * @example\n * ```typescript\n * const hexString = serializeECIES(encrypted);\n * // Store hexString in database or send over network\n * ```\n */\nexport function serializeECIES(encrypted: ECIESEncrypted): string {\n  const combined = new Uint8Array(\n    encrypted.iv.length +\n      encrypted.ephemPublicKey.length +\n      encrypted.ciphertext.length +\n      encrypted.mac.length,\n  );\n\n  let offset = 0;\n  combined.set(encrypted.iv, offset);\n  offset += encrypted.iv.length;\n  combined.set(encrypted.ephemPublicKey, offset);\n  offset += encrypted.ephemPublicKey.length;\n  combined.set(encrypted.ciphertext, offset);\n  offset += encrypted.ciphertext.length;\n  combined.set(encrypted.mac, offset);\n\n  return Array.from(combined)\n    .map((b) => b.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n}\n\n/**\n * Deserializes hex string to ECIESEncrypted structure.\n *\n * @param hex - Hex string from `serializeECIES()` or storage.\n * @returns ECIESEncrypted structure ready for decryption.\n * @throws {ECIESError} When hex string format is invalid.\n *   Verify the hex string is complete and uncorrupted.\n *\n * @example\n * ```typescript\n * const encrypted = deserializeECIES(hexString);\n * const decrypted = await provider.decrypt(privateKey, encrypted);\n * ```\n */\nexport function deserializeECIES(hex: string): ECIESEncrypted {\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < hex.length; i += 2) {\n    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);\n  }\n\n  // Determine ephemPublicKey size based on prefix\n  const ephemKeySize =\n    bytes[FORMAT.EPHEMERAL_KEY_OFFSET] === CURVE.PREFIX.UNCOMPRESSED\n      ? CURVE.UNCOMPRESSED_PUBLIC_KEY_LENGTH\n      : CURVE.COMPRESSED_PUBLIC_KEY_LENGTH;\n\n  const minLength = FORMAT.IV_LENGTH + ephemKeySize + MAC.LENGTH + 1; // +1 for at least 1 byte of ciphertext\n  if (bytes.length < minLength) {\n    throw new ECIESError(\"Invalid ECIES data: too short\", \"DECRYPTION_FAILED\");\n  }\n\n  return {\n    iv: bytes.subarray(FORMAT.IV_OFFSET, FORMAT.IV_OFFSET + FORMAT.IV_LENGTH),\n    ephemPublicKey: bytes.subarray(\n      FORMAT.EPHEMERAL_KEY_OFFSET,\n      FORMAT.EPHEMERAL_KEY_OFFSET + ephemKeySize,\n    ),\n    ciphertext: bytes.subarray(\n      FORMAT.EPHEMERAL_KEY_OFFSET + ephemKeySize,\n      bytes.length - MAC.LENGTH,\n    ),\n    mac: bytes.subarray(bytes.length - MAC.LENGTH),\n  };\n}\n"],"mappings":"AAcA,SAAS,QAAQ,OAAO,KAAK,cAAc;AA4HpC,MAAM,mBAAmB,MAAM;AAAA,EACpC,YACE,SACgB,MAMS,OACzB;AACA,UAAM,OAAO;AARG;AAMS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAeO,SAAS,iBAAiB,KAAqC;AACpE,MAAI,CAAC,OAAO,OAAO,QAAQ,SAAU,QAAO;AAC5C,QAAM,MAAM;AAEZ,QAAM,eAAe,CAAC,UAAwC;AAC5D,WACE,iBAAiB,cAChB,OAAO,WAAW,eAAe,OAAO,SAAS,KAAK;AAAA,EAE3D;AAEA,SACE,aAAa,IAAI,EAAE,KACnB,IAAI,GAAG,WAAW,OAAO,aACzB,aAAa,IAAI,cAAc,MAC9B,IAAI,eAAe,WAAW,MAAM,kCACnC,IAAI,eAAe,WAAW,MAAM,iCACtC,aAAa,IAAI,UAAU,KAC3B,IAAI,WAAW,SAAS,KACxB,aAAa,IAAI,GAAG,KACpB,IAAI,IAAI,WAAW,IAAI;AAE3B;AAcO,SAAS,eAAe,WAAmC;AAChE,QAAM,WAAW,IAAI;AAAA,IACnB,UAAU,GAAG,SACX,UAAU,eAAe,SACzB,UAAU,WAAW,SACrB,UAAU,IAAI;AAAA,EAClB;AAEA,MAAI,SAAS;AACb,WAAS,IAAI,UAAU,IAAI,MAAM;AACjC,YAAU,UAAU,GAAG;AACvB,WAAS,IAAI,UAAU,gBAAgB,MAAM;AAC7C,YAAU,UAAU,eAAe;AACnC,WAAS,IAAI,UAAU,YAAY,MAAM;AACzC,YAAU,UAAU,WAAW;AAC/B,WAAS,IAAI,UAAU,KAAK,MAAM;AAElC,SAAO,MAAM,KAAK,QAAQ,EACvB,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAC1C,KAAK,EAAE;AACZ;AAgBO,SAAS,iBAAiB,KAA6B;AAC5D,QAAM,QAAQ,IAAI,WAAW,IAAI,SAAS,CAAC;AAC3C,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK,GAAG;AACtC,UAAM,IAAI,CAAC,IAAI,SAAS,IAAI,OAAO,GAAG,CAAC,GAAG,EAAE;AAAA,EAC9C;AAGA,QAAM,eACJ,MAAM,OAAO,oBAAoB,MAAM,MAAM,OAAO,eAChD,MAAM,iCACN,MAAM;AAEZ,QAAM,YAAY,OAAO,YAAY,eAAe,IAAI,SAAS;AACjE,MAAI,MAAM,SAAS,WAAW;AAC5B,UAAM,IAAI,WAAW,iCAAiC,mBAAmB;AAAA,EAC3E;AAEA,SAAO;AAAA,IACL,IAAI,MAAM,SAAS,OAAO,WAAW,OAAO,YAAY,OAAO,SAAS;AAAA,IACxE,gBAAgB,MAAM;AAAA,MACpB,OAAO;AAAA,MACP,OAAO,uBAAuB;AAAA,IAChC;AAAA,IACA,YAAY,MAAM;AAAA,MAChB,OAAO,uBAAuB;AAAA,MAC9B,MAAM,SAAS,IAAI;AAAA,IACrB;AAAA,IACA,KAAK,MAAM,SAAS,MAAM,SAAS,IAAI,MAAM;AAAA,EAC/C;AACF;","names":[]}
+{"version":3,"sources":["../../../src/crypto/ecies/interface.ts"],"sourcesContent":["/**\n * ECIES (Elliptic Curve Integrated Encryption Scheme) Interface\n *\n * @remarks\n * Defines the contract for platform-specific ECIES implementations.\n * All implementations maintain compatibility with the eccrypto format to ensure\n * backward compatibility with existing encrypted data.\n *\n * **Format specification:**\n * `[iv (16 bytes)][ephemPublicKey (65 bytes)][ciphertext (variable)][mac (32 bytes)]`\n *\n * @category Cryptography\n */\n\nimport { CIPHER, CURVE, MAC, FORMAT } from \"./constants\";\nimport { fromHex, toHex } from \"viem\";\n\n/**\n * Represents ECIES encrypted data in eccrypto-compatible format.\n *\n * @remarks\n * This structure maintains backward compatibility with data encrypted using\n * the legacy eccrypto library.\n */\nexport interface ECIESEncrypted {\n  /** Initialization vector (16 bytes) */\n  iv: Uint8Array;\n  /** Ephemeral public key (65 bytes uncompressed) */\n  ephemPublicKey: Uint8Array;\n  /** Encrypted data */\n  ciphertext: Uint8Array;\n  /** Message authentication code (32 bytes) */\n  mac: Uint8Array;\n}\n\n/**\n * Provides ECIES encryption and decryption operations.\n *\n * @remarks\n * Platform-specific implementations handle the underlying cryptographic primitives\n * while maintaining consistent data format across environments.\n *\n * @category Cryptography\n */\nexport interface ECIESProvider {\n  /**\n   * Encrypts data using ECIES with secp256k1.\n   *\n   * @param publicKey - Recipient's public key (65 bytes uncompressed or 33 bytes compressed).\n   *   Obtain via `vana.server.getIdentity(userAddress).public_key`.\n   * @param message - Data to encrypt.\n   * @returns Encrypted data structure compatible with eccrypto format.\n   * @throws {ECIESError} When public key is invalid.\n   *   Verify key format matches secp256k1 requirements.\n   *\n   * @example\n   * ```typescript\n   * const encrypted = await provider.encrypt(\n   *   fromHex(publicKey, 'bytes'),\n   *   new TextEncoder().encode('sensitive data')\n   * );\n   * ```\n   */\n  encrypt(publicKey: Uint8Array, message: Uint8Array): Promise<ECIESEncrypted>;\n\n  /**\n   * Decrypts ECIES encrypted data.\n   *\n   * @param privateKey - Recipient's private key (32 bytes).\n   * @param encrypted - Encrypted data structure from `encrypt()` or legacy eccrypto.\n   * @returns Decrypted message as Uint8Array.\n   * @throws {ECIESError} When MAC verification fails.\n   *   Ensure the private key matches the public key used for encryption.\n   *\n   * @example\n   * ```typescript\n   * const decrypted = await provider.decrypt(\n   *   fromHex(privateKey, 'bytes'),\n   *   encrypted\n   * );\n   * const message = new TextDecoder().decode(decrypted);\n   * ```\n   */\n  decrypt(\n    privateKey: Uint8Array,\n    encrypted: ECIESEncrypted,\n  ): Promise<Uint8Array>;\n\n  /**\n   * Normalizes a public key to uncompressed format (65 bytes with 0x04 prefix).\n   *\n   * @remarks\n   * Strict policy: Only accepts properly formatted compressed (33 bytes) or\n   * uncompressed (65 bytes) public keys. Does not accept 64-byte raw coordinates\n   * to ensure data integrity and prevent masking of malformed inputs.\n   *\n   * @param publicKey - Public key in compressed or uncompressed format\n   * @returns Normalized uncompressed public key (65 bytes with 0x04 prefix)\n   * @throws {Error} When public key format is invalid, including raw coordinates (64 bytes)\n   * @throws {Error} When decompression of compressed key fails\n   *\n   * @example\n   * ```typescript\n   * // Compressed key (33 bytes)\n   * const compressed = new Uint8Array(33);\n   * compressed[0] = 0x02;\n   * const uncompressed = provider.normalizeToUncompressed(compressed);\n   * console.log(uncompressed.length); // 65\n   * console.log(uncompressed[0]); // 0x04\n   *\n   * // Already uncompressed (65 bytes)\n   * const already = provider.normalizeToUncompressed(uncompressedKey);\n   * console.log(already === uncompressedKey); // true (returns same reference)\n   *\n   * // Raw coordinates rejected (64 bytes)\n   * const raw = new Uint8Array(64);\n   * provider.normalizeToUncompressed(raw); // Throws error\n   * ```\n   */\n  normalizeToUncompressed(publicKey: Uint8Array): Uint8Array;\n}\n\n/**\n * Configures ECIES operation behavior.\n */\nexport interface ECIESOptions {\n  /** Use compressed public keys (33 bytes) instead of uncompressed (65 bytes) */\n  useCompressed?: boolean;\n}\n\n/**\n * Represents failures in ECIES cryptographic operations.\n *\n * @remarks\n * Provides specific error codes to help identify and recover from\n * different failure scenarios.\n *\n * @category Errors\n */\nexport class ECIESError extends Error {\n  constructor(\n    message: string,\n    public readonly code:\n      | \"INVALID_KEY\"\n      | \"ENCRYPTION_FAILED\"\n      | \"DECRYPTION_FAILED\"\n      | \"MAC_MISMATCH\"\n      | \"ECDH_FAILED\",\n    public override readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"ECIESError\";\n  }\n}\n\n/**\n * Validates if an object conforms to the ECIESEncrypted structure.\n *\n * @param obj - Object to validate.\n * @returns `true` if object is a valid ECIESEncrypted structure.\n *\n * @example\n * ```typescript\n * if (isECIESEncrypted(data)) {\n *   const decrypted = await provider.decrypt(privateKey, data);\n * }\n * ```\n */\nexport function isECIESEncrypted(obj: unknown): obj is ECIESEncrypted {\n  if (!obj || typeof obj !== \"object\") return false;\n  const enc = obj as Record<string, unknown>;\n\n  const isUint8Array = (value: unknown): value is Uint8Array => {\n    return (\n      value instanceof Uint8Array ||\n      (typeof Buffer !== \"undefined\" && Buffer.isBuffer(value))\n    );\n  };\n\n  return (\n    isUint8Array(enc.iv) &&\n    enc.iv.length === CIPHER.IV_LENGTH &&\n    isUint8Array(enc.ephemPublicKey) &&\n    (enc.ephemPublicKey.length === CURVE.UNCOMPRESSED_PUBLIC_KEY_LENGTH ||\n      enc.ephemPublicKey.length === CURVE.COMPRESSED_PUBLIC_KEY_LENGTH) &&\n    isUint8Array(enc.ciphertext) &&\n    enc.ciphertext.length > 0 &&\n    isUint8Array(enc.mac) &&\n    enc.mac.length === MAC.LENGTH\n  );\n}\n\n/**\n * Serializes ECIESEncrypted to hex string for storage or transmission.\n *\n * @param encrypted - Encrypted data structure from `encrypt()`.\n * @returns Hex string representation.\n *\n * @example\n * ```typescript\n * const hexString = serializeECIES(encrypted);\n * // Store hexString in database or send over network\n * ```\n */\nexport function serializeECIES(encrypted: ECIESEncrypted): string {\n  const combined = new Uint8Array(\n    encrypted.iv.length +\n      encrypted.ephemPublicKey.length +\n      encrypted.ciphertext.length +\n      encrypted.mac.length,\n  );\n\n  let offset = 0;\n  combined.set(encrypted.iv, offset);\n  offset += encrypted.iv.length;\n  combined.set(encrypted.ephemPublicKey, offset);\n  offset += encrypted.ephemPublicKey.length;\n  combined.set(encrypted.ciphertext, offset);\n  offset += encrypted.ciphertext.length;\n  combined.set(encrypted.mac, offset);\n\n  return toHex(combined).slice(2);\n}\n\n/**\n * Deserializes hex string to ECIESEncrypted structure.\n *\n * @param hex - Hex string from `serializeECIES()` or storage.\n * @returns ECIESEncrypted structure ready for decryption.\n * @throws {ECIESError} When hex string format is invalid.\n *   Verify the hex string is complete and uncorrupted.\n *\n * @example\n * ```typescript\n * const encrypted = deserializeECIES(hexString);\n * const decrypted = await provider.decrypt(privateKey, encrypted);\n * ```\n */\nexport function deserializeECIES(hex: string): ECIESEncrypted {\n  const hexWithPrefix = hex.startsWith(\"0x\") ? hex : `0x${hex}`;\n  const bytes = fromHex(hexWithPrefix as `0x${string}`, \"bytes\");\n\n  // Determine ephemPublicKey size based on prefix\n  const ephemKeySize =\n    bytes[FORMAT.EPHEMERAL_KEY_OFFSET] === CURVE.PREFIX.UNCOMPRESSED\n      ? CURVE.UNCOMPRESSED_PUBLIC_KEY_LENGTH\n      : CURVE.COMPRESSED_PUBLIC_KEY_LENGTH;\n\n  const minLength = FORMAT.IV_LENGTH + ephemKeySize + MAC.LENGTH + 1; // +1 for at least 1 byte of ciphertext\n  if (bytes.length < minLength) {\n    throw new ECIESError(\"Invalid ECIES data: too short\", \"DECRYPTION_FAILED\");\n  }\n\n  return {\n    iv: bytes.subarray(FORMAT.IV_OFFSET, FORMAT.IV_OFFSET + FORMAT.IV_LENGTH),\n    ephemPublicKey: bytes.subarray(\n      FORMAT.EPHEMERAL_KEY_OFFSET,\n      FORMAT.EPHEMERAL_KEY_OFFSET + ephemKeySize,\n    ),\n    ciphertext: bytes.subarray(\n      FORMAT.EPHEMERAL_KEY_OFFSET + ephemKeySize,\n      bytes.length - MAC.LENGTH,\n    ),\n    mac: bytes.subarray(bytes.length - MAC.LENGTH),\n  };\n}\n"],"mappings":"AAcA,SAAS,QAAQ,OAAO,KAAK,cAAc;AAC3C,SAAS,SAAS,aAAa;AA4HxB,MAAM,mBAAmB,MAAM;AAAA,EACpC,YACE,SACgB,MAMS,OACzB;AACA,UAAM,OAAO;AARG;AAMS;AAGzB,SAAK,OAAO;AAAA,EACd;AACF;AAeO,SAAS,iBAAiB,KAAqC;AACpE,MAAI,CAAC,OAAO,OAAO,QAAQ,SAAU,QAAO;AAC5C,QAAM,MAAM;AAEZ,QAAM,eAAe,CAAC,UAAwC;AAC5D,WACE,iBAAiB,cAChB,OAAO,WAAW,eAAe,OAAO,SAAS,KAAK;AAAA,EAE3D;AAEA,SACE,aAAa,IAAI,EAAE,KACnB,IAAI,GAAG,WAAW,OAAO,aACzB,aAAa,IAAI,cAAc,MAC9B,IAAI,eAAe,WAAW,MAAM,kCACnC,IAAI,eAAe,WAAW,MAAM,iCACtC,aAAa,IAAI,UAAU,KAC3B,IAAI,WAAW,SAAS,KACxB,aAAa,IAAI,GAAG,KACpB,IAAI,IAAI,WAAW,IAAI;AAE3B;AAcO,SAAS,eAAe,WAAmC;AAChE,QAAM,WAAW,IAAI;AAAA,IACnB,UAAU,GAAG,SACX,UAAU,eAAe,SACzB,UAAU,WAAW,SACrB,UAAU,IAAI;AAAA,EAClB;AAEA,MAAI,SAAS;AACb,WAAS,IAAI,UAAU,IAAI,MAAM;AACjC,YAAU,UAAU,GAAG;AACvB,WAAS,IAAI,UAAU,gBAAgB,MAAM;AAC7C,YAAU,UAAU,eAAe;AACnC,WAAS,IAAI,UAAU,YAAY,MAAM;AACzC,YAAU,UAAU,WAAW;AAC/B,WAAS,IAAI,UAAU,KAAK,MAAM;AAElC,SAAO,MAAM,QAAQ,EAAE,MAAM,CAAC;AAChC;AAgBO,SAAS,iBAAiB,KAA6B;AAC5D,QAAM,gBAAgB,IAAI,WAAW,IAAI,IAAI,MAAM,KAAK,GAAG;AAC3D,QAAM,QAAQ,QAAQ,eAAgC,OAAO;AAG7D,QAAM,eACJ,MAAM,OAAO,oBAAoB,MAAM,MAAM,OAAO,eAChD,MAAM,iCACN,MAAM;AAEZ,QAAM,YAAY,OAAO,YAAY,eAAe,IAAI,SAAS;AACjE,MAAI,MAAM,SAAS,WAAW;AAC5B,UAAM,IAAI,WAAW,iCAAiC,mBAAmB;AAAA,EAC3E;AAEA,SAAO;AAAA,IACL,IAAI,MAAM,SAAS,OAAO,WAAW,OAAO,YAAY,OAAO,SAAS;AAAA,IACxE,gBAAgB,MAAM;AAAA,MACpB,OAAO;AAAA,MACP,OAAO,uBAAuB;AAAA,IAChC;AAAA,IACA,YAAY,MAAM;AAAA,MAChB,OAAO,uBAAuB;AAAA,MAC9B,MAAM,SAAS,IAAI;AAAA,IACrB;AAAA,IACA,KAAK,MAAM,SAAS,MAAM,SAAS,IAAI,MAAM;AAAA,EAC/C;AACF;","names":[]}

package/dist/crypto/ecies/node.cjs

@@ -34,11 +34,12 @@ module.exports = __toCommonJS(node_exports);
 var import_crypto = require("crypto");
 var import_secp256k1 = __toESM(require("secp256k1"), 1);
 var import_base = require("./base");
+var import_viem = require("viem");
 const secp256k1 = import_secp256k1.default;
 class NodeECIESUint8Provider extends import_base.BaseECIESUint8 {
   // Identity hash function for ECDH - returns raw X coordinate
   // CRITICAL: Must handle (x, y, output) signature correctly
-  identityHashFn = (x, y, output) => {
+  identityHashFn = (x, _y, output) => {
     if (output && output.length >= 32) {
       output.set(x);
       return output;
@@ -144,7 +145,7 @@ class NodeECIESUint8Provider extends import_base.BaseECIESUint8 {
       const decompressed = this.decompressPublicKey(publicKey);
       if (!decompressed) {
         throw new Error(
-          `Failed to decompress public key with prefix 0x${publicKey[0].toString(16).padStart(2, "0")}`
+          `Failed to decompress public key with prefix ${(0, import_viem.toHex)(publicKey[0])}`
         );
       }
       return decompressed;

package/dist/crypto/ecies/node.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/crypto/ecies/node.ts"],"sourcesContent":["/**\n * Node.js implementation of ECIES using native secp256k1 for performance\n *\n * @remarks\n * Uses native secp256k1 bindings for all elliptic curve operations.\n * Uses Node.js crypto module for hashing and AES operations.\n * Provides Uint8Array-only interface with no Buffer exposure.\n */\n\nimport {\n  randomBytes,\n  createHash,\n  createHmac,\n  createCipheriv,\n  createDecipheriv,\n} from \"crypto\";\nimport secp256k1Import from \"secp256k1\";\nimport { BaseECIESUint8 } from \"./base\";\n\n// Type definition for secp256k1 module\ninterface Secp256k1Module {\n  privateKeyVerify(privateKey: Buffer): boolean;\n  publicKeyCreate(privateKey: Buffer, compressed: boolean): Buffer;\n  publicKeyVerify(publicKey: Buffer): boolean;\n  publicKeyConvert(publicKey: Buffer, compressed: boolean): Buffer;\n  ecdh(\n    publicKey: Buffer,\n    privateKey: Buffer,\n    options: {\n      hashfn: (x: Uint8Array, y: Uint8Array, output?: Uint8Array) => Uint8Array;\n    },\n    output: Buffer,\n  ): Buffer;\n}\n\n// Use the imported secp256k1 module\nconst secp256k1 = secp256k1Import as unknown as Secp256k1Module;\n\n/**\n * Node.js-specific ECIES provider using native secp256k1\n *\n * @remarks\n * This implementation:\n * - Uses native secp256k1 for all EC operations (optimal performance)\n * - Uses Node.js crypto for SHA-512, HMAC, and AES operations\n * - Internally works with Uint8Array\n * - Only uses Buffer at crypto API boundaries\n */\nexport class NodeECIESUint8Provider extends BaseECIESUint8 {\n  // Identity hash function for ECDH - returns raw X coordinate\n  // CRITICAL: Must handle (x, y, output) signature correctly\n  private readonly identityHashFn = (\n    x: Uint8Array,\n    y: Uint8Array,\n    output?: Uint8Array,\n  ): Uint8Array => {\n    // Copy x into output buffer if provided (prevents allocations)\n    if (output && output.length >= 32) {\n      output.set(x);\n      return output;\n    }\n    return x;\n  };\n  protected generateRandomBytes(length: number): Uint8Array {\n    return new Uint8Array(randomBytes(length));\n  }\n\n  protected verifyPrivateKey(privateKey: Uint8Array): boolean {\n    // Native secp256k1 returns true for valid, false for invalid\n    return secp256k1.privateKeyVerify(Buffer.from(privateKey)) === true;\n  }\n\n  protected createPublicKey(\n    privateKey: Uint8Array,\n    compressed: boolean,\n  ): Uint8Array | null {\n    try {\n      return new Uint8Array(\n        secp256k1.publicKeyCreate(Buffer.from(privateKey), compressed),\n      );\n    } catch {\n      return null;\n    }\n  }\n\n  protected validatePublicKey(publicKey: Uint8Array): boolean {\n    // Native secp256k1 returns true for valid, false for invalid\n    return secp256k1.publicKeyVerify(Buffer.from(publicKey)) === true;\n  }\n\n  protected decompressPublicKey(publicKey: Uint8Array): Uint8Array | null {\n    try {\n      // Convert to uncompressed format (65 bytes)\n      return new Uint8Array(\n        secp256k1.publicKeyConvert(Buffer.from(publicKey), false),\n      );\n    } catch {\n      return null;\n    }\n  }\n\n  protected performECDH(\n    publicKey: Uint8Array,\n    privateKey: Uint8Array,\n  ): Uint8Array {\n    try {\n      // Use pre-allocated buffer for output (32 bytes)\n      const output = Buffer.alloc(32);\n\n      // CRITICAL: Use identity hash to get raw X coordinate\n      // Default would apply SHA256 and break compatibility\n      secp256k1.ecdh(\n        Buffer.from(publicKey),\n        Buffer.from(privateKey),\n        { hashfn: this.identityHashFn },\n        output,\n      );\n\n      return new Uint8Array(output);\n    } catch (error) {\n      throw new Error(\n        `ECDH failed: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n  }\n\n  protected sha512(data: Uint8Array): Uint8Array {\n    // Use Node.js crypto for native performance\n    return new Uint8Array(\n      createHash(\"sha512\").update(Buffer.from(data)).digest(),\n    );\n  }\n\n  protected hmacSha256(key: Uint8Array, data: Uint8Array): Uint8Array {\n    // Use Node.js crypto for native performance\n    return new Uint8Array(\n      createHmac(\"sha256\", Buffer.from(key)).update(Buffer.from(data)).digest(),\n    );\n  }\n\n  protected async aesEncrypt(\n    key: Uint8Array,\n    iv: Uint8Array,\n    plaintext: Uint8Array,\n  ): Promise<Uint8Array> {\n    const cipher = createCipheriv(\n      \"aes-256-cbc\",\n      Buffer.from(key),\n      Buffer.from(iv),\n    );\n    const encrypted = Buffer.concat([\n      cipher.update(Buffer.from(plaintext)),\n      cipher.final(),\n    ]);\n    return new Uint8Array(encrypted);\n  }\n\n  protected async aesDecrypt(\n    key: Uint8Array,\n    iv: Uint8Array,\n    ciphertext: Uint8Array,\n  ): Promise<Uint8Array> {\n    const decipher = createDecipheriv(\n      \"aes-256-cbc\",\n      Buffer.from(key),\n      Buffer.from(iv),\n    );\n    const decrypted = Buffer.concat([\n      decipher.update(Buffer.from(ciphertext)),\n      decipher.final(),\n    ]);\n    return new Uint8Array(decrypted);\n  }\n\n  // No Buffer compatibility methods - Uint8Array only public API\n\n  /**\n   * Normalizes a public key to uncompressed format (65 bytes with 0x04 prefix).\n   * Handles compressed (33 bytes) and uncompressed (65 bytes) formats only.\n   *\n   * @remarks\n   * Strict policy: Does not accept 64-byte raw coordinates to avoid masking\n   * malformed data. Callers must provide properly formatted keys.\n   *\n   * @param publicKey - The public key to normalize (33 or 65 bytes)\n   * @returns The normalized uncompressed public key (65 bytes)\n   * @throws {Error} When public key format is invalid or decompression fails\n   */\n  normalizeToUncompressed(publicKey: Uint8Array): Uint8Array {\n    const len = publicKey.length;\n\n    // Already uncompressed\n    if (len === 65 && publicKey[0] === 0x04) {\n      return publicKey;\n    }\n\n    // Compressed - decompress using secp256k1\n    if (len === 33 && (publicKey[0] === 0x02 || publicKey[0] === 0x03)) {\n      const decompressed = this.decompressPublicKey(publicKey);\n      if (!decompressed) {\n        throw new Error(\n          `Failed to decompress public key with prefix 0x${publicKey[0].toString(16).padStart(2, \"0\")}`,\n        );\n      }\n      return decompressed;\n    }\n\n    // Reject raw coordinates (64 bytes) - require proper formatting\n    if (len === 64) {\n      throw new Error(\n        \"Raw public key coordinates (64 bytes) are not accepted. \" +\n          \"Please provide a properly formatted compressed (33 bytes) or uncompressed (65 bytes) public key.\",\n      );\n    }\n\n    throw new Error(\n      `Invalid public key format: expected compressed (33 bytes) or uncompressed (65 bytes), got ${len} bytes`,\n    );\n  }\n}\n"],"mappings":"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","names":["secp256k1Import"]}
+{"version":3,"sources":["../../../src/crypto/ecies/node.ts"],"sourcesContent":["/**\n * Node.js implementation of ECIES using native secp256k1 for performance\n *\n * @remarks\n * Uses native secp256k1 bindings for all elliptic curve operations.\n * Uses Node.js crypto module for hashing and AES operations.\n * Provides Uint8Array-only interface with no Buffer exposure.\n */\n\nimport {\n  randomBytes,\n  createHash,\n  createHmac,\n  createCipheriv,\n  createDecipheriv,\n} from \"crypto\";\nimport secp256k1Import from \"secp256k1\";\nimport { BaseECIESUint8 } from \"./base\";\nimport { toHex } from \"viem\";\n\n// Type definition for secp256k1 module\ninterface Secp256k1Module {\n  privateKeyVerify(privateKey: Buffer): boolean;\n  publicKeyCreate(privateKey: Buffer, compressed: boolean): Buffer;\n  publicKeyVerify(publicKey: Buffer): boolean;\n  publicKeyConvert(publicKey: Buffer, compressed: boolean): Buffer;\n  ecdh(\n    publicKey: Buffer,\n    privateKey: Buffer,\n    options: {\n      hashfn: (x: Uint8Array, y: Uint8Array, output?: Uint8Array) => Uint8Array;\n    },\n    output: Buffer,\n  ): Buffer;\n}\n\n// Use the imported secp256k1 module\nconst secp256k1 = secp256k1Import as unknown as Secp256k1Module;\n\n/**\n * Node.js-specific ECIES provider using native secp256k1\n *\n * @remarks\n * This implementation:\n * - Uses native secp256k1 for all EC operations (optimal performance)\n * - Uses Node.js crypto for SHA-512, HMAC, and AES operations\n * - Internally works with Uint8Array\n * - Only uses Buffer at crypto API boundaries\n */\nexport class NodeECIESUint8Provider extends BaseECIESUint8 {\n  // Identity hash function for ECDH - returns raw X coordinate\n  // CRITICAL: Must handle (x, y, output) signature correctly\n  private readonly identityHashFn = (\n    x: Uint8Array,\n    _y: Uint8Array,\n    output?: Uint8Array,\n  ): Uint8Array => {\n    // Copy x into output buffer if provided (prevents allocations)\n    if (output && output.length >= 32) {\n      output.set(x);\n      return output;\n    }\n    return x;\n  };\n  protected generateRandomBytes(length: number): Uint8Array {\n    return new Uint8Array(randomBytes(length));\n  }\n\n  protected verifyPrivateKey(privateKey: Uint8Array): boolean {\n    // Native secp256k1 returns true for valid, false for invalid\n    return secp256k1.privateKeyVerify(Buffer.from(privateKey)) === true;\n  }\n\n  protected createPublicKey(\n    privateKey: Uint8Array,\n    compressed: boolean,\n  ): Uint8Array | null {\n    try {\n      return new Uint8Array(\n        secp256k1.publicKeyCreate(Buffer.from(privateKey), compressed),\n      );\n    } catch {\n      return null;\n    }\n  }\n\n  protected validatePublicKey(publicKey: Uint8Array): boolean {\n    // Native secp256k1 returns true for valid, false for invalid\n    return secp256k1.publicKeyVerify(Buffer.from(publicKey)) === true;\n  }\n\n  protected decompressPublicKey(publicKey: Uint8Array): Uint8Array | null {\n    try {\n      // Convert to uncompressed format (65 bytes)\n      return new Uint8Array(\n        secp256k1.publicKeyConvert(Buffer.from(publicKey), false),\n      );\n    } catch {\n      return null;\n    }\n  }\n\n  protected performECDH(\n    publicKey: Uint8Array,\n    privateKey: Uint8Array,\n  ): Uint8Array {\n    try {\n      // Use pre-allocated buffer for output (32 bytes)\n      const output = Buffer.alloc(32);\n\n      // CRITICAL: Use identity hash to get raw X coordinate\n      // Default would apply SHA256 and break compatibility\n      secp256k1.ecdh(\n        Buffer.from(publicKey),\n        Buffer.from(privateKey),\n        { hashfn: this.identityHashFn },\n        output,\n      );\n\n      return new Uint8Array(output);\n    } catch (error) {\n      throw new Error(\n        `ECDH failed: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n  }\n\n  protected sha512(data: Uint8Array): Uint8Array {\n    // Use Node.js crypto for native performance\n    return new Uint8Array(\n      createHash(\"sha512\").update(Buffer.from(data)).digest(),\n    );\n  }\n\n  protected hmacSha256(key: Uint8Array, data: Uint8Array): Uint8Array {\n    // Use Node.js crypto for native performance\n    return new Uint8Array(\n      createHmac(\"sha256\", Buffer.from(key)).update(Buffer.from(data)).digest(),\n    );\n  }\n\n  protected async aesEncrypt(\n    key: Uint8Array,\n    iv: Uint8Array,\n    plaintext: Uint8Array,\n  ): Promise<Uint8Array> {\n    const cipher = createCipheriv(\n      \"aes-256-cbc\",\n      Buffer.from(key),\n      Buffer.from(iv),\n    );\n    const encrypted = Buffer.concat([\n      cipher.update(Buffer.from(plaintext)),\n      cipher.final(),\n    ]);\n    return new Uint8Array(encrypted);\n  }\n\n  protected async aesDecrypt(\n    key: Uint8Array,\n    iv: Uint8Array,\n    ciphertext: Uint8Array,\n  ): Promise<Uint8Array> {\n    const decipher = createDecipheriv(\n      \"aes-256-cbc\",\n      Buffer.from(key),\n      Buffer.from(iv),\n    );\n    const decrypted = Buffer.concat([\n      decipher.update(Buffer.from(ciphertext)),\n      decipher.final(),\n    ]);\n    return new Uint8Array(decrypted);\n  }\n\n  // No Buffer compatibility methods - Uint8Array only public API\n\n  /**\n   * Normalizes a public key to uncompressed format (65 bytes with 0x04 prefix).\n   * Handles compressed (33 bytes) and uncompressed (65 bytes) formats only.\n   *\n   * @remarks\n   * Strict policy: Does not accept 64-byte raw coordinates to avoid masking\n   * malformed data. Callers must provide properly formatted keys.\n   *\n   * @param publicKey - The public key to normalize (33 or 65 bytes)\n   * @returns The normalized uncompressed public key (65 bytes)\n   * @throws {Error} When public key format is invalid or decompression fails\n   */\n  normalizeToUncompressed(publicKey: Uint8Array): Uint8Array {\n    const len = publicKey.length;\n\n    // Already uncompressed\n    if (len === 65 && publicKey[0] === 0x04) {\n      return publicKey;\n    }\n\n    // Compressed - decompress using secp256k1\n    if (len === 33 && (publicKey[0] === 0x02 || publicKey[0] === 0x03)) {\n      const decompressed = this.decompressPublicKey(publicKey);\n      if (!decompressed) {\n        throw new Error(\n          `Failed to decompress public key with prefix ${toHex(publicKey[0])}`,\n        );\n      }\n      return decompressed;\n    }\n\n    // Reject raw coordinates (64 bytes) - require proper formatting\n    if (len === 64) {\n      throw new Error(\n        \"Raw public key coordinates (64 bytes) are not accepted. \" +\n          \"Please provide a properly formatted compressed (33 bytes) or uncompressed (65 bytes) public key.\",\n      );\n    }\n\n    throw new Error(\n      `Invalid public key format: expected compressed (33 bytes) or uncompressed (65 bytes), got ${len} bytes`,\n    );\n  }\n}\n"],"mappings":"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","names":["secp256k1Import"]}

package/dist/crypto/ecies/node.d.ts

@@ -1,6 +1,3 @@
-import { BaseECIESUint8 } from './base.js';
-import './interface.js';
-
 /**
  * Node.js implementation of ECIES using native secp256k1 for performance
  *
@@ -9,7 +6,7 @@ import './interface.js';
  * Uses Node.js crypto module for hashing and AES operations.
  * Provides Uint8Array-only interface with no Buffer exposure.
  */
-
+import { BaseECIESUint8 } from "./base";
 /**
  * Node.js-specific ECIES provider using native secp256k1
  *
@@ -20,7 +17,7 @@ import './interface.js';
  * - Internally works with Uint8Array
  * - Only uses Buffer at crypto API boundaries
  */
-declare class NodeECIESUint8Provider extends BaseECIESUint8 {
+export declare class NodeECIESUint8Provider extends BaseECIESUint8 {
     private readonly identityHashFn;
     protected generateRandomBytes(length: number): Uint8Array;
     protected verifyPrivateKey(privateKey: Uint8Array): boolean;
@@ -46,5 +43,3 @@ declare class NodeECIESUint8Provider extends BaseECIESUint8 {
      */
     normalizeToUncompressed(publicKey: Uint8Array): Uint8Array;
 }
-
-export { NodeECIESUint8Provider };

package/dist/crypto/ecies/node.js

@@ -1,6 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import {
   randomBytes,
   createHash,
@@ -10,20 +7,18 @@ import {
 } from "crypto";
 import secp256k1Import from "secp256k1";
 import { BaseECIESUint8 } from "./base";
+import { toHex } from "viem";
 const secp256k1 = secp256k1Import;
 class NodeECIESUint8Provider extends BaseECIESUint8 {
-  constructor() {
-    super(...arguments);
-    // Identity hash function for ECDH - returns raw X coordinate
-    // CRITICAL: Must handle (x, y, output) signature correctly
-    __publicField(this, "identityHashFn", (x, y, output) => {
-      if (output && output.length >= 32) {
-        output.set(x);
-        return output;
-      }
-      return x;
-    });
-  }
+  // Identity hash function for ECDH - returns raw X coordinate
+  // CRITICAL: Must handle (x, y, output) signature correctly
+  identityHashFn = (x, _y, output) => {
+    if (output && output.length >= 32) {
+      output.set(x);
+      return output;
+    }
+    return x;
+  };
   generateRandomBytes(length) {
     return new Uint8Array(randomBytes(length));
   }
@@ -123,7 +118,7 @@ class NodeECIESUint8Provider extends BaseECIESUint8 {
       const decompressed = this.decompressPublicKey(publicKey);
       if (!decompressed) {
         throw new Error(
-          `Failed to decompress public key with prefix 0x${publicKey[0].toString(16).padStart(2, "0")}`
+          `Failed to decompress public key with prefix ${toHex(publicKey[0])}`
         );
       }
       return decompressed;

package/dist/crypto/ecies/node.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/crypto/ecies/node.ts"],"sourcesContent":["/**\n * Node.js implementation of ECIES using native secp256k1 for performance\n *\n * @remarks\n * Uses native secp256k1 bindings for all elliptic curve operations.\n * Uses Node.js crypto module for hashing and AES operations.\n * Provides Uint8Array-only interface with no Buffer exposure.\n */\n\nimport {\n  randomBytes,\n  createHash,\n  createHmac,\n  createCipheriv,\n  createDecipheriv,\n} from \"crypto\";\nimport secp256k1Import from \"secp256k1\";\nimport { BaseECIESUint8 } from \"./base\";\n\n// Type definition for secp256k1 module\ninterface Secp256k1Module {\n  privateKeyVerify(privateKey: Buffer): boolean;\n  publicKeyCreate(privateKey: Buffer, compressed: boolean): Buffer;\n  publicKeyVerify(publicKey: Buffer): boolean;\n  publicKeyConvert(publicKey: Buffer, compressed: boolean): Buffer;\n  ecdh(\n    publicKey: Buffer,\n    privateKey: Buffer,\n    options: {\n      hashfn: (x: Uint8Array, y: Uint8Array, output?: Uint8Array) => Uint8Array;\n    },\n    output: Buffer,\n  ): Buffer;\n}\n\n// Use the imported secp256k1 module\nconst secp256k1 = secp256k1Import as unknown as Secp256k1Module;\n\n/**\n * Node.js-specific ECIES provider using native secp256k1\n *\n * @remarks\n * This implementation:\n * - Uses native secp256k1 for all EC operations (optimal performance)\n * - Uses Node.js crypto for SHA-512, HMAC, and AES operations\n * - Internally works with Uint8Array\n * - Only uses Buffer at crypto API boundaries\n */\nexport class NodeECIESUint8Provider extends BaseECIESUint8 {\n  // Identity hash function for ECDH - returns raw X coordinate\n  // CRITICAL: Must handle (x, y, output) signature correctly\n  private readonly identityHashFn = (\n    x: Uint8Array,\n    y: Uint8Array,\n    output?: Uint8Array,\n  ): Uint8Array => {\n    // Copy x into output buffer if provided (prevents allocations)\n    if (output && output.length >= 32) {\n      output.set(x);\n      return output;\n    }\n    return x;\n  };\n  protected generateRandomBytes(length: number): Uint8Array {\n    return new Uint8Array(randomBytes(length));\n  }\n\n  protected verifyPrivateKey(privateKey: Uint8Array): boolean {\n    // Native secp256k1 returns true for valid, false for invalid\n    return secp256k1.privateKeyVerify(Buffer.from(privateKey)) === true;\n  }\n\n  protected createPublicKey(\n    privateKey: Uint8Array,\n    compressed: boolean,\n  ): Uint8Array | null {\n    try {\n      return new Uint8Array(\n        secp256k1.publicKeyCreate(Buffer.from(privateKey), compressed),\n      );\n    } catch {\n      return null;\n    }\n  }\n\n  protected validatePublicKey(publicKey: Uint8Array): boolean {\n    // Native secp256k1 returns true for valid, false for invalid\n    return secp256k1.publicKeyVerify(Buffer.from(publicKey)) === true;\n  }\n\n  protected decompressPublicKey(publicKey: Uint8Array): Uint8Array | null {\n    try {\n      // Convert to uncompressed format (65 bytes)\n      return new Uint8Array(\n        secp256k1.publicKeyConvert(Buffer.from(publicKey), false),\n      );\n    } catch {\n      return null;\n    }\n  }\n\n  protected performECDH(\n    publicKey: Uint8Array,\n    privateKey: Uint8Array,\n  ): Uint8Array {\n    try {\n      // Use pre-allocated buffer for output (32 bytes)\n      const output = Buffer.alloc(32);\n\n      // CRITICAL: Use identity hash to get raw X coordinate\n      // Default would apply SHA256 and break compatibility\n      secp256k1.ecdh(\n        Buffer.from(publicKey),\n        Buffer.from(privateKey),\n        { hashfn: this.identityHashFn },\n        output,\n      );\n\n      return new Uint8Array(output);\n    } catch (error) {\n      throw new Error(\n        `ECDH failed: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n  }\n\n  protected sha512(data: Uint8Array): Uint8Array {\n    // Use Node.js crypto for native performance\n    return new Uint8Array(\n      createHash(\"sha512\").update(Buffer.from(data)).digest(),\n    );\n  }\n\n  protected hmacSha256(key: Uint8Array, data: Uint8Array): Uint8Array {\n    // Use Node.js crypto for native performance\n    return new Uint8Array(\n      createHmac(\"sha256\", Buffer.from(key)).update(Buffer.from(data)).digest(),\n    );\n  }\n\n  protected async aesEncrypt(\n    key: Uint8Array,\n    iv: Uint8Array,\n    plaintext: Uint8Array,\n  ): Promise<Uint8Array> {\n    const cipher = createCipheriv(\n      \"aes-256-cbc\",\n      Buffer.from(key),\n      Buffer.from(iv),\n    );\n    const encrypted = Buffer.concat([\n      cipher.update(Buffer.from(plaintext)),\n      cipher.final(),\n    ]);\n    return new Uint8Array(encrypted);\n  }\n\n  protected async aesDecrypt(\n    key: Uint8Array,\n    iv: Uint8Array,\n    ciphertext: Uint8Array,\n  ): Promise<Uint8Array> {\n    const decipher = createDecipheriv(\n      \"aes-256-cbc\",\n      Buffer.from(key),\n      Buffer.from(iv),\n    );\n    const decrypted = Buffer.concat([\n      decipher.update(Buffer.from(ciphertext)),\n      decipher.final(),\n    ]);\n    return new Uint8Array(decrypted);\n  }\n\n  // No Buffer compatibility methods - Uint8Array only public API\n\n  /**\n   * Normalizes a public key to uncompressed format (65 bytes with 0x04 prefix).\n   * Handles compressed (33 bytes) and uncompressed (65 bytes) formats only.\n   *\n   * @remarks\n   * Strict policy: Does not accept 64-byte raw coordinates to avoid masking\n   * malformed data. Callers must provide properly formatted keys.\n   *\n   * @param publicKey - The public key to normalize (33 or 65 bytes)\n   * @returns The normalized uncompressed public key (65 bytes)\n   * @throws {Error} When public key format is invalid or decompression fails\n   */\n  normalizeToUncompressed(publicKey: Uint8Array): Uint8Array {\n    const len = publicKey.length;\n\n    // Already uncompressed\n    if (len === 65 && publicKey[0] === 0x04) {\n      return publicKey;\n    }\n\n    // Compressed - decompress using secp256k1\n    if (len === 33 && (publicKey[0] === 0x02 || publicKey[0] === 0x03)) {\n      const decompressed = this.decompressPublicKey(publicKey);\n      if (!decompressed) {\n        throw new Error(\n          `Failed to decompress public key with prefix 0x${publicKey[0].toString(16).padStart(2, \"0\")}`,\n        );\n      }\n      return decompressed;\n    }\n\n    // Reject raw coordinates (64 bytes) - require proper formatting\n    if (len === 64) {\n      throw new Error(\n        \"Raw public key coordinates (64 bytes) are not accepted. \" +\n          \"Please provide a properly formatted compressed (33 bytes) or uncompressed (65 bytes) public key.\",\n      );\n    }\n\n    throw new Error(\n      `Invalid public key format: expected compressed (33 bytes) or uncompressed (65 bytes), got ${len} bytes`,\n    );\n  }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../../src/crypto/ecies/node.ts"],"sourcesContent":["/**\n * Node.js implementation of ECIES using native secp256k1 for performance\n *\n * @remarks\n * Uses native secp256k1 bindings for all elliptic curve operations.\n * Uses Node.js crypto module for hashing and AES operations.\n * Provides Uint8Array-only interface with no Buffer exposure.\n */\n\nimport {\n  randomBytes,\n  createHash,\n  createHmac,\n  createCipheriv,\n  createDecipheriv,\n} from \"crypto\";\nimport secp256k1Import from \"secp256k1\";\nimport { BaseECIESUint8 } from \"./base\";\nimport { toHex } from \"viem\";\n\n// Type definition for secp256k1 module\ninterface Secp256k1Module {\n  privateKeyVerify(privateKey: Buffer): boolean;\n  publicKeyCreate(privateKey: Buffer, compressed: boolean): Buffer;\n  publicKeyVerify(publicKey: Buffer): boolean;\n  publicKeyConvert(publicKey: Buffer, compressed: boolean): Buffer;\n  ecdh(\n    publicKey: Buffer,\n    privateKey: Buffer,\n    options: {\n      hashfn: (x: Uint8Array, y: Uint8Array, output?: Uint8Array) => Uint8Array;\n    },\n    output: Buffer,\n  ): Buffer;\n}\n\n// Use the imported secp256k1 module\nconst secp256k1 = secp256k1Import as unknown as Secp256k1Module;\n\n/**\n * Node.js-specific ECIES provider using native secp256k1\n *\n * @remarks\n * This implementation:\n * - Uses native secp256k1 for all EC operations (optimal performance)\n * - Uses Node.js crypto for SHA-512, HMAC, and AES operations\n * - Internally works with Uint8Array\n * - Only uses Buffer at crypto API boundaries\n */\nexport class NodeECIESUint8Provider extends BaseECIESUint8 {\n  // Identity hash function for ECDH - returns raw X coordinate\n  // CRITICAL: Must handle (x, y, output) signature correctly\n  private readonly identityHashFn = (\n    x: Uint8Array,\n    _y: Uint8Array,\n    output?: Uint8Array,\n  ): Uint8Array => {\n    // Copy x into output buffer if provided (prevents allocations)\n    if (output && output.length >= 32) {\n      output.set(x);\n      return output;\n    }\n    return x;\n  };\n  protected generateRandomBytes(length: number): Uint8Array {\n    return new Uint8Array(randomBytes(length));\n  }\n\n  protected verifyPrivateKey(privateKey: Uint8Array): boolean {\n    // Native secp256k1 returns true for valid, false for invalid\n    return secp256k1.privateKeyVerify(Buffer.from(privateKey)) === true;\n  }\n\n  protected createPublicKey(\n    privateKey: Uint8Array,\n    compressed: boolean,\n  ): Uint8Array | null {\n    try {\n      return new Uint8Array(\n        secp256k1.publicKeyCreate(Buffer.from(privateKey), compressed),\n      );\n    } catch {\n      return null;\n    }\n  }\n\n  protected validatePublicKey(publicKey: Uint8Array): boolean {\n    // Native secp256k1 returns true for valid, false for invalid\n    return secp256k1.publicKeyVerify(Buffer.from(publicKey)) === true;\n  }\n\n  protected decompressPublicKey(publicKey: Uint8Array): Uint8Array | null {\n    try {\n      // Convert to uncompressed format (65 bytes)\n      return new Uint8Array(\n        secp256k1.publicKeyConvert(Buffer.from(publicKey), false),\n      );\n    } catch {\n      return null;\n    }\n  }\n\n  protected performECDH(\n    publicKey: Uint8Array,\n    privateKey: Uint8Array,\n  ): Uint8Array {\n    try {\n      // Use pre-allocated buffer for output (32 bytes)\n      const output = Buffer.alloc(32);\n\n      // CRITICAL: Use identity hash to get raw X coordinate\n      // Default would apply SHA256 and break compatibility\n      secp256k1.ecdh(\n        Buffer.from(publicKey),\n        Buffer.from(privateKey),\n        { hashfn: this.identityHashFn },\n        output,\n      );\n\n      return new Uint8Array(output);\n    } catch (error) {\n      throw new Error(\n        `ECDH failed: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n  }\n\n  protected sha512(data: Uint8Array): Uint8Array {\n    // Use Node.js crypto for native performance\n    return new Uint8Array(\n      createHash(\"sha512\").update(Buffer.from(data)).digest(),\n    );\n  }\n\n  protected hmacSha256(key: Uint8Array, data: Uint8Array): Uint8Array {\n    // Use Node.js crypto for native performance\n    return new Uint8Array(\n      createHmac(\"sha256\", Buffer.from(key)).update(Buffer.from(data)).digest(),\n    );\n  }\n\n  protected async aesEncrypt(\n    key: Uint8Array,\n    iv: Uint8Array,\n    plaintext: Uint8Array,\n  ): Promise<Uint8Array> {\n    const cipher = createCipheriv(\n      \"aes-256-cbc\",\n      Buffer.from(key),\n      Buffer.from(iv),\n    );\n    const encrypted = Buffer.concat([\n      cipher.update(Buffer.from(plaintext)),\n      cipher.final(),\n    ]);\n    return new Uint8Array(encrypted);\n  }\n\n  protected async aesDecrypt(\n    key: Uint8Array,\n    iv: Uint8Array,\n    ciphertext: Uint8Array,\n  ): Promise<Uint8Array> {\n    const decipher = createDecipheriv(\n      \"aes-256-cbc\",\n      Buffer.from(key),\n      Buffer.from(iv),\n    );\n    const decrypted = Buffer.concat([\n      decipher.update(Buffer.from(ciphertext)),\n      decipher.final(),\n    ]);\n    return new Uint8Array(decrypted);\n  }\n\n  // No Buffer compatibility methods - Uint8Array only public API\n\n  /**\n   * Normalizes a public key to uncompressed format (65 bytes with 0x04 prefix).\n   * Handles compressed (33 bytes) and uncompressed (65 bytes) formats only.\n   *\n   * @remarks\n   * Strict policy: Does not accept 64-byte raw coordinates to avoid masking\n   * malformed data. Callers must provide properly formatted keys.\n   *\n   * @param publicKey - The public key to normalize (33 or 65 bytes)\n   * @returns The normalized uncompressed public key (65 bytes)\n   * @throws {Error} When public key format is invalid or decompression fails\n   */\n  normalizeToUncompressed(publicKey: Uint8Array): Uint8Array {\n    const len = publicKey.length;\n\n    // Already uncompressed\n    if (len === 65 && publicKey[0] === 0x04) {\n      return publicKey;\n    }\n\n    // Compressed - decompress using secp256k1\n    if (len === 33 && (publicKey[0] === 0x02 || publicKey[0] === 0x03)) {\n      const decompressed = this.decompressPublicKey(publicKey);\n      if (!decompressed) {\n        throw new Error(\n          `Failed to decompress public key with prefix ${toHex(publicKey[0])}`,\n        );\n      }\n      return decompressed;\n    }\n\n    // Reject raw coordinates (64 bytes) - require proper formatting\n    if (len === 64) {\n      throw new Error(\n        \"Raw public key coordinates (64 bytes) are not accepted. \" +\n          \"Please provide a properly formatted compressed (33 bytes) or uncompressed (65 bytes) public key.\",\n      );\n    }\n\n    throw new Error(\n      `Invalid public key format: expected compressed (33 bytes) or uncompressed (65 bytes), got ${len} bytes`,\n    );\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/crypto/ecies/test-vectors/eccrypto-vectors.json

@@ -0,0 +1,72 @@
+{
+  "metadata": {
+    "generated": "2025-08-17T15:03:45.067Z",
+    "eccryptoVersion": "1.1.6",
+    "description": "Test vectors from eccrypto to ensure backward compatibility",
+    "format": "eccrypto ECIES format: [iv(16)] [ephemPublicKey(65)] [ciphertext(variable)] [mac(32)]"
+  },
+  "vectors": [
+    {
+      "name": "Simple text message",
+      "privateKey": "1878693c39d810ce44ee40f9fdd068a0414615e74a7ff58adaba74063b2402e4",
+      "publicKey": "0486c0312c4609fc3d53c35cbd1b7af82c8900c056a0389e1697720e3b60284aa2996a6c16c9b65eeb830c9016c5ab49481a406c88666de95f8fc236d0cbb7bb79",
+      "message": "48656c6c6f2c20454349455321",
+      "encrypted": {
+        "iv": "9da6a7f84a8a192eeb787fd5907bf23a",
+        "ephemPublicKey": "0442fdf37e36007921c07e5447bdae847f04a46e7bde3f3c8cca37d2766633d8e52c734a183d5e61f24bd50c677c8bd9491ba46a29c97b5d3c4dce93477c66deb6",
+        "ciphertext": "44070d8d4d2dc7ac70c77732c22b87aa",
+        "mac": "901a65fb7c13995727904e99618d73de370d37913e0c33fc38c9c87737ccdf8a"
+      }
+    },
+    {
+      "name": "Binary data (64 bytes)",
+      "privateKey": "21796c4692ba9d34b7f273c0099b96625e8dec49ada0390724d23dc35f4986d1",
+      "publicKey": "04ab33f0e766d672f89c844633eb491e1ce75bce281423c11e1247503374e42f4b3877fab9a5b762ac78c8a639a0277d178280e580ffa992056b6d2ed3679f18ef",
+      "message": "0b35fb489cd6f2bd6ab923382053a2cffc1054371a8009cae0009a8fc4c75ecc52e937d6571ea9e29d40c29cffd2cf2a0a14021871017a6ac171e48d7feda637",
+      "encrypted": {
+        "iv": "a9e389c20c31d8aed19da6367a7d28e8",
+        "ephemPublicKey": "04fd61f7e70726779fd8e13bcbd5a41d2d8d7e3d24053eef6493bbae390e05e1a6fce46b6012549edcc267c5b6aa64f747b9466bcf086695c5a1344dcb187c41a2",
+        "ciphertext": "1c233cdaa6514370daaf3371c2f566522181c115bb445883caa0e97d205a46741c1d0726901da59978c346da826ccd7ff4c1d92742f43adef98faf5f7498c3ad811d3dda1f5e8be425051d4fb973bc3c",
+        "mac": "f18a5a0338c4a9c1b5242949873095a6d0ef2707918d05d89f745f27ed119c73"
+      }
+    },
+    {
+      "name": "Large data (1KB)",
+      "privateKey": "ae1a9ea14589c1d18c6f4c9683d4ee970d389cac2844cece049e1a2f5ee3f62e",
+      "publicKey": "045c0e8e526fba2c2aa05834c06db12d737bcb899f7763d46690f36eadb490c3ba4cdaf0bcb8799b903378dc5f9d350bbe3b935e5f323be3d477c9deb4fdb05212",
+      "message": "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",
+      "encrypted": {
+        "iv": "fb1452dae55b431b99a88376dbd732b8",
+        "ephemPublicKey": "04698c369bf59ef9477d1aa837cd384eb7768e76de2de7fc37d5b5abe1c7f81cd37453359979b7fc3947dd2bd499fe01bcaab265b0970f99150380f48ecfe5fc13",
+        "ciphertext": "87eb187e200fe08714ff110586afcce49f3f98045f44b6c5f752b25550cc96323808200b7e766cbc8af9b704252eaca6aeddbd4fc1da03118afb525c8fda4fdd354250f965a8ab02d1d66fb624ccaffa033aa7db4e151833075a81ecd43483f05e4bb8f46e4f1e5ea780ff0bcee3bc31d0d41851a43184e9e0bd499b03750445b8467a4085b056381ac04a11fda032b96fb1c90cf3c05bc3470a319568b8ddc993f822f7366e11ce326b5d9da9c72039a6e8746382f10c8bd8e1637d61c75bec11121457e29fabcc2a17ac613f5c8a2dcab3f3c1b2687f5c66deb29f95f0f4e1c83ce2c8d65a7f5139c04110f691e8d4eafa4f6891a6da1fa5f575e5c4fe7c350bffbd43df796b40b7d2804b883572695c2d1a384517500a42b10ecb512f4fba28f90a7c745f2dcd7193dfe91439aa54864be5273cd18e07c28c9fd117682765a78f8aae43edc378388098622628fbc7b7824a70dc8599400d45a850130e52363e8e1818626079e31593e67a2f5e1a5eae17dd52ca03680676b7db18bd0295a8f24ced48e5b57b7112fd4931898a5f8866b08ad4f647925586e16a3bb775316cde7bc298725e4c0fb0d66421e6dfde9d495bc3e4f7eea20fa184e2befd7499158e135e43afff610d310c9318a7c61858b09d51a7878dec4976d7647ab548819e91abb01971a77869ee16282b18cf323d3853846e509434a69fce2f378e286fa9a85f43938d961b9b95c9936f21e70a2164db96d6d6e6fa23ea742559abc01ea1b82ff8bb855cb350d894581818640e0d563bdf8e14dd80a43f46f8213e18377be29f4bea6ce2b2f3038be944a61cd8d82c3bf738f3800189e5aa41e1ddad4d6c2fca33c67bc11d9fec2296e8bab773bbc8b1127b74764ba16fcfd40d28ca43f8e8fc9bca197d5571196296e674091ff2ac93839a01d5650d1dbf851cfb6726c65847b39b4ec781794e1f54e12ec837cf773b4313566f665f80a0db3f299891b7c25bb733d52f7c2199b614669a4ae2eff3e2bd99806487178864c7acab76fdf09a406ca117d83f0f412af66e05152d4339f3d2f705976419cb5e75bc5d5e13b279e3b6065b83f61a0bd891d7932dbe802ee5390fc7b7ca3d117c14f6c3786e3578545583eef5107ea4fadf306c460c93bc1f96df692c988e9ce22329eec36bafbb8cfa3ddb30e3e33d71eb86830f54cf2a680b127f65e96b3842f966c466c705ce64450ab8d885f68c645046fbff85914f94ed72b92937d70f686abd933183974dc1086af958322d375d1728cea8902e00a0600f12c6b593f1382c61f97233bba6cd45392690a1c5d03f1b4aadacd1e723a5785850bb79d9e3f341e388b099947b61cf9ac83db5b8f01c888f245ed6a23f8dc519920b52576670ee567a923e68bd32a7c2ac364c342551060de4efcba0a078c40c7a8ec9db4a03bf5cc578ece351c6da0553341bbc89bb871c90ab2a45",
+        "mac": "faafe7a325f36260015408ef2d859f71628cb7ff5287c6f3ccf6eadba27abe3f"
+      }
+    },
+    {
+      "name": "UTF-8 text with special characters",
+      "privateKey": "d447811abc5bae2fd9c53f97569c50338108154cfa36f18fdbc300bcad37f493",
+      "publicKey": "045cb6eecff8afd418c2e590a956dae270a0342a9b1c9180f1500f7719da4b17702eed93f08415ebcf65036af2dc14f677e79aaa1cff54828285ff8686bc6c72bc",
+      "message": "48656c6c6f20e4b896e7958c2120f09f8e89205370656369616c2063686172733a20c3a0c3a9c3aec3b5c3bc",
+      "messageText": "Hello 世界! 🎉 Special chars: àéîõü",
+      "encrypted": {
+        "iv": "a6f108c025f8e041a79f085aa42e2a92",
+        "ephemPublicKey": "041cfe2092b3d086b60b15a74ab9850878d02dfb0b72976e593027fb6cfdef2634fffdd67639b02bd8c1ed222d22f3eaf8b2f262c38415ddc97629fc7c818670d7",
+        "ciphertext": "5b675b04b3a7d93883a9dc0962b47d421966a8fe400c2125b17d30e93b6a8999fb8fe7e82bf7c63fd08092debaafba3c",
+        "mac": "e786868550c316b5f31f696bf1aa2f7c59b795033456205f71603cc4d3a0a95b"
+      }
+    },
+    {
+      "name": "Known private key test",
+      "privateKey": "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+      "publicKey": "04bb50e2d89a4ed70663d080659fe0ad4b9bc3e06c17a227433966cb59ceee020decddbf6e00192011648d13b1c00af770c0c1bb609d4d3a5c98a43772e0e18ef4",
+      "message": "54657374206d6573736167652077697468206b6e6f776e206b6579",
+      "messageText": "Test message with known key",
+      "encrypted": {
+        "iv": "c8dffc7f392098524aa6acec38f36835",
+        "ephemPublicKey": "04b663805d764f8cde462c54019dc76d2f4ec6389f2ee5ca6bf9e13d12fc75c059390c624ae7d35ef2fd6bea4f5a93ccc0fc3a505d222490d9091de379cf2bd3c4",
+        "ciphertext": "2beecd177fffa8e07bd1119a208d3303a5a4b24f516b03876bbd319f4b32f1ec",
+        "mac": "ace56259ef19fe19aee629eac25327a6b4832ae258521e4dc41823dde910e86d"
+      }
+    }
+  ]
+}

package/dist/crypto/ecies/utils.cjs

@@ -20,43 +20,9 @@ var utils_exports = {};
 __export(utils_exports, {
   bufferToBytes: () => bufferToBytes,
   bytesToBuffer: () => bytesToBuffer,
-  bytesToHex: () => bytesToHex,
-  bytesToString: () => bytesToString,
-  concatBytes: () => concatBytes,
-  constantTimeEqual: () => constantTimeEqual,
-  hexToBytes: () => hexToBytes,
-  stringToBytes: () => stringToBytes
+  constantTimeEqual: () => constantTimeEqual
 });
 module.exports = __toCommonJS(utils_exports);
-function hexToBytes(hex) {
-  if (hex.length % 2 !== 0) {
-    throw new Error("Hex string must have even length");
-  }
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-  }
-  return bytes;
-}
-function bytesToHex(bytes) {
-  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function stringToBytes(str) {
-  return new TextEncoder().encode(str);
-}
-function bytesToString(bytes) {
-  return new TextDecoder().decode(bytes);
-}
-function concatBytes(...arrays) {
-  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
 function constantTimeEqual(a, b) {
   if (a.length !== b.length) return false;
   let result = 0;
@@ -81,11 +47,6 @@ function bytesToBuffer(bytes) {
 0 && (module.exports = {
   bufferToBytes,
   bytesToBuffer,
-  bytesToHex,
-  bytesToString,
-  concatBytes,
-  constantTimeEqual,
-  hexToBytes,
-  stringToBytes
+  constantTimeEqual
 });
 //# sourceMappingURL=utils.cjs.map

package/dist/crypto/ecies/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/crypto/ecies/utils.ts"],"sourcesContent":["/**\n * Utility functions for ECIES operations\n *\n * Provides conversion utilities between different data formats\n * to bridge platform-specific implementations.\n */\n\n/**\n * Converts a hex string to Uint8Array\n *\n * @param hex - Hex string to convert\n * @returns Uint8Array representation of the hex string\n */\nexport function hexToBytes(hex: string): Uint8Array {\n  if (hex.length % 2 !== 0) {\n    throw new Error(\"Hex string must have even length\");\n  }\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < hex.length; i += 2) {\n    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);\n  }\n  return bytes;\n}\n\n/**\n * Converts Uint8Array to hex string\n *\n * @param bytes - Bytes to convert to hex\n * @returns Hex string representation\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n  return Array.from(bytes)\n    .map((b) => b.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n}\n\n/**\n * Converts a string to Uint8Array using UTF-8 encoding\n *\n * @param str - String to convert\n * @returns UTF-8 encoded bytes\n */\nexport function stringToBytes(str: string): Uint8Array {\n  return new TextEncoder().encode(str);\n}\n\n/**\n * Converts Uint8Array to string using UTF-8 decoding\n *\n * @param bytes - Bytes to decode\n * @returns Decoded UTF-8 string\n */\nexport function bytesToString(bytes: Uint8Array): string {\n  return new TextDecoder().decode(bytes);\n}\n\n/**\n * Concatenates multiple Uint8Arrays into one\n *\n * @param arrays - Arrays to concatenate\n * @returns Concatenated Uint8Array\n */\nexport function concatBytes(...arrays: Uint8Array[]): Uint8Array {\n  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);\n  const result = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const arr of arrays) {\n    result.set(arr, offset);\n    offset += arr.length;\n  }\n  return result;\n}\n\n/**\n * Checks if two Uint8Arrays are equal in constant time\n *\n * @param a - First array to compare\n * @param b - Second array to compare\n * @returns `true` if arrays are equal\n */\nexport function constantTimeEqual(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) return false;\n  let result = 0;\n  for (let i = 0; i < a.length; i++) {\n    result |= a[i] ^ b[i];\n  }\n  return result === 0;\n}\n\n/**\n * Converts Buffer to Uint8Array (for Node.js compatibility layer)\n * In browser, this is a no-op if already Uint8Array\n *\n * @param buffer - Buffer or Uint8Array to convert\n * @returns Uint8Array representation\n */\nexport function bufferToBytes(buffer: Buffer | Uint8Array): Uint8Array {\n  if (buffer instanceof Uint8Array) {\n    return buffer;\n  }\n  // Node.js Buffer is a subclass of Uint8Array\n  return new Uint8Array(buffer);\n}\n\n/**\n * Converts Uint8Array to Buffer (for Node.js compatibility layer)\n * Only available in Node.js environment\n *\n * @param bytes - Uint8Array to convert to Buffer\n * @returns Buffer representation\n */\nexport function bytesToBuffer(bytes: Uint8Array): Buffer {\n  if (typeof Buffer === \"undefined\") {\n    throw new Error(\"Buffer is not available in browser environment\");\n  }\n  return Buffer.from(bytes);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaO,SAAS,WAAW,KAAyB;AAClD,MAAI,IAAI,SAAS,MAAM,GAAG;AACxB,UAAM,IAAI,MAAM,kCAAkC;AAAA,EACpD;AACA,QAAM,QAAQ,IAAI,WAAW,IAAI,SAAS,CAAC;AAC3C,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK,GAAG;AACtC,UAAM,IAAI,CAAC,IAAI,SAAS,IAAI,OAAO,GAAG,CAAC,GAAG,EAAE;AAAA,EAC9C;AACA,SAAO;AACT;AAQO,SAAS,WAAW,OAA2B;AACpD,SAAO,MAAM,KAAK,KAAK,EACpB,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAC1C,KAAK,EAAE;AACZ;AAQO,SAAS,cAAc,KAAyB;AACrD,SAAO,IAAI,YAAY,EAAE,OAAO,GAAG;AACrC;AAQO,SAAS,cAAc,OAA2B;AACvD,SAAO,IAAI,YAAY,EAAE,OAAO,KAAK;AACvC;AAQO,SAAS,eAAe,QAAkC;AAC/D,QAAM,cAAc,OAAO,OAAO,CAAC,KAAK,QAAQ,MAAM,IAAI,QAAQ,CAAC;AACnE,QAAM,SAAS,IAAI,WAAW,WAAW;AACzC,MAAI,SAAS;AACb,aAAW,OAAO,QAAQ;AACxB,WAAO,IAAI,KAAK,MAAM;AACtB,cAAU,IAAI;AAAA,EAChB;AACA,SAAO;AACT;AASO,SAAS,kBAAkB,GAAe,GAAwB;AACvE,MAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,cAAU,EAAE,CAAC,IAAI,EAAE,CAAC;AAAA,EACtB;AACA,SAAO,WAAW;AACpB;AASO,SAAS,cAAc,QAAyC;AACrE,MAAI,kBAAkB,YAAY;AAChC,WAAO;AAAA,EACT;AAEA,SAAO,IAAI,WAAW,MAAM;AAC9B;AASO,SAAS,cAAc,OAA2B;AACvD,MAAI,OAAO,WAAW,aAAa;AACjC,UAAM,IAAI,MAAM,gDAAgD;AAAA,EAClE;AACA,SAAO,OAAO,KAAK,KAAK;AAC1B;","names":[]}
+{"version":3,"sources":["../../../src/crypto/ecies/utils.ts"],"sourcesContent":["/**\n * Utility functions for ECIES operations\n *\n * Provides conversion utilities between different data formats\n * to bridge platform-specific implementations.\n */\n\n/**\n * Checks if two Uint8Arrays are equal in constant time\n *\n * @param a - First array to compare\n * @param b - Second array to compare\n * @returns `true` if arrays are equal\n */\nexport function constantTimeEqual(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) return false;\n  let result = 0;\n  for (let i = 0; i < a.length; i++) {\n    result |= a[i] ^ b[i];\n  }\n  return result === 0;\n}\n\n/**\n * Converts Buffer to Uint8Array (for Node.js compatibility layer)\n * In browser, this is a no-op if already Uint8Array\n *\n * @param buffer - Buffer or Uint8Array to convert\n * @returns Uint8Array representation\n */\nexport function bufferToBytes(buffer: Buffer | Uint8Array): Uint8Array {\n  if (buffer instanceof Uint8Array) {\n    return buffer;\n  }\n  // Node.js Buffer is a subclass of Uint8Array\n  return new Uint8Array(buffer);\n}\n\n/**\n * Converts Uint8Array to Buffer (for Node.js compatibility layer)\n * Only available in Node.js environment\n *\n * @param bytes - Uint8Array to convert to Buffer\n * @returns Buffer representation\n */\nexport function bytesToBuffer(bytes: Uint8Array): Buffer {\n  if (typeof Buffer === \"undefined\") {\n    throw new Error(\"Buffer is not available in browser environment\");\n  }\n  return Buffer.from(bytes);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAcO,SAAS,kBAAkB,GAAe,GAAwB;AACvE,MAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,cAAU,EAAE,CAAC,IAAI,EAAE,CAAC;AAAA,EACtB;AACA,SAAO,WAAW;AACpB;AASO,SAAS,cAAc,QAAyC;AACrE,MAAI,kBAAkB,YAAY;AAChC,WAAO;AAAA,EACT;AAEA,SAAO,IAAI,WAAW,MAAM;AAC9B;AASO,SAAS,cAAc,OAA2B;AACvD,MAAI,OAAO,WAAW,aAAa;AACjC,UAAM,IAAI,MAAM,gDAAgD;AAAA,EAClE;AACA,SAAO,OAAO,KAAK,KAAK;AAC1B;","names":[]}

package/dist/crypto/ecies/utils.d.ts

@@ -4,41 +4,6 @@
  * Provides conversion utilities between different data formats
  * to bridge platform-specific implementations.
  */
-/**
- * Converts a hex string to Uint8Array
- *
- * @param hex - Hex string to convert
- * @returns Uint8Array representation of the hex string
- */
-declare function hexToBytes(hex: string): Uint8Array;
-/**
- * Converts Uint8Array to hex string
- *
- * @param bytes - Bytes to convert to hex
- * @returns Hex string representation
- */
-declare function bytesToHex(bytes: Uint8Array): string;
-/**
- * Converts a string to Uint8Array using UTF-8 encoding
- *
- * @param str - String to convert
- * @returns UTF-8 encoded bytes
- */
-declare function stringToBytes(str: string): Uint8Array;
-/**
- * Converts Uint8Array to string using UTF-8 decoding
- *
- * @param bytes - Bytes to decode
- * @returns Decoded UTF-8 string
- */
-declare function bytesToString(bytes: Uint8Array): string;
-/**
- * Concatenates multiple Uint8Arrays into one
- *
- * @param arrays - Arrays to concatenate
- * @returns Concatenated Uint8Array
- */
-declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
 /**
  * Checks if two Uint8Arrays are equal in constant time
  *
@@ -46,7 +11,7 @@ declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
  * @param b - Second array to compare
  * @returns `true` if arrays are equal
  */
-declare function constantTimeEqual(a: Uint8Array, b: Uint8Array): boolean;
+export declare function constantTimeEqual(a: Uint8Array, b: Uint8Array): boolean;
 /**
  * Converts Buffer to Uint8Array (for Node.js compatibility layer)
  * In browser, this is a no-op if already Uint8Array
@@ -54,7 +19,7 @@ declare function constantTimeEqual(a: Uint8Array, b: Uint8Array): boolean;
  * @param buffer - Buffer or Uint8Array to convert
  * @returns Uint8Array representation
  */
-declare function bufferToBytes(buffer: Buffer | Uint8Array): Uint8Array;
+export declare function bufferToBytes(buffer: Buffer | Uint8Array): Uint8Array;
 /**
  * Converts Uint8Array to Buffer (for Node.js compatibility layer)
  * Only available in Node.js environment
@@ -62,6 +27,4 @@ declare function bufferToBytes(buffer: Buffer | Uint8Array): Uint8Array;
  * @param bytes - Uint8Array to convert to Buffer
  * @returns Buffer representation
  */
-declare function bytesToBuffer(bytes: Uint8Array): Buffer;
-
-export { bufferToBytes, bytesToBuffer, bytesToHex, bytesToString, concatBytes, constantTimeEqual, hexToBytes, stringToBytes };
+export declare function bytesToBuffer(bytes: Uint8Array): Buffer;

package/dist/crypto/ecies/utils.js

@@ -1,32 +1,3 @@
-function hexToBytes(hex) {
-  if (hex.length % 2 !== 0) {
-    throw new Error("Hex string must have even length");
-  }
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-  }
-  return bytes;
-}
-function bytesToHex(bytes) {
-  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function stringToBytes(str) {
-  return new TextEncoder().encode(str);
-}
-function bytesToString(bytes) {
-  return new TextDecoder().decode(bytes);
-}
-function concatBytes(...arrays) {
-  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
 function constantTimeEqual(a, b) {
   if (a.length !== b.length) return false;
   let result = 0;
@@ -50,11 +21,6 @@ function bytesToBuffer(bytes) {
 export {
   bufferToBytes,
   bytesToBuffer,
-  bytesToHex,
-  bytesToString,
-  concatBytes,
-  constantTimeEqual,
-  hexToBytes,
-  stringToBytes
+  constantTimeEqual
 };
 //# sourceMappingURL=utils.js.map