@opendatalabs/vana-sdk 0.1.0-alpha.7e71046 → 0.1.0-alpha.7ee7635

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

@@ -0,0 +1,67 @@
+/**
+ * Utility functions for ECIES operations
+ *
+ * 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
+ *
+ * @param a - First array to compare
+ * @param b - Second array to compare
+ * @returns `true` if arrays are equal
+ */
+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
+ *
+ * @param buffer - Buffer or Uint8Array to convert
+ * @returns Uint8Array representation
+ */
+declare function bufferToBytes(buffer: Buffer | Uint8Array): Uint8Array;
+/**
+ * Converts Uint8Array to Buffer (for Node.js compatibility layer)
+ * Only available in Node.js environment
+ *
+ * @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 };

package/dist/crypto/ecies/utils.js

@@ -0,0 +1,60 @@
+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;
+  for (let i = 0; i < a.length; i++) {
+    result |= a[i] ^ b[i];
+  }
+  return result === 0;
+}
+function bufferToBytes(buffer) {
+  if (buffer instanceof Uint8Array) {
+    return buffer;
+  }
+  return new Uint8Array(buffer);
+}
+function bytesToBuffer(bytes) {
+  if (typeof Buffer === "undefined") {
+    throw new Error("Buffer is not available in browser environment");
+  }
+  return Buffer.from(bytes);
+}
+export {
+  bufferToBytes,
+  bytesToBuffer,
+  bytesToHex,
+  bytesToString,
+  concatBytes,
+  constantTimeEqual,
+  hexToBytes,
+  stringToBytes
+};
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +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":"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":[]}

package/dist/crypto/services/WalletKeyEncryptionService.cjs

@@ -0,0 +1,128 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WalletKeyEncryptionService_exports = {};
+__export(WalletKeyEncryptionService_exports, {
+  WalletKeyEncryptionService: () => WalletKeyEncryptionService
+});
+module.exports = __toCommonJS(WalletKeyEncryptionService_exports);
+var import_crypto_utils = require("../../utils/crypto-utils");
+var import_viem = require("viem");
+class WalletKeyEncryptionService {
+  eciesProvider;
+  constructor(config) {
+    this.eciesProvider = config.eciesProvider;
+  }
+  /**
+   * Encrypts data using a wallet's public key.
+   *
+   * @param data - The plaintext message to encrypt for the wallet owner.
+   * @param publicKey - The recipient wallet's public key for encryption.
+   * @returns A promise that resolves to the encrypted data as a hex string.
+   * @throws {Error} When encryption fails due to invalid key format.
+   *
+   * @example
+   * ```typescript
+   * const encrypted = await processor.encryptWithWalletPublicKey(
+   *   "Secret message",
+   *   "0x04..." // 65-byte uncompressed public key
+   * );
+   * console.log(`Encrypted: ${encrypted}`);
+   * ```
+   */
+  async encryptWithWalletPublicKey(data, publicKey) {
+    const publicKeyBytes = (0, import_crypto_utils.processWalletPublicKey)(publicKey);
+    const normalizedKey = this.eciesProvider.normalizeToUncompressed(publicKeyBytes);
+    const dataBytes = (0, import_viem.stringToBytes)(data);
+    const encrypted = await this.eciesProvider.encrypt(
+      normalizedKey,
+      dataBytes
+    );
+    const result = (0, import_crypto_utils.concatBytes)(
+      encrypted.iv,
+      encrypted.ephemPublicKey,
+      encrypted.ciphertext,
+      encrypted.mac
+    );
+    return (0, import_viem.toHex)(result).slice(2);
+  }
+  /**
+   * Decrypts data using a wallet's private key.
+   *
+   * @param encryptedData - The hex-encoded encrypted data to decrypt.
+   * @param privateKey - The wallet's private key for decryption.
+   * @returns A promise that resolves to the decrypted plaintext message.
+   * @throws {Error} When decryption fails due to invalid data or key format.
+   *
+   * @example
+   * ```typescript
+   * const decrypted = await processor.decryptWithWalletPrivateKey(
+   *   encryptedHexString,
+   *   "0x..." // 32-byte private key
+   * );
+   * console.log(`Decrypted: ${decrypted}`);
+   * ```
+   */
+  async decryptWithWalletPrivateKey(encryptedData, privateKey) {
+    const privateKeyBytes = (0, import_crypto_utils.processWalletPrivateKey)(privateKey);
+    const prefixedHex = encryptedData.startsWith("0x") ? encryptedData : `0x${encryptedData}`;
+    const encryptedBytes = (0, import_viem.fromHex)(prefixedHex, "bytes");
+    const encrypted = (0, import_crypto_utils.parseEncryptedDataBuffer)(encryptedBytes);
+    const decrypted = await this.eciesProvider.decrypt(
+      privateKeyBytes,
+      encrypted
+    );
+    return (0, import_viem.bytesToString)(decrypted);
+  }
+  /**
+   * Encrypts a Uint8Array with a wallet public key
+   *
+   * @param data - Binary data to encrypt
+   * @param publicKey - Public key as hex string or Uint8Array
+   * @returns Encrypted data structure
+   */
+  async encryptBinary(data, publicKey) {
+    const publicKeyBytes = (0, import_crypto_utils.processWalletPublicKey)(publicKey);
+    const normalizedKey = this.eciesProvider.normalizeToUncompressed(publicKeyBytes);
+    return this.eciesProvider.encrypt(normalizedKey, data);
+  }
+  /**
+   * Decrypts to a Uint8Array with a wallet private key
+   *
+   * @param encrypted - Encrypted data structure
+   * @param privateKey - Private key as hex string or Uint8Array
+   * @returns Decrypted binary data
+   */
+  async decryptBinary(encrypted, privateKey) {
+    const privateKeyBytes = (0, import_crypto_utils.processWalletPrivateKey)(privateKey);
+    return this.eciesProvider.decrypt(privateKeyBytes, encrypted);
+  }
+  /**
+   * Gets the underlying ECIES provider
+   *
+   * @returns The ECIES provider instance
+   */
+  getECIESProvider() {
+    return this.eciesProvider;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WalletKeyEncryptionService
+});
+//# sourceMappingURL=WalletKeyEncryptionService.cjs.map

package/dist/crypto/services/WalletKeyEncryptionService.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/crypto/services/WalletKeyEncryptionService.ts"],"sourcesContent":["/**\n * Service for wallet key encryption and decryption operations.\n *\n * @remarks\n * This service separates business logic (wallet key processing) from crypto primitives\n * (ECIES operations). It handles key normalization, data conversion, and format transformation\n * while delegating actual cryptographic operations to the provided ECIES provider.\n *\n * @category Cryptography\n * @internal\n */\n\nimport type { ECIESProvider, ECIESEncrypted } from \"../ecies/interface\";\nimport {\n  processWalletPublicKey,\n  processWalletPrivateKey,\n  parseEncryptedDataBuffer,\n  concatBytes,\n} from \"../../utils/crypto-utils\";\nimport { stringToBytes, bytesToString, toHex, fromHex } from \"viem\";\n\nexport interface WalletKeyEncryptionServiceConfig {\n  /** ECIES provider for encryption/decryption */\n  eciesProvider: ECIESProvider;\n}\n\n/**\n * Service for wallet key encryption and decryption operations\n *\n * @remarks\n * This service encapsulates the business logic for wallet key operations,\n * delegating actual cryptographic operations to the provided ECIES provider.\n * It handles key normalization, data conversion, and format transformation.\n *\n * @internal\n */\nexport class WalletKeyEncryptionService {\n  private readonly eciesProvider: ECIESProvider;\n\n  constructor(config: WalletKeyEncryptionServiceConfig) {\n    this.eciesProvider = config.eciesProvider;\n  }\n\n  /**\n   * Encrypts data using a wallet's public key.\n   *\n   * @param data - The plaintext message to encrypt for the wallet owner.\n   * @param publicKey - The recipient wallet's public key for encryption.\n   * @returns A promise that resolves to the encrypted data as a hex string.\n   * @throws {Error} When encryption fails due to invalid key format.\n   *\n   * @example\n   * ```typescript\n   * const encrypted = await processor.encryptWithWalletPublicKey(\n   *   \"Secret message\",\n   *   \"0x04...\" // 65-byte uncompressed public key\n   * );\n   * console.log(`Encrypted: ${encrypted}`);\n   * ```\n   */\n  async encryptWithWalletPublicKey(\n    data: string,\n    publicKey: string | Uint8Array,\n  ): Promise<string> {\n    // Process the public key to ensure correct format\n    const publicKeyBytes = processWalletPublicKey(publicKey);\n\n    // Normalize to uncompressed format using the provider\n    // This handles compressed keys, raw coordinates, and validates the format\n    const normalizedKey =\n      this.eciesProvider.normalizeToUncompressed(publicKeyBytes);\n\n    // Convert string data to bytes\n    const dataBytes = stringToBytes(data);\n\n    // Perform ECIES encryption\n    const encrypted = await this.eciesProvider.encrypt(\n      normalizedKey,\n      dataBytes,\n    );\n\n    // Concatenate all components for legacy format compatibility\n    const result = concatBytes(\n      encrypted.iv,\n      encrypted.ephemPublicKey,\n      encrypted.ciphertext,\n      encrypted.mac,\n    );\n\n    // Return as hex string without 0x prefix for API compatibility\n    return toHex(result).slice(2);\n  }\n\n  /**\n   * Decrypts data using a wallet's private key.\n   *\n   * @param encryptedData - The hex-encoded encrypted data to decrypt.\n   * @param privateKey - The wallet's private key for decryption.\n   * @returns A promise that resolves to the decrypted plaintext message.\n   * @throws {Error} When decryption fails due to invalid data or key format.\n   *\n   * @example\n   * ```typescript\n   * const decrypted = await processor.decryptWithWalletPrivateKey(\n   *   encryptedHexString,\n   *   \"0x...\" // 32-byte private key\n   * );\n   * console.log(`Decrypted: ${decrypted}`);\n   * ```\n   */\n  async decryptWithWalletPrivateKey(\n    encryptedData: string,\n    privateKey: string | Uint8Array,\n  ): Promise<string> {\n    // Process the private key to ensure correct format\n    const privateKeyBytes = processWalletPrivateKey(privateKey);\n\n    // Convert hex string to bytes and parse encrypted components\n    const prefixedHex = encryptedData.startsWith(\"0x\")\n      ? encryptedData\n      : `0x${encryptedData}`;\n    const encryptedBytes = fromHex(prefixedHex as `0x${string}`, \"bytes\");\n    const encrypted = parseEncryptedDataBuffer(encryptedBytes);\n\n    // Perform ECIES decryption\n    const decrypted = await this.eciesProvider.decrypt(\n      privateKeyBytes,\n      encrypted,\n    );\n\n    // Convert bytes back to string\n    return bytesToString(decrypted);\n  }\n\n  /**\n   * Encrypts a Uint8Array with a wallet public key\n   *\n   * @param data - Binary data to encrypt\n   * @param publicKey - Public key as hex string or Uint8Array\n   * @returns Encrypted data structure\n   */\n  async encryptBinary(\n    data: Uint8Array,\n    publicKey: string | Uint8Array,\n  ): Promise<ECIESEncrypted> {\n    const publicKeyBytes = processWalletPublicKey(publicKey);\n    const normalizedKey =\n      this.eciesProvider.normalizeToUncompressed(publicKeyBytes);\n    return this.eciesProvider.encrypt(normalizedKey, data);\n  }\n\n  /**\n   * Decrypts to a Uint8Array with a wallet private key\n   *\n   * @param encrypted - Encrypted data structure\n   * @param privateKey - Private key as hex string or Uint8Array\n   * @returns Decrypted binary data\n   */\n  async decryptBinary(\n    encrypted: ECIESEncrypted,\n    privateKey: string | Uint8Array,\n  ): Promise<Uint8Array> {\n    const privateKeyBytes = processWalletPrivateKey(privateKey);\n    return this.eciesProvider.decrypt(privateKeyBytes, encrypted);\n  }\n\n  /**\n   * Gets the underlying ECIES provider\n   *\n   * @returns The ECIES provider instance\n   */\n  getECIESProvider(): ECIESProvider {\n    return this.eciesProvider;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,0BAKO;AACP,kBAA6D;AAiBtD,MAAM,2BAA2B;AAAA,EACrB;AAAA,EAEjB,YAAY,QAA0C;AACpD,SAAK,gBAAgB,OAAO;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,MAAM,2BACJ,MACA,WACiB;AAEjB,UAAM,qBAAiB,4CAAuB,SAAS;AAIvD,UAAM,gBACJ,KAAK,cAAc,wBAAwB,cAAc;AAG3D,UAAM,gBAAY,2BAAc,IAAI;AAGpC,UAAM,YAAY,MAAM,KAAK,cAAc;AAAA,MACzC;AAAA,MACA;AAAA,IACF;AAGA,UAAM,aAAS;AAAA,MACb,UAAU;AAAA,MACV,UAAU;AAAA,MACV,UAAU;AAAA,MACV,UAAU;AAAA,IACZ;AAGA,eAAO,mBAAM,MAAM,EAAE,MAAM,CAAC;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,MAAM,4BACJ,eACA,YACiB;AAEjB,UAAM,sBAAkB,6CAAwB,UAAU;AAG1D,UAAM,cAAc,cAAc,WAAW,IAAI,IAC7C,gBACA,KAAK,aAAa;AACtB,UAAM,qBAAiB,qBAAQ,aAA8B,OAAO;AACpE,UAAM,gBAAY,8CAAyB,cAAc;AAGzD,UAAM,YAAY,MAAM,KAAK,cAAc;AAAA,MACzC;AAAA,MACA;AAAA,IACF;AAGA,eAAO,2BAAc,SAAS;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,cACJ,MACA,WACyB;AACzB,UAAM,qBAAiB,4CAAuB,SAAS;AACvD,UAAM,gBACJ,KAAK,cAAc,wBAAwB,cAAc;AAC3D,WAAO,KAAK,cAAc,QAAQ,eAAe,IAAI;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,cACJ,WACA,YACqB;AACrB,UAAM,sBAAkB,6CAAwB,UAAU;AAC1D,WAAO,KAAK,cAAc,QAAQ,iBAAiB,SAAS;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,mBAAkC;AAChC,WAAO,KAAK;AAAA,EACd;AACF;","names":[]}

package/dist/crypto/services/WalletKeyEncryptionService.d.cts

@@ -0,0 +1,92 @@
+import { ECIESProvider, ECIESEncrypted } from '../ecies/interface.cjs';
+
+/**
+ * Service for wallet key encryption and decryption operations.
+ *
+ * @remarks
+ * This service separates business logic (wallet key processing) from crypto primitives
+ * (ECIES operations). It handles key normalization, data conversion, and format transformation
+ * while delegating actual cryptographic operations to the provided ECIES provider.
+ *
+ * @category Cryptography
+ * @internal
+ */
+
+interface WalletKeyEncryptionServiceConfig {
+    /** ECIES provider for encryption/decryption */
+    eciesProvider: ECIESProvider;
+}
+/**
+ * Service for wallet key encryption and decryption operations
+ *
+ * @remarks
+ * This service encapsulates the business logic for wallet key operations,
+ * delegating actual cryptographic operations to the provided ECIES provider.
+ * It handles key normalization, data conversion, and format transformation.
+ *
+ * @internal
+ */
+declare class WalletKeyEncryptionService {
+    private readonly eciesProvider;
+    constructor(config: WalletKeyEncryptionServiceConfig);
+    /**
+     * Encrypts data using a wallet's public key.
+     *
+     * @param data - The plaintext message to encrypt for the wallet owner.
+     * @param publicKey - The recipient wallet's public key for encryption.
+     * @returns A promise that resolves to the encrypted data as a hex string.
+     * @throws {Error} When encryption fails due to invalid key format.
+     *
+     * @example
+     * ```typescript
+     * const encrypted = await processor.encryptWithWalletPublicKey(
+     *   "Secret message",
+     *   "0x04..." // 65-byte uncompressed public key
+     * );
+     * console.log(`Encrypted: ${encrypted}`);
+     * ```
+     */
+    encryptWithWalletPublicKey(data: string, publicKey: string | Uint8Array): Promise<string>;
+    /**
+     * Decrypts data using a wallet's private key.
+     *
+     * @param encryptedData - The hex-encoded encrypted data to decrypt.
+     * @param privateKey - The wallet's private key for decryption.
+     * @returns A promise that resolves to the decrypted plaintext message.
+     * @throws {Error} When decryption fails due to invalid data or key format.
+     *
+     * @example
+     * ```typescript
+     * const decrypted = await processor.decryptWithWalletPrivateKey(
+     *   encryptedHexString,
+     *   "0x..." // 32-byte private key
+     * );
+     * console.log(`Decrypted: ${decrypted}`);
+     * ```
+     */
+    decryptWithWalletPrivateKey(encryptedData: string, privateKey: string | Uint8Array): Promise<string>;
+    /**
+     * Encrypts a Uint8Array with a wallet public key
+     *
+     * @param data - Binary data to encrypt
+     * @param publicKey - Public key as hex string or Uint8Array
+     * @returns Encrypted data structure
+     */
+    encryptBinary(data: Uint8Array, publicKey: string | Uint8Array): Promise<ECIESEncrypted>;
+    /**
+     * Decrypts to a Uint8Array with a wallet private key
+     *
+     * @param encrypted - Encrypted data structure
+     * @param privateKey - Private key as hex string or Uint8Array
+     * @returns Decrypted binary data
+     */
+    decryptBinary(encrypted: ECIESEncrypted, privateKey: string | Uint8Array): Promise<Uint8Array>;
+    /**
+     * Gets the underlying ECIES provider
+     *
+     * @returns The ECIES provider instance
+     */
+    getECIESProvider(): ECIESProvider;
+}
+
+export { WalletKeyEncryptionService, type WalletKeyEncryptionServiceConfig };

package/dist/crypto/services/WalletKeyEncryptionService.d.ts

@@ -0,0 +1,92 @@
+import { ECIESProvider, ECIESEncrypted } from '../ecies/interface.js';
+
+/**
+ * Service for wallet key encryption and decryption operations.
+ *
+ * @remarks
+ * This service separates business logic (wallet key processing) from crypto primitives
+ * (ECIES operations). It handles key normalization, data conversion, and format transformation
+ * while delegating actual cryptographic operations to the provided ECIES provider.
+ *
+ * @category Cryptography
+ * @internal
+ */
+
+interface WalletKeyEncryptionServiceConfig {
+    /** ECIES provider for encryption/decryption */
+    eciesProvider: ECIESProvider;
+}
+/**
+ * Service for wallet key encryption and decryption operations
+ *
+ * @remarks
+ * This service encapsulates the business logic for wallet key operations,
+ * delegating actual cryptographic operations to the provided ECIES provider.
+ * It handles key normalization, data conversion, and format transformation.
+ *
+ * @internal
+ */
+declare class WalletKeyEncryptionService {
+    private readonly eciesProvider;
+    constructor(config: WalletKeyEncryptionServiceConfig);
+    /**
+     * Encrypts data using a wallet's public key.
+     *
+     * @param data - The plaintext message to encrypt for the wallet owner.
+     * @param publicKey - The recipient wallet's public key for encryption.
+     * @returns A promise that resolves to the encrypted data as a hex string.
+     * @throws {Error} When encryption fails due to invalid key format.
+     *
+     * @example
+     * ```typescript
+     * const encrypted = await processor.encryptWithWalletPublicKey(
+     *   "Secret message",
+     *   "0x04..." // 65-byte uncompressed public key
+     * );
+     * console.log(`Encrypted: ${encrypted}`);
+     * ```
+     */
+    encryptWithWalletPublicKey(data: string, publicKey: string | Uint8Array): Promise<string>;
+    /**
+     * Decrypts data using a wallet's private key.
+     *
+     * @param encryptedData - The hex-encoded encrypted data to decrypt.
+     * @param privateKey - The wallet's private key for decryption.
+     * @returns A promise that resolves to the decrypted plaintext message.
+     * @throws {Error} When decryption fails due to invalid data or key format.
+     *
+     * @example
+     * ```typescript
+     * const decrypted = await processor.decryptWithWalletPrivateKey(
+     *   encryptedHexString,
+     *   "0x..." // 32-byte private key
+     * );
+     * console.log(`Decrypted: ${decrypted}`);
+     * ```
+     */
+    decryptWithWalletPrivateKey(encryptedData: string, privateKey: string | Uint8Array): Promise<string>;
+    /**
+     * Encrypts a Uint8Array with a wallet public key
+     *
+     * @param data - Binary data to encrypt
+     * @param publicKey - Public key as hex string or Uint8Array
+     * @returns Encrypted data structure
+     */
+    encryptBinary(data: Uint8Array, publicKey: string | Uint8Array): Promise<ECIESEncrypted>;
+    /**
+     * Decrypts to a Uint8Array with a wallet private key
+     *
+     * @param encrypted - Encrypted data structure
+     * @param privateKey - Private key as hex string or Uint8Array
+     * @returns Decrypted binary data
+     */
+    decryptBinary(encrypted: ECIESEncrypted, privateKey: string | Uint8Array): Promise<Uint8Array>;
+    /**
+     * Gets the underlying ECIES provider
+     *
+     * @returns The ECIES provider instance
+     */
+    getECIESProvider(): ECIESProvider;
+}
+
+export { WalletKeyEncryptionService, type WalletKeyEncryptionServiceConfig };

package/dist/crypto/services/WalletKeyEncryptionService.js

@@ -0,0 +1,112 @@
+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 {
+  processWalletPublicKey,
+  processWalletPrivateKey,
+  parseEncryptedDataBuffer,
+  concatBytes
+} from "../../utils/crypto-utils";
+import { stringToBytes, bytesToString, toHex, fromHex } from "viem";
+class WalletKeyEncryptionService {
+  constructor(config) {
+    __publicField(this, "eciesProvider");
+    this.eciesProvider = config.eciesProvider;
+  }
+  /**
+   * Encrypts data using a wallet's public key.
+   *
+   * @param data - The plaintext message to encrypt for the wallet owner.
+   * @param publicKey - The recipient wallet's public key for encryption.
+   * @returns A promise that resolves to the encrypted data as a hex string.
+   * @throws {Error} When encryption fails due to invalid key format.
+   *
+   * @example
+   * ```typescript
+   * const encrypted = await processor.encryptWithWalletPublicKey(
+   *   "Secret message",
+   *   "0x04..." // 65-byte uncompressed public key
+   * );
+   * console.log(`Encrypted: ${encrypted}`);
+   * ```
+   */
+  async encryptWithWalletPublicKey(data, publicKey) {
+    const publicKeyBytes = processWalletPublicKey(publicKey);
+    const normalizedKey = this.eciesProvider.normalizeToUncompressed(publicKeyBytes);
+    const dataBytes = stringToBytes(data);
+    const encrypted = await this.eciesProvider.encrypt(
+      normalizedKey,
+      dataBytes
+    );
+    const result = concatBytes(
+      encrypted.iv,
+      encrypted.ephemPublicKey,
+      encrypted.ciphertext,
+      encrypted.mac
+    );
+    return toHex(result).slice(2);
+  }
+  /**
+   * Decrypts data using a wallet's private key.
+   *
+   * @param encryptedData - The hex-encoded encrypted data to decrypt.
+   * @param privateKey - The wallet's private key for decryption.
+   * @returns A promise that resolves to the decrypted plaintext message.
+   * @throws {Error} When decryption fails due to invalid data or key format.
+   *
+   * @example
+   * ```typescript
+   * const decrypted = await processor.decryptWithWalletPrivateKey(
+   *   encryptedHexString,
+   *   "0x..." // 32-byte private key
+   * );
+   * console.log(`Decrypted: ${decrypted}`);
+   * ```
+   */
+  async decryptWithWalletPrivateKey(encryptedData, privateKey) {
+    const privateKeyBytes = processWalletPrivateKey(privateKey);
+    const prefixedHex = encryptedData.startsWith("0x") ? encryptedData : `0x${encryptedData}`;
+    const encryptedBytes = fromHex(prefixedHex, "bytes");
+    const encrypted = parseEncryptedDataBuffer(encryptedBytes);
+    const decrypted = await this.eciesProvider.decrypt(
+      privateKeyBytes,
+      encrypted
+    );
+    return bytesToString(decrypted);
+  }
+  /**
+   * Encrypts a Uint8Array with a wallet public key
+   *
+   * @param data - Binary data to encrypt
+   * @param publicKey - Public key as hex string or Uint8Array
+   * @returns Encrypted data structure
+   */
+  async encryptBinary(data, publicKey) {
+    const publicKeyBytes = processWalletPublicKey(publicKey);
+    const normalizedKey = this.eciesProvider.normalizeToUncompressed(publicKeyBytes);
+    return this.eciesProvider.encrypt(normalizedKey, data);
+  }
+  /**
+   * Decrypts to a Uint8Array with a wallet private key
+   *
+   * @param encrypted - Encrypted data structure
+   * @param privateKey - Private key as hex string or Uint8Array
+   * @returns Decrypted binary data
+   */
+  async decryptBinary(encrypted, privateKey) {
+    const privateKeyBytes = processWalletPrivateKey(privateKey);
+    return this.eciesProvider.decrypt(privateKeyBytes, encrypted);
+  }
+  /**
+   * Gets the underlying ECIES provider
+   *
+   * @returns The ECIES provider instance
+   */
+  getECIESProvider() {
+    return this.eciesProvider;
+  }
+}
+export {
+  WalletKeyEncryptionService
+};
+//# sourceMappingURL=WalletKeyEncryptionService.js.map

package/dist/crypto/services/WalletKeyEncryptionService.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/crypto/services/WalletKeyEncryptionService.ts"],"sourcesContent":["/**\n * Service for wallet key encryption and decryption operations.\n *\n * @remarks\n * This service separates business logic (wallet key processing) from crypto primitives\n * (ECIES operations). It handles key normalization, data conversion, and format transformation\n * while delegating actual cryptographic operations to the provided ECIES provider.\n *\n * @category Cryptography\n * @internal\n */\n\nimport type { ECIESProvider, ECIESEncrypted } from \"../ecies/interface\";\nimport {\n  processWalletPublicKey,\n  processWalletPrivateKey,\n  parseEncryptedDataBuffer,\n  concatBytes,\n} from \"../../utils/crypto-utils\";\nimport { stringToBytes, bytesToString, toHex, fromHex } from \"viem\";\n\nexport interface WalletKeyEncryptionServiceConfig {\n  /** ECIES provider for encryption/decryption */\n  eciesProvider: ECIESProvider;\n}\n\n/**\n * Service for wallet key encryption and decryption operations\n *\n * @remarks\n * This service encapsulates the business logic for wallet key operations,\n * delegating actual cryptographic operations to the provided ECIES provider.\n * It handles key normalization, data conversion, and format transformation.\n *\n * @internal\n */\nexport class WalletKeyEncryptionService {\n  private readonly eciesProvider: ECIESProvider;\n\n  constructor(config: WalletKeyEncryptionServiceConfig) {\n    this.eciesProvider = config.eciesProvider;\n  }\n\n  /**\n   * Encrypts data using a wallet's public key.\n   *\n   * @param data - The plaintext message to encrypt for the wallet owner.\n   * @param publicKey - The recipient wallet's public key for encryption.\n   * @returns A promise that resolves to the encrypted data as a hex string.\n   * @throws {Error} When encryption fails due to invalid key format.\n   *\n   * @example\n   * ```typescript\n   * const encrypted = await processor.encryptWithWalletPublicKey(\n   *   \"Secret message\",\n   *   \"0x04...\" // 65-byte uncompressed public key\n   * );\n   * console.log(`Encrypted: ${encrypted}`);\n   * ```\n   */\n  async encryptWithWalletPublicKey(\n    data: string,\n    publicKey: string | Uint8Array,\n  ): Promise<string> {\n    // Process the public key to ensure correct format\n    const publicKeyBytes = processWalletPublicKey(publicKey);\n\n    // Normalize to uncompressed format using the provider\n    // This handles compressed keys, raw coordinates, and validates the format\n    const normalizedKey =\n      this.eciesProvider.normalizeToUncompressed(publicKeyBytes);\n\n    // Convert string data to bytes\n    const dataBytes = stringToBytes(data);\n\n    // Perform ECIES encryption\n    const encrypted = await this.eciesProvider.encrypt(\n      normalizedKey,\n      dataBytes,\n    );\n\n    // Concatenate all components for legacy format compatibility\n    const result = concatBytes(\n      encrypted.iv,\n      encrypted.ephemPublicKey,\n      encrypted.ciphertext,\n      encrypted.mac,\n    );\n\n    // Return as hex string without 0x prefix for API compatibility\n    return toHex(result).slice(2);\n  }\n\n  /**\n   * Decrypts data using a wallet's private key.\n   *\n   * @param encryptedData - The hex-encoded encrypted data to decrypt.\n   * @param privateKey - The wallet's private key for decryption.\n   * @returns A promise that resolves to the decrypted plaintext message.\n   * @throws {Error} When decryption fails due to invalid data or key format.\n   *\n   * @example\n   * ```typescript\n   * const decrypted = await processor.decryptWithWalletPrivateKey(\n   *   encryptedHexString,\n   *   \"0x...\" // 32-byte private key\n   * );\n   * console.log(`Decrypted: ${decrypted}`);\n   * ```\n   */\n  async decryptWithWalletPrivateKey(\n    encryptedData: string,\n    privateKey: string | Uint8Array,\n  ): Promise<string> {\n    // Process the private key to ensure correct format\n    const privateKeyBytes = processWalletPrivateKey(privateKey);\n\n    // Convert hex string to bytes and parse encrypted components\n    const prefixedHex = encryptedData.startsWith(\"0x\")\n      ? encryptedData\n      : `0x${encryptedData}`;\n    const encryptedBytes = fromHex(prefixedHex as `0x${string}`, \"bytes\");\n    const encrypted = parseEncryptedDataBuffer(encryptedBytes);\n\n    // Perform ECIES decryption\n    const decrypted = await this.eciesProvider.decrypt(\n      privateKeyBytes,\n      encrypted,\n    );\n\n    // Convert bytes back to string\n    return bytesToString(decrypted);\n  }\n\n  /**\n   * Encrypts a Uint8Array with a wallet public key\n   *\n   * @param data - Binary data to encrypt\n   * @param publicKey - Public key as hex string or Uint8Array\n   * @returns Encrypted data structure\n   */\n  async encryptBinary(\n    data: Uint8Array,\n    publicKey: string | Uint8Array,\n  ): Promise<ECIESEncrypted> {\n    const publicKeyBytes = processWalletPublicKey(publicKey);\n    const normalizedKey =\n      this.eciesProvider.normalizeToUncompressed(publicKeyBytes);\n    return this.eciesProvider.encrypt(normalizedKey, data);\n  }\n\n  /**\n   * Decrypts to a Uint8Array with a wallet private key\n   *\n   * @param encrypted - Encrypted data structure\n   * @param privateKey - Private key as hex string or Uint8Array\n   * @returns Decrypted binary data\n   */\n  async decryptBinary(\n    encrypted: ECIESEncrypted,\n    privateKey: string | Uint8Array,\n  ): Promise<Uint8Array> {\n    const privateKeyBytes = processWalletPrivateKey(privateKey);\n    return this.eciesProvider.decrypt(privateKeyBytes, encrypted);\n  }\n\n  /**\n   * Gets the underlying ECIES provider\n   *\n   * @returns The ECIES provider instance\n   */\n  getECIESProvider(): ECIESProvider {\n    return this.eciesProvider;\n  }\n}\n"],"mappings":";;;AAaA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,eAAe,eAAe,OAAO,eAAe;AAiBtD,MAAM,2BAA2B;AAAA,EAGtC,YAAY,QAA0C;AAFtD,wBAAiB;AAGf,SAAK,gBAAgB,OAAO;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,MAAM,2BACJ,MACA,WACiB;AAEjB,UAAM,iBAAiB,uBAAuB,SAAS;AAIvD,UAAM,gBACJ,KAAK,cAAc,wBAAwB,cAAc;AAG3D,UAAM,YAAY,cAAc,IAAI;AAGpC,UAAM,YAAY,MAAM,KAAK,cAAc;AAAA,MACzC;AAAA,MACA;AAAA,IACF;AAGA,UAAM,SAAS;AAAA,MACb,UAAU;AAAA,MACV,UAAU;AAAA,MACV,UAAU;AAAA,MACV,UAAU;AAAA,IACZ;AAGA,WAAO,MAAM,MAAM,EAAE,MAAM,CAAC;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,MAAM,4BACJ,eACA,YACiB;AAEjB,UAAM,kBAAkB,wBAAwB,UAAU;AAG1D,UAAM,cAAc,cAAc,WAAW,IAAI,IAC7C,gBACA,KAAK,aAAa;AACtB,UAAM,iBAAiB,QAAQ,aAA8B,OAAO;AACpE,UAAM,YAAY,yBAAyB,cAAc;AAGzD,UAAM,YAAY,MAAM,KAAK,cAAc;AAAA,MACzC;AAAA,MACA;AAAA,IACF;AAGA,WAAO,cAAc,SAAS;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,cACJ,MACA,WACyB;AACzB,UAAM,iBAAiB,uBAAuB,SAAS;AACvD,UAAM,gBACJ,KAAK,cAAc,wBAAwB,cAAc;AAC3D,WAAO,KAAK,cAAc,QAAQ,eAAe,IAAI;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,cACJ,WACA,YACqB;AACrB,UAAM,kBAAkB,wBAAwB,UAAU;AAC1D,WAAO,KAAK,cAAc,QAAQ,iBAAiB,SAAS;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,mBAAkC;AAChC,WAAO,KAAK;AAAA,EACd;AACF;","names":[]}

package/dist/diagnostics.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var diagnostics_exports = {};
+__export(diagnostics_exports, {
+  warnOnce: () => warnOnce
+});
+module.exports = __toCommonJS(diagnostics_exports);
+const seen = /* @__PURE__ */ new Set();
+const SILENCE = typeof process !== "undefined" && process?.env?.VANA_SDK_SILENCE_WARNINGS === "1";
+function warnOnce(...msg) {
+  if (SILENCE) return;
+  const key = msg.join(" ");
+  if (seen.has(key)) return;
+  seen.add(key);
+  console.warn("[vana-sdk]", ...msg);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  warnOnce
+});
+//# sourceMappingURL=diagnostics.cjs.map

package/dist/diagnostics.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/diagnostics.ts"],"sourcesContent":["/**\n * Provides diagnostic warnings for SDK configuration and environment issues.\n *\n * @remarks\n * Warnings are deduplicated by message and can be silenced via\n * the VANA_SDK_SILENCE_WARNINGS environment variable.\n *\n * @category Diagnostics\n */\n\n/** Tracks seen warning messages to prevent duplicate output. */\nconst seen = new Set<string>();\n\n/** Checks if warnings are silenced via environment variable. */\nconst SILENCE =\n  typeof process !== \"undefined\" &&\n  process?.env?.VANA_SDK_SILENCE_WARNINGS === \"1\";\n\n/**\n * Emits a warning message once per unique message content.\n *\n * @remarks\n * Warnings are automatically prefixed with \"[vana-sdk]\" and deduplicated.\n * Set `VANA_SDK_SILENCE_WARNINGS=1` to disable all warnings.\n *\n * @param msg - Warning message components to display.\n *\n * @example\n * ```typescript\n * warnOnce(\"AES-256-CBC not available.\", \"ECIES will fail.\");\n * ```\n */\nexport function warnOnce(...msg: unknown[]): void {\n  if (SILENCE) return;\n  const key = msg.join(\" \");\n  if (seen.has(key)) return;\n  seen.add(key);\n  console.warn(\"[vana-sdk]\", ...msg);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,MAAM,OAAO,oBAAI,IAAY;AAG7B,MAAM,UACJ,OAAO,YAAY,eACnB,SAAS,KAAK,8BAA8B;AAgBvC,SAAS,YAAY,KAAsB;AAChD,MAAI,QAAS;AACb,QAAM,MAAM,IAAI,KAAK,GAAG;AACxB,MAAI,KAAK,IAAI,GAAG,EAAG;AACnB,OAAK,IAAI,GAAG;AACZ,UAAQ,KAAK,cAAc,GAAG,GAAG;AACnC;","names":[]}

package/dist/diagnostics.d.cts

@@ -0,0 +1,26 @@
+/**
+ * Provides diagnostic warnings for SDK configuration and environment issues.
+ *
+ * @remarks
+ * Warnings are deduplicated by message and can be silenced via
+ * the VANA_SDK_SILENCE_WARNINGS environment variable.
+ *
+ * @category Diagnostics
+ */
+/**
+ * Emits a warning message once per unique message content.
+ *
+ * @remarks
+ * Warnings are automatically prefixed with "[vana-sdk]" and deduplicated.
+ * Set `VANA_SDK_SILENCE_WARNINGS=1` to disable all warnings.
+ *
+ * @param msg - Warning message components to display.
+ *
+ * @example
+ * ```typescript
+ * warnOnce("AES-256-CBC not available.", "ECIES will fail.");
+ * ```
+ */
+declare function warnOnce(...msg: unknown[]): void;
+
+export { warnOnce };