@opendatalabs/vana-sdk 0.1.0-alpha.ffe4659 → 2.0.0

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_viem.concat)([
+      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} from \"../../utils/crypto-utils\";\nimport { stringToBytes, bytesToString, toHex, fromHex, concat } 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 = concat([\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,0BAIO;AACP,kBAAqE;AAiB9D,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,oBAAO;AAAA,MACpB,UAAU;AAAA,MACV,UAAU;AAAA,MACV,UAAU;AAAA,MACV,UAAU;AAAA,IACZ,CAAC;AAGD,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.ts

@@ -0,0 +1,88 @@
+/**
+ * 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
+ */
+import type { ECIESProvider, ECIESEncrypted } from "../ecies/interface";
+export 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
+ */
+export 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;
+}

package/dist/crypto/services/WalletKeyEncryptionService.js

@@ -0,0 +1,108 @@
+import {
+  processWalletPublicKey,
+  processWalletPrivateKey,
+  parseEncryptedDataBuffer
+} from "../../utils/crypto-utils";
+import { stringToBytes, bytesToString, toHex, fromHex, concat } from "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 = processWalletPublicKey(publicKey);
+    const normalizedKey = this.eciesProvider.normalizeToUncompressed(publicKeyBytes);
+    const dataBytes = stringToBytes(data);
+    const encrypted = await this.eciesProvider.encrypt(
+      normalizedKey,
+      dataBytes
+    );
+    const result = concat([
+      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} from \"../../utils/crypto-utils\";\nimport { stringToBytes, bytesToString, toHex, fromHex, concat } 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 = concat([\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,OACK;AACP,SAAS,eAAe,eAAe,OAAO,SAAS,cAAc;AAiB9D,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,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,OAAO;AAAA,MACpB,UAAU;AAAA,MACV,UAAU;AAAA,MACV,UAAU;AAAA,MACV,UAAU;AAAA,IACZ,CAAC;AAGD,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/crypto/services/WalletKeyEncryptionService.test.d.ts

@@ -0,0 +1 @@
+export {};

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.ts

@@ -0,0 +1,24 @@
+/**
+ * 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.");
+ * ```
+ */
+export declare function warnOnce(...msg: unknown[]): void;

package/dist/diagnostics.js

@@ -0,0 +1,13 @@
+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);
+}
+export {
+  warnOnce
+};
+//# sourceMappingURL=diagnostics.js.map

package/dist/diagnostics.js.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":"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.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/errors.cjs

@@ -0,0 +1,186 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  BlockchainError: () => BlockchainError,
+  ContractNotFoundError: () => ContractNotFoundError,
+  InvalidConfigurationError: () => InvalidConfigurationError,
+  NetworkError: () => NetworkError,
+  NonceError: () => NonceError,
+  PermissionError: () => PermissionError,
+  PersonalServerError: () => PersonalServerError,
+  ReadOnlyError: () => ReadOnlyError,
+  RelayerError: () => RelayerError,
+  SerializationError: () => SerializationError,
+  ServerUrlMismatchError: () => ServerUrlMismatchError,
+  SignatureError: () => SignatureError,
+  TransactionPendingError: () => TransactionPendingError,
+  UserRejectedRequestError: () => UserRejectedRequestError,
+  VanaError: () => VanaError
+});
+module.exports = __toCommonJS(errors_exports);
+class VanaError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = this.constructor.name;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+class RelayerError extends VanaError {
+  constructor(message, statusCode, response) {
+    super(message, "RELAYER_ERROR");
+    this.statusCode = statusCode;
+    this.response = response;
+  }
+}
+class UserRejectedRequestError extends VanaError {
+  constructor(message = "User rejected the signature request") {
+    super(message, "USER_REJECTED_REQUEST");
+  }
+}
+class InvalidConfigurationError extends VanaError {
+  constructor(message) {
+    super(message, "INVALID_CONFIGURATION");
+  }
+}
+class ContractNotFoundError extends VanaError {
+  constructor(contractName, chainId) {
+    super(
+      `Contract ${contractName} not found on chain ${chainId}`,
+      "CONTRACT_NOT_FOUND"
+    );
+  }
+}
+class BlockchainError extends VanaError {
+  constructor(message, originalError) {
+    super(message, "BLOCKCHAIN_ERROR");
+    this.originalError = originalError;
+  }
+}
+class SerializationError extends VanaError {
+  constructor(message) {
+    super(message, "SERIALIZATION_ERROR");
+  }
+}
+class SignatureError extends VanaError {
+  constructor(message, originalError) {
+    super(message, "SIGNATURE_ERROR");
+    this.originalError = originalError;
+  }
+}
+class NetworkError extends VanaError {
+  constructor(message, originalError) {
+    super(message, "NETWORK_ERROR");
+    this.originalError = originalError;
+  }
+}
+class NonceError extends VanaError {
+  constructor(message) {
+    super(message, "NONCE_ERROR");
+  }
+}
+class PersonalServerError extends VanaError {
+  constructor(message, originalError) {
+    super(message, "PERSONAL_SERVER_ERROR");
+    this.originalError = originalError;
+  }
+}
+class ServerUrlMismatchError extends VanaError {
+  constructor(existingUrl, providedUrl, serverId) {
+    super(
+      `Server ${serverId} is already registered with URL "${existingUrl}". Cannot change to "${providedUrl}".`,
+      "SERVER_URL_MISMATCH"
+    );
+    this.existingUrl = existingUrl;
+    this.providedUrl = providedUrl;
+    this.serverId = serverId;
+  }
+  existingUrl;
+  providedUrl;
+  serverId;
+}
+class PermissionError extends VanaError {
+  constructor(message, originalError) {
+    super(message, "PERMISSION_ERROR");
+    this.originalError = originalError;
+  }
+}
+class ReadOnlyError extends VanaError {
+  constructor(operation, suggestion = "Initialize the SDK with a walletClient to perform this operation") {
+    super(
+      `Operation '${operation}' requires a wallet client. ${suggestion}`,
+      "READ_ONLY_ERROR"
+    );
+    this.operation = operation;
+    this.suggestion = suggestion;
+  }
+  /** The operation that was attempted */
+  operation;
+  /** Suggested solution for fixing the error */
+  suggestion;
+}
+class TransactionPendingError extends VanaError {
+  constructor(operationId, message, lastKnownStatus) {
+    super(
+      `Transaction operation pending: ${message} (operationId: ${operationId})`,
+      "TRANSACTION_PENDING"
+    );
+    this.operationId = operationId;
+    this.lastKnownStatus = lastKnownStatus;
+  }
+  /**
+   * Converts the error to a JSON-serializable format.
+   *
+   * @remarks
+   * Useful for logging, storage, or transmission of error details.
+   *
+   * @returns JSON representation of the error
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      operationId: this.operationId,
+      lastKnownStatus: this.lastKnownStatus
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BlockchainError,
+  ContractNotFoundError,
+  InvalidConfigurationError,
+  NetworkError,
+  NonceError,
+  PermissionError,
+  PersonalServerError,
+  ReadOnlyError,
+  RelayerError,
+  SerializationError,
+  ServerUrlMismatchError,
+  SignatureError,
+  TransactionPendingError,
+  UserRejectedRequestError,
+  VanaError
+});
+//# sourceMappingURL=errors.cjs.map