@opendatalabs/vana-sdk 0.1.0-alpha.606fa2d → 0.1.0-alpha.61efc06

package/dist/index.node.js

@@ -1,11 +1,5 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -14,6 +8,53 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/platform/shared/crypto-utils.ts
+function processWalletPublicKey(publicKey) {
+  const publicKeyHex = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+  const publicKeyBytes = Buffer.from(publicKeyHex, "hex");
+  return publicKeyBytes.length === 64 ? Buffer.concat([Buffer.from([4]), publicKeyBytes]) : publicKeyBytes;
+}
+function processWalletPrivateKey(privateKey) {
+  const privateKeyHex = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
+  return Buffer.from(privateKeyHex, "hex");
+}
+function parseEncryptedDataBuffer(encryptedBuffer) {
+  return {
+    iv: encryptedBuffer.slice(0, 16),
+    ephemPublicKey: encryptedBuffer.slice(16, 81),
+    // 65 bytes for uncompressed public key
+    ciphertext: encryptedBuffer.slice(81, -32),
+    mac: encryptedBuffer.slice(-32)
+  };
+}
+function toBase64(str) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(str, "utf8").toString("base64");
+  } else if (typeof btoa !== "undefined") {
+    return btoa(str);
+  } else {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let result = "";
+    let i = 0;
+    while (i < str.length) {
+      const a = str.charCodeAt(i++);
+      const b = i < str.length ? str.charCodeAt(i++) : 0;
+      const c = i < str.length ? str.charCodeAt(i++) : 0;
+      const bitmap = a << 16 | b << 8 | c;
+      result += chars.charAt(bitmap >> 18 & 63);
+      result += chars.charAt(bitmap >> 12 & 63);
+      result += i - 2 < str.length ? chars.charAt(bitmap >> 6 & 63) : "=";
+      result += i - 1 < str.length ? chars.charAt(bitmap & 63) : "=";
+    }
+    return result;
+  }
+}
+var init_crypto_utils = __esm({
+  "src/platform/shared/crypto-utils.ts"() {
+    "use strict";
+  }
+});
+
 // src/platform/shared/pgp-utils.ts
 function processPGPKeyOptions(options) {
   return {
@@ -75,626 +116,6 @@ var init_lazy_import = __esm({
   }
 });
 
-// src/utils/encoding.ts
-function toBase64(data) {
-  if (typeof Buffer !== "undefined" && Buffer.from) {
-    return Buffer.from(data).toString("base64");
-  }
-  if (typeof btoa !== "undefined") {
-    const binary = Array.from(data, (byte) => String.fromCharCode(byte)).join(
-      ""
-    );
-    return btoa(binary);
-  }
-  throw new Error("No base64 encoding method available in this environment");
-}
-function toHex(data) {
-  if (typeof Buffer !== "undefined" && Buffer.from) {
-    return Buffer.from(data).toString("hex");
-  }
-  return Array.from(data, (byte) => byte.toString(16).padStart(2, "0")).join(
-    ""
-  );
-}
-function fromHex(hex) {
-  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-  if (cleanHex.length % 2 !== 0) {
-    throw new Error("Invalid hex string: odd length");
-  }
-  if (!/^[0-9a-fA-F]*$/.test(cleanHex)) {
-    throw new Error("Invalid hex string: contains non-hex characters");
-  }
-  if (typeof Buffer !== "undefined" && Buffer.from) {
-    return new Uint8Array(Buffer.from(cleanHex, "hex"));
-  }
-  const bytes = new Uint8Array(cleanHex.length / 2);
-  for (let i = 0; i < cleanHex.length; i += 2) {
-    bytes[i / 2] = parseInt(cleanHex.substr(i, 2), 16);
-  }
-  return bytes;
-}
-function stringToBytes(str) {
-  if (typeof Buffer !== "undefined" && Buffer.from) {
-    return new Uint8Array(Buffer.from(str, "utf8"));
-  }
-  if (typeof TextEncoder !== "undefined") {
-    return new TextEncoder().encode(str);
-  }
-  const bytes = [];
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    if (char < 128) {
-      bytes.push(char);
-    } else if (char < 2048) {
-      bytes.push(192 | char >> 6, 128 | char & 63);
-    } else if (char < 55296 || char >= 57344) {
-      bytes.push(
-        224 | char >> 12,
-        128 | char >> 6 & 63,
-        128 | char & 63
-      );
-    } else {
-      i++;
-      const char2 = str.charCodeAt(i);
-      const codePoint = 65536 + ((char & 1023) << 10 | char2 & 1023);
-      bytes.push(
-        240 | codePoint >> 18,
-        128 | codePoint >> 12 & 63,
-        128 | codePoint >> 6 & 63,
-        128 | codePoint & 63
-      );
-    }
-  }
-  return new Uint8Array(bytes);
-}
-function bytesToString(bytes) {
-  if (typeof Buffer !== "undefined" && Buffer.from) {
-    return Buffer.from(bytes).toString("utf8");
-  }
-  if (typeof TextDecoder !== "undefined") {
-    return new TextDecoder().decode(bytes);
-  }
-  let str = "";
-  let i = 0;
-  while (i < bytes.length) {
-    const byte = bytes[i];
-    if (byte < 128) {
-      str += String.fromCharCode(byte);
-      i++;
-    } else if ((byte & 224) === 192) {
-      str += String.fromCharCode((byte & 31) << 6 | bytes[i + 1] & 63);
-      i += 2;
-    } else if ((byte & 240) === 224) {
-      str += String.fromCharCode(
-        (byte & 15) << 12 | (bytes[i + 1] & 63) << 6 | bytes[i + 2] & 63
-      );
-      i += 3;
-    } else {
-      const codePoint = ((byte & 7) << 18 | (bytes[i + 1] & 63) << 12 | (bytes[i + 2] & 63) << 6 | bytes[i + 3] & 63) - 65536;
-      str += String.fromCharCode(
-        55296 + (codePoint >> 10),
-        56320 + (codePoint & 1023)
-      );
-      i += 4;
-    }
-  }
-  return str;
-}
-var init_encoding = __esm({
-  "src/utils/encoding.ts"() {
-    "use strict";
-  }
-});
-
-// src/utils/crypto-utils.ts
-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 hexToBytes(hex) {
-  return fromHex(hex);
-}
-function bytesToHex(bytes) {
-  return toHex(bytes);
-}
-function processWalletPublicKey(publicKey) {
-  const publicKeyHex = typeof publicKey === "string" ? publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey : bytesToHex(publicKey);
-  const publicKeyBytes = hexToBytes(publicKeyHex);
-  return publicKeyBytes.length === 64 ? concatBytes(new Uint8Array([4]), publicKeyBytes) : publicKeyBytes;
-}
-function processWalletPrivateKey(privateKey) {
-  const privateKeyHex = typeof privateKey === "string" ? privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey : bytesToHex(privateKey);
-  return hexToBytes(privateKeyHex);
-}
-function parseEncryptedDataBuffer(encryptedBuffer) {
-  return {
-    iv: encryptedBuffer.slice(0, 16),
-    ephemPublicKey: encryptedBuffer.slice(16, 81),
-    // 65 bytes for uncompressed public key
-    ciphertext: encryptedBuffer.slice(81, -32),
-    mac: encryptedBuffer.slice(-32)
-  };
-}
-var init_crypto_utils = __esm({
-  "src/utils/crypto-utils.ts"() {
-    "use strict";
-    init_encoding();
-  }
-});
-
-// src/crypto/services/WalletKeyEncryptionService.ts
-var WalletKeyEncryptionService;
-var init_WalletKeyEncryptionService = __esm({
-  "src/crypto/services/WalletKeyEncryptionService.ts"() {
-    "use strict";
-    init_crypto_utils();
-    init_encoding();
-    WalletKeyEncryptionService = class {
-      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 dataBytes = stringToBytes(data);
-        const encrypted = await this.eciesProvider.encrypt(
-          publicKeyBytes,
-          dataBytes
-        );
-        const result = concatBytes(
-          encrypted.iv,
-          encrypted.ephemPublicKey,
-          encrypted.ciphertext,
-          encrypted.mac
-        );
-        return bytesToHex(result);
-      }
-      /**
-       * 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 encryptedBytes = hexToBytes(encryptedData);
-        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);
-        return this.eciesProvider.encrypt(publicKeyBytes, 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;
-      }
-    };
-  }
-});
-
-// src/crypto/ecies/constants.ts
-var CURVE, CIPHER, KDF, MAC, FORMAT;
-var init_constants = __esm({
-  "src/crypto/ecies/constants.ts"() {
-    "use strict";
-    CURVE = {
-      /** The elliptic curve used (secp256k1 - same as Bitcoin/Ethereum) */
-      name: "secp256k1",
-      /** Private key length in bytes */
-      PRIVATE_KEY_LENGTH: 32,
-      /** Compressed public key length in bytes (0x02 or 0x03 prefix + 32 bytes) */
-      COMPRESSED_PUBLIC_KEY_LENGTH: 33,
-      /** Uncompressed public key length in bytes (0x04 prefix + 64 bytes) */
-      UNCOMPRESSED_PUBLIC_KEY_LENGTH: 65,
-      /** ECDH shared secret X coordinate length */
-      SHARED_SECRET_LENGTH: 32,
-      /** Public key prefixes */
-      PREFIX: {
-        /** Uncompressed public key prefix */
-        UNCOMPRESSED: 4,
-        /** Compressed public key prefix for even Y */
-        COMPRESSED_EVEN: 2,
-        /** Compressed public key prefix for odd Y */
-        COMPRESSED_ODD: 3
-      },
-      /** X coordinate starts at byte 1 (after prefix) */
-      X_COORDINATE_OFFSET: 1,
-      /** X coordinate ends at byte 33 (1 + 32) */
-      X_COORDINATE_END: 33
-    };
-    CIPHER = {
-      /** Cipher algorithm - must match eccrypto */
-      algorithm: "aes-256-cbc",
-      /** AES key length in bytes */
-      KEY_LENGTH: 32,
-      /** Initialization vector length in bytes */
-      IV_LENGTH: 16,
-      /** Block size for AES */
-      BLOCK_SIZE: 16
-    };
-    KDF = {
-      /** Hash algorithm for key derivation - must match eccrypto */
-      algorithm: "sha512",
-      /** Output length of SHA-512 in bytes */
-      OUTPUT_LENGTH: 64,
-      /** Encryption key slice (first 32 bytes of KDF output) */
-      ENCRYPTION_KEY_OFFSET: 0,
-      ENCRYPTION_KEY_LENGTH: 32,
-      /** MAC key slice (last 32 bytes of KDF output) */
-      MAC_KEY_OFFSET: 32,
-      MAC_KEY_LENGTH: 32
-    };
-    MAC = {
-      /** MAC algorithm - must match eccrypto */
-      algorithm: "sha256",
-      /** HMAC-SHA256 output length in bytes */
-      LENGTH: 32
-    };
-    FORMAT = {
-      /** Offsets for each component in serialized format */
-      IV_OFFSET: 0,
-      IV_LENGTH: CIPHER.IV_LENGTH,
-      /** Ephemeral public key (always uncompressed in eccrypto format) */
-      EPHEMERAL_KEY_OFFSET: CIPHER.IV_LENGTH,
-      EPHEMERAL_KEY_LENGTH: CURVE.UNCOMPRESSED_PUBLIC_KEY_LENGTH,
-      /** Ciphertext starts after IV and ephemeral key */
-      CIPHERTEXT_OFFSET: CIPHER.IV_LENGTH + CURVE.UNCOMPRESSED_PUBLIC_KEY_LENGTH,
-      /** MAC is always the last 32 bytes */
-      MAC_LENGTH: MAC.LENGTH,
-      /** Minimum size of encrypted data (IV + ephemKey + MAC, no ciphertext) */
-      MIN_ENCRYPTED_LENGTH: CIPHER.IV_LENGTH + CURVE.UNCOMPRESSED_PUBLIC_KEY_LENGTH + MAC.LENGTH,
-      /**
-       * Helper to calculate total length of encrypted data
-       *
-       * @param ciphertextLength - Length of the ciphertext portion
-       * @returns Total length including all components
-       */
-      getTotalLength: (ciphertextLength) => CIPHER.IV_LENGTH + CURVE.UNCOMPRESSED_PUBLIC_KEY_LENGTH + ciphertextLength + MAC.LENGTH
-    };
-  }
-});
-
-// src/crypto/ecies/interface.ts
-function isECIESEncrypted(obj) {
-  if (!obj || typeof obj !== "object") return false;
-  const enc = obj;
-  const isUint8Array = (value) => {
-    return value instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(value);
-  };
-  return isUint8Array(enc.iv) && enc.iv.length === CIPHER.IV_LENGTH && isUint8Array(enc.ephemPublicKey) && (enc.ephemPublicKey.length === CURVE.UNCOMPRESSED_PUBLIC_KEY_LENGTH || enc.ephemPublicKey.length === CURVE.COMPRESSED_PUBLIC_KEY_LENGTH) && isUint8Array(enc.ciphertext) && enc.ciphertext.length > 0 && isUint8Array(enc.mac) && enc.mac.length === MAC.LENGTH;
-}
-var ECIESError;
-var init_interface = __esm({
-  "src/crypto/ecies/interface.ts"() {
-    "use strict";
-    init_constants();
-    ECIESError = class extends Error {
-      constructor(message, code, cause) {
-        super(message);
-        this.code = code;
-        this.cause = cause;
-        this.name = "ECIESError";
-      }
-    };
-  }
-});
-
-// src/crypto/ecies/utils.ts
-function hexToBytes2(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 bytesToHex2(bytes) {
-  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function stringToBytes2(str) {
-  return new TextEncoder().encode(str);
-}
-function bytesToString2(bytes) {
-  return new TextDecoder().decode(bytes);
-}
-function concatBytes2(...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;
-}
-var init_utils = __esm({
-  "src/crypto/ecies/utils.ts"() {
-    "use strict";
-  }
-});
-
-// src/crypto/ecies/base.ts
-var BaseECIESUint8;
-var init_base = __esm({
-  "src/crypto/ecies/base.ts"() {
-    "use strict";
-    init_interface();
-    init_constants();
-    init_utils();
-    BaseECIESUint8 = class _BaseECIESUint8 {
-      // Cache for validated public keys to avoid repeated validation
-      static validatedKeys = /* @__PURE__ */ new WeakMap();
-      /**
-       * Normalizes a public key to uncompressed format.
-       *
-       * @param publicKey - Public key in any format.
-       * @returns Uncompressed public key (65 bytes).
-       * @throws {ECIESError} If key format is invalid.
-       */
-      normalizePublicKey(publicKey) {
-        if (_BaseECIESUint8.validatedKeys.has(publicKey)) {
-          return publicKey;
-        }
-        if (publicKey.length === CURVE.UNCOMPRESSED_PUBLIC_KEY_LENGTH) {
-          if (publicKey[0] !== CURVE.PREFIX.UNCOMPRESSED) {
-            throw new ECIESError(
-              "Invalid uncompressed public key prefix",
-              "INVALID_KEY"
-            );
-          }
-          if (!this.validatePublicKey(publicKey)) {
-            throw new ECIESError("Invalid public key", "INVALID_KEY");
-          }
-          _BaseECIESUint8.validatedKeys.set(publicKey, true);
-          return publicKey;
-        }
-        if (publicKey.length === CURVE.COMPRESSED_PUBLIC_KEY_LENGTH) {
-          const decompressed = this.decompressPublicKey(publicKey);
-          if (!decompressed) {
-            throw new ECIESError("Failed to decompress public key", "INVALID_KEY");
-          }
-          _BaseECIESUint8.validatedKeys.set(decompressed, true);
-          return decompressed;
-        }
-        throw new ECIESError(
-          `Invalid public key length: ${publicKey.length}`,
-          "INVALID_KEY"
-        );
-      }
-      /**
-       * Encrypts data using ECIES.
-       *
-       * @param publicKey - The recipient's public key (compressed or uncompressed)
-       * @param message - The data to encrypt
-       * @returns Promise resolving to encrypted data structure
-       */
-      async encrypt(publicKey, message) {
-        try {
-          if (!(publicKey instanceof Uint8Array)) {
-            throw new ECIESError("Public key must be a Uint8Array", "INVALID_KEY");
-          }
-          if (!(message instanceof Uint8Array)) {
-            throw new ECIESError(
-              "Message must be a Uint8Array",
-              "ENCRYPTION_FAILED"
-            );
-          }
-          if (publicKey.length === 0) {
-            throw new ECIESError("Public key cannot be empty", "INVALID_KEY");
-          }
-          const pubKey = this.normalizePublicKey(publicKey);
-          let ephemeralPrivateKey;
-          do {
-            ephemeralPrivateKey = this.generateRandomBytes(
-              CURVE.PRIVATE_KEY_LENGTH
-            );
-          } while (!this.verifyPrivateKey(ephemeralPrivateKey));
-          const ephemeralPublicKey = this.createPublicKey(
-            ephemeralPrivateKey,
-            false
-          );
-          if (!ephemeralPublicKey) {
-            throw new ECIESError(
-              "Failed to generate ephemeral public key",
-              "ENCRYPTION_FAILED"
-            );
-          }
-          const sharedSecret = this.performECDH(pubKey, ephemeralPrivateKey);
-          const kdf = this.sha512(sharedSecret);
-          const encryptionKey = kdf.slice(
-            KDF.ENCRYPTION_KEY_OFFSET,
-            KDF.ENCRYPTION_KEY_OFFSET + KDF.ENCRYPTION_KEY_LENGTH
-          );
-          const macKey = kdf.slice(
-            KDF.MAC_KEY_OFFSET,
-            KDF.MAC_KEY_OFFSET + KDF.MAC_KEY_LENGTH
-          );
-          const iv = this.generateRandomBytes(CIPHER.IV_LENGTH);
-          const ciphertext = await this.aesEncrypt(encryptionKey, iv, message);
-          const macData = concatBytes2(iv, ephemeralPublicKey, ciphertext);
-          const mac = this.hmacSha256(macKey, macData);
-          this.clearBuffer(ephemeralPrivateKey);
-          this.clearBuffer(sharedSecret);
-          this.clearBuffer(kdf);
-          return {
-            iv,
-            ephemPublicKey: ephemeralPublicKey,
-            ciphertext,
-            mac
-          };
-        } catch (error) {
-          if (error instanceof ECIESError) throw error;
-          throw new ECIESError(
-            `Encryption failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "ENCRYPTION_FAILED",
-            error instanceof Error ? error : void 0
-          );
-        }
-      }
-      /**
-       * Decrypts ECIES encrypted data.
-       *
-       * @param privateKey - The recipient's private key (32 bytes)
-       * @param encrypted - The encrypted data structure from encrypt()
-       * @returns Promise resolving to the original plaintext
-       */
-      async decrypt(privateKey, encrypted) {
-        try {
-          if (!(privateKey instanceof Uint8Array)) {
-            throw new ECIESError("Private key must be a Uint8Array", "INVALID_KEY");
-          }
-          if (!isECIESEncrypted(encrypted)) {
-            throw new ECIESError(
-              "Invalid encrypted data structure",
-              "DECRYPTION_FAILED"
-            );
-          }
-          if (privateKey.length !== CURVE.PRIVATE_KEY_LENGTH) {
-            throw new ECIESError(
-              `Invalid private key length: ${privateKey.length}`,
-              "INVALID_KEY"
-            );
-          }
-          if (!this.verifyPrivateKey(privateKey)) {
-            throw new ECIESError("Invalid private key", "INVALID_KEY");
-          }
-          const ephemeralPublicKey = this.normalizePublicKey(
-            encrypted.ephemPublicKey
-          );
-          const sharedSecret = this.performECDH(ephemeralPublicKey, privateKey);
-          const kdf = this.sha512(sharedSecret);
-          const encryptionKey = kdf.slice(
-            KDF.ENCRYPTION_KEY_OFFSET,
-            KDF.ENCRYPTION_KEY_OFFSET + KDF.ENCRYPTION_KEY_LENGTH
-          );
-          const macKey = kdf.slice(
-            KDF.MAC_KEY_OFFSET,
-            KDF.MAC_KEY_OFFSET + KDF.MAC_KEY_LENGTH
-          );
-          const macData = concatBytes2(
-            encrypted.iv,
-            encrypted.ephemPublicKey,
-            encrypted.ciphertext
-          );
-          const expectedMac = this.hmacSha256(macKey, macData);
-          if (!constantTimeEqual(encrypted.mac, expectedMac)) {
-            throw new ECIESError("MAC verification failed", "MAC_MISMATCH");
-          }
-          const decrypted = await this.aesDecrypt(
-            encryptionKey,
-            encrypted.iv,
-            encrypted.ciphertext
-          );
-          this.clearBuffer(sharedSecret);
-          this.clearBuffer(kdf);
-          return decrypted;
-        } catch (error) {
-          if (error instanceof ECIESError) throw error;
-          throw new ECIESError(
-            `Decryption failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-            "DECRYPTION_FAILED",
-            error instanceof Error ? error : void 0
-          );
-        }
-      }
-      /**
-       * Clears sensitive data from memory using multi-pass overwrite.
-       *
-       * @remarks
-       * Uses multiple passes with different patterns to make it harder
-       * for JIT compilers to optimize away the operation. While not
-       * guaranteed in JavaScript, this is a best-effort approach to
-       * clear sensitive data from memory.
-       *
-       * @param buffer - The buffer to clear
-       */
-      clearBuffer(buffer) {
-        if (buffer && buffer.length > 0) {
-          buffer.fill(0);
-          buffer.fill(255);
-          buffer.fill(170);
-          buffer.fill(0);
-          for (let i = 0; i < buffer.length; i++) {
-            buffer[i] = i & 255 ^ 90;
-          }
-          buffer.fill(0);
-        }
-      }
-    };
-  }
-});
-
 // src/schemas/dataSchema.schema.json
 var dataSchema_schema_default;
 var init_dataSchema_schema = __esm({
@@ -758,8 +179,10 @@ var init_dataSchema_schema = __esm({
 // src/utils/schemaValidation.ts
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-function validateDataSchema(schema) {
-  return schemaValidator.validateDataSchema(schema);
+function validateDataSchemaAgainstMetaSchema(schema) {
+  const validator = schemaValidator;
+  validator.validateDataSchemaAgainstMetaSchema(schema);
+  return schema;
 }
 function validateDataAgainstSchema(data, schema) {
   return schemaValidator.validateDataAgainstSchema(data, schema);
@@ -792,9 +215,9 @@ var init_schemaValidation = __esm({
         this.dataSchemaValidator = this.ajv.compile(dataSchema_schema_default);
       }
       /**
-       * Validates a data schema against the Vana meta-schema
+       * Validates a data schema definition against the Vana meta-schema
        *
-       * @param schema - The data schema to validate
+       * @param schema - The data schema definition to validate
        * @throws SchemaValidationError if invalid
        * @example
        * ```typescript
@@ -813,10 +236,10 @@ var init_schemaValidation = __esm({
        *   }
        * };
        *
-       * validator.validateDataSchema(schema); // throws if invalid
+       * validator.validateDataSchemaAgainstMetaSchema(schema); // throws if invalid
        * ```
        */
-      validateDataSchema(schema) {
+      validateDataSchemaAgainstMetaSchema(schema) {
         const isValid = this.dataSchemaValidator(schema);
         if (!isValid) {
           const errors = this.dataSchemaValidator.errors || [];
@@ -836,10 +259,10 @@ var init_schemaValidation = __esm({
         }
       }
       /**
-       * Validates data against a JSON Schema from a schema
+       * Validates data against a JSON Schema
        *
        * @param data - The data to validate
-       * @param schema - The schema containing the validation rules (DataSchema or Schema)
+       * @param schema - The schema containing the validation rules (must have been validated or fetched from chain)
        * @throws SchemaValidationError if invalid
        * @example
        * ```typescript
@@ -849,25 +272,22 @@ var init_schemaValidation = __esm({
        * const schema = await vana.schemas.get(1);
        * validator.validateDataAgainstSchema(userData, schema);
        *
-       * // Also works with DataSchema object
-       * const dataSchema: DataSchema = {
+       * // Also works with pre-validated DataSchema object
+       * const dataSchema = validator.validateDataSchemaAgainstMetaSchema({
        *   name: "User Profile",
        *   version: "1.0.0",
        *   dialect: "json",
        *   schema: { type: "object", properties: { name: { type: "string" } } }
-       * };
+       * });
        * validator.validateDataAgainstSchema(userData, dataSchema);
        * ```
        */
       validateDataAgainstSchema(data, schema) {
-        if (!("id" in schema)) {
-          this.validateDataSchema(schema);
-        }
         if (schema.dialect !== "json") {
-          throw new SchemaValidationError(
-            `Data validation only supported for JSON dialect, got: ${schema.dialect}`,
-            []
+          console.warn(
+            `[SchemaValidator] Data validation skipped: dialect '${schema.dialect}' does not support data validation. Only JSON schemas can validate data structure.`
           );
+          return;
         }
         if (typeof schema.schema !== "object") {
           throw new SchemaValidationError(
@@ -933,9 +353,9 @@ var init_schemaValidation = __esm({
         }
       }
       /**
-       * Fetches and validates a schema from a URL
+       * Fetches and validates a data schema from a URL
        *
-       * @param url - The URL to fetch the schema from
+       * @param url - The URL to fetch the data schema from
        * @returns The validated data schema
        * @throws SchemaValidationError if invalid or fetch fails
        * @example
@@ -951,7 +371,7 @@ var init_schemaValidation = __esm({
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
           }
           const schema = await response.json();
-          this.validateDataSchema(schema);
+          this.validateDataSchemaAgainstMetaSchema(schema);
           if (schema.dialect === "sqlite" && typeof schema.schema === "string") {
             this.validateSQLiteDDL(schema.schema, schema.dialectVersion);
           }
@@ -1600,19 +1020,19 @@ var init_eventMappings = __esm({
       // DataRegistry operations
       addFile: {
         contract: "DataRegistry",
-        event: "FileAdded"
+        event: "FileAddedV2"
       },
       addFileWithPermissionsAndSchema: {
         contract: "DataRegistry",
-        event: "FileAdded"
+        event: "FileAddedV2"
       },
       addFileWithSchema: {
         contract: "DataRegistry",
-        event: "FileAdded"
+        event: "FileAddedV2"
       },
       addFileWithPermissions: {
         contract: "DataRegistry",
-        event: "FileAdded"
+        event: "FileAddedV2"
       },
       addRefinement: {
         contract: "DataRegistry",
@@ -3099,6 +2519,37 @@ var init_DataRegistryImplementation = __esm({
         name: "FileAdded",
         type: "event"
       },
+      {
+        anonymous: false,
+        inputs: [
+          {
+            indexed: true,
+            internalType: "uint256",
+            name: "fileId",
+            type: "uint256"
+          },
+          {
+            indexed: true,
+            internalType: "address",
+            name: "ownerAddress",
+            type: "address"
+          },
+          {
+            indexed: false,
+            internalType: "string",
+            name: "url",
+            type: "string"
+          },
+          {
+            indexed: false,
+            internalType: "uint256",
+            name: "schemaId",
+            type: "uint256"
+          }
+        ],
+        name: "FileAddedV2",
+        type: "event"
+      },
       {
         anonymous: false,
         inputs: [
@@ -3646,6 +3097,19 @@ var init_DataRegistryImplementation = __esm({
         stateMutability: "view",
         type: "function"
       },
+      {
+        inputs: [],
+        name: "emitLegacyEvents",
+        outputs: [
+          {
+            internalType: "bool",
+            name: "",
+            type: "bool"
+          }
+        ],
+        stateMutability: "view",
+        type: "function"
+      },
       {
         inputs: [
           {
@@ -3803,6 +3267,11 @@ var init_DataRegistryImplementation = __esm({
                 name: "url",
                 type: "string"
               },
+              {
+                internalType: "uint256",
+                name: "schemaId",
+                type: "uint256"
+              },
               {
                 internalType: "uint256",
                 name: "addedAtBlock",
@@ -4086,6 +3555,19 @@ var init_DataRegistryImplementation = __esm({
         stateMutability: "nonpayable",
         type: "function"
       },
+      {
+        inputs: [
+          {
+            internalType: "bool",
+            name: "newEmitLegacyEvents",
+            type: "bool"
+          }
+        ],
+        name: "updateEmitLegacyEvents",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
       {
         inputs: [
           {
@@ -36891,7 +36373,7 @@ var init_schemas = __esm({
             dialect,
             schema: schemaDefinition
           };
-          validateDataSchema(dataSchema);
+          validateDataSchemaAgainstMetaSchema(dataSchema);
           if (!this.context.storageManager) {
             if (this.context.validateStorageRequired) {
               this.context.validateStorageRequired();
@@ -37000,7 +36482,7 @@ var init_schemas = __esm({
             `Invalid schema definition format for schema ${schemaId}`
           );
         }
-        validateDataSchema(definition);
+        validateDataSchemaAgainstMetaSchema(definition);
         const dataSchema = definition;
         if (dataSchema.name !== metadata.name) {
           throw new Error(
@@ -37335,7 +36817,7 @@ var init_schemas = __esm({
             try {
               const definition = await fetchFromUrl(schema.definitionUrl);
               if (definition && typeof definition === "object") {
-                validateDataSchema(definition);
+                validateDataSchemaAgainstMetaSchema(definition);
                 const dataSchema = definition;
                 schema.version = dataSchema.version;
                 schema.description = dataSchema.description;
@@ -37354,204 +36836,123 @@ var init_schemas = __esm({
   }
 });
 
-// src/crypto/ecies/browser.ts
-import * as secp256k12 from "@noble/secp256k1";
-import { hmac } from "@noble/hashes/hmac";
-import { sha256 as sha2562, sha512 as nobleSha512 } from "@noble/hashes/sha2";
-var BrowserECIESUint8Provider;
-var init_browser = __esm({
-  "src/crypto/ecies/browser.ts"() {
-    "use strict";
-    init_base();
-    BrowserECIESUint8Provider = class extends BaseECIESUint8 {
-      generateRandomBytes(length) {
-        const bytes = new Uint8Array(length);
-        crypto.getRandomValues(bytes);
-        return bytes;
-      }
-      verifyPrivateKey(privateKey) {
-        try {
-          return secp256k12.utils.isValidPrivateKey(privateKey);
-        } catch {
-          return false;
-        }
-      }
-      createPublicKey(privateKey, compressed) {
-        try {
-          return secp256k12.getPublicKey(privateKey, compressed);
-        } catch {
-          return null;
-        }
-      }
-      validatePublicKey(publicKey) {
-        try {
-          secp256k12.Point.fromHex(publicKey);
-          return true;
-        } catch {
-          return false;
-        }
-      }
-      decompressPublicKey(publicKey) {
-        try {
-          const point = secp256k12.Point.fromHex(publicKey);
-          return point.toRawBytes(false);
-        } catch {
-          return null;
-        }
-      }
-      performECDH(publicKey, privateKey) {
-        try {
-          const sharedPoint = secp256k12.getSharedSecret(
-            privateKey,
-            publicKey,
-            true
-          );
-          return sharedPoint.slice(1);
-        } catch (error) {
-          throw new Error(
-            `ECDH failed: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
-      }
-      sha512(data) {
-        return nobleSha512(data);
-      }
-      hmacSha256(key, data) {
-        return hmac(sha2562, key, data);
-      }
-      async aesEncrypt(key, iv, plaintext) {
-        const cryptoKey = await crypto.subtle.importKey(
-          "raw",
-          key,
-          { name: "AES-CBC" },
-          false,
-          ["encrypt"]
-        );
-        const encrypted = await crypto.subtle.encrypt(
-          { name: "AES-CBC", iv },
-          cryptoKey,
-          plaintext
-        );
-        return new Uint8Array(encrypted);
-      }
-      async aesDecrypt(key, iv, ciphertext) {
-        const cryptoKey = await crypto.subtle.importKey(
-          "raw",
-          key,
-          { name: "AES-CBC" },
-          false,
-          ["decrypt"]
-        );
-        const decrypted = await crypto.subtle.decrypt(
-          { name: "AES-CBC", iv },
-          cryptoKey,
-          ciphertext
-        );
-        return new Uint8Array(decrypted);
-      }
-    };
-  }
-});
-
 // src/platform/browser.ts
 var browser_exports = {};
 __export(browser_exports, {
-  BrowserPlatformAdapter: () => BrowserPlatformAdapter
+  BrowserPlatformAdapter: () => BrowserPlatformAdapter,
+  browserPlatformAdapter: () => browserPlatformAdapter
 });
-import * as secp256k13 from "@noble/secp256k1";
-var getOpenPGP2, BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserCacheAdapter, BrowserPlatformAdapter;
-var init_browser2 = __esm({
+var getOpenPGP2, BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserCacheAdapter, BrowserPlatformAdapter, browserPlatformAdapter;
+var init_browser = __esm({
   "src/platform/browser.ts"() {
     "use strict";
+    init_crypto_utils();
     init_pgp_utils();
     init_error_utils();
     init_lazy_import();
-    init_WalletKeyEncryptionService();
-    init_crypto_utils();
-    init_utils();
-    init_browser();
     getOpenPGP2 = lazyImport(() => import("openpgp"));
     BrowserCryptoAdapter = class {
-      eciesProvider = new BrowserECIESUint8Provider();
-      walletKeyEncryptionService = new WalletKeyEncryptionService({
-        eciesProvider: this.eciesProvider
-      });
       async encryptWithPublicKey(data, publicKeyHex) {
         try {
-          const publicKeyBytes = hexToBytes2(publicKeyHex);
-          const encrypted = await this.eciesProvider.encrypt(
-            publicKeyBytes,
-            stringToBytes2(data)
+          const eccrypto = await import("eccrypto-js");
+          const publicKeyBuffer = Buffer.from(publicKeyHex, "hex");
+          const encrypted = await eccrypto.encrypt(
+            publicKeyBuffer,
+            Buffer.from(data, "utf8")
           );
-          const result = concatBytes2(
+          const result = Buffer.concat([
             encrypted.iv,
             encrypted.ephemPublicKey,
             encrypted.ciphertext,
             encrypted.mac
-          );
-          return bytesToHex2(result);
+          ]);
+          return result.toString("hex");
         } catch (error) {
-          throw wrapCryptoError("encryptWithPublicKey", error);
+          throw new Error(`Encryption failed: ${error}`);
         }
       }
       async decryptWithPrivateKey(encryptedData, privateKeyHex) {
         try {
-          const encryptedBytes = hexToBytes2(encryptedData);
-          const privateKeyBytes = hexToBytes2(privateKeyHex);
-          const encrypted = parseEncryptedDataBuffer(encryptedBytes);
-          const decrypted = await this.eciesProvider.decrypt(
-            privateKeyBytes,
-            encrypted
+          const eccrypto = await import("eccrypto-js");
+          const privateKeyBuffer = processWalletPrivateKey(privateKeyHex);
+          const encryptedBuffer = Buffer.from(encryptedData, "hex");
+          const { iv, ephemPublicKey, ciphertext, mac } = parseEncryptedDataBuffer(encryptedBuffer);
+          const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };
+          const decryptedBuffer = await eccrypto.decrypt(
+            privateKeyBuffer,
+            encryptedObj
           );
-          return bytesToString2(decrypted);
+          return decryptedBuffer.toString("utf8");
         } catch (error) {
-          throw wrapCryptoError("decryptWithPrivateKey", error);
+          throw new Error(`Decryption failed: ${error}`);
         }
       }
-      async encryptWithWalletPublicKey(data, publicKey) {
+      async generateKeyPair() {
         try {
-          return await this.walletKeyEncryptionService.encryptWithWalletPublicKey(
-            data,
-            publicKey
-          );
+          const eccrypto = await import("eccrypto-js");
+          const privateKeyBytes = new Uint8Array(32);
+          crypto.getRandomValues(privateKeyBytes);
+          const privateKey = Buffer.from(privateKeyBytes);
+          const publicKey = eccrypto.getPublicCompressed(privateKey);
+          return {
+            privateKey: privateKey.toString("hex"),
+            publicKey: publicKey.toString("hex")
+          };
         } catch (error) {
-          throw wrapCryptoError("encryptWithWalletPublicKey", error);
+          throw wrapCryptoError("key generation", error);
         }
       }
-      async decryptWithWalletPrivateKey(encryptedData, privateKey) {
+      async encryptWithWalletPublicKey(data, publicKey) {
         try {
-          return await this.walletKeyEncryptionService.decryptWithWalletPrivateKey(
-            encryptedData,
-            privateKey
+          const eccrypto = await import("eccrypto-js");
+          const uncompressedKey = processWalletPublicKey(publicKey);
+          const encryptedBuffer = await eccrypto.encrypt(
+            uncompressedKey,
+            Buffer.from(data)
           );
+          const result = Buffer.concat([
+            encryptedBuffer.iv,
+            encryptedBuffer.ephemPublicKey,
+            encryptedBuffer.ciphertext,
+            encryptedBuffer.mac
+          ]);
+          return result.toString("hex");
         } catch (error) {
-          throw wrapCryptoError("decryptWithWalletPrivateKey", error);
+          throw wrapCryptoError("encrypt with wallet public key", error);
         }
       }
-      async generateKeyPair() {
+      async decryptWithWalletPrivateKey(encryptedData, privateKey) {
         try {
-          const privateKeyBytes = secp256k13.utils.randomPrivateKey();
-          const publicKeyBytes = secp256k13.getPublicKey(privateKeyBytes, true);
-          return {
-            privateKey: bytesToHex2(privateKeyBytes),
-            publicKey: bytesToHex2(publicKeyBytes)
-          };
+          const eccrypto = await import("eccrypto-js");
+          const privateKeyBuffer = processWalletPrivateKey(privateKey);
+          const encryptedBuffer = Buffer.from(encryptedData, "hex");
+          const { iv, ephemPublicKey, ciphertext, mac } = parseEncryptedDataBuffer(encryptedBuffer);
+          const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };
+          const decryptedBuffer = await eccrypto.decrypt(
+            privateKeyBuffer,
+            encryptedObj
+          );
+          return decryptedBuffer.toString("utf8");
         } catch (error) {
-          throw wrapCryptoError("generateKeyPair", error);
+          throw wrapCryptoError("decrypt with wallet private key", error);
         }
       }
       async encryptWithPassword(data, password) {
         try {
           const openpgp = await getOpenPGP2();
-          const message = await openpgp.createMessage({ binary: data });
+          const message = await openpgp.createMessage({
+            binary: data
+          });
           const encrypted = await openpgp.encrypt({
             message,
             passwords: [password],
             format: "binary"
           });
-          return new Uint8Array(encrypted);
+          const response = new Response(encrypted);
+          const arrayBuffer = await response.arrayBuffer();
+          return new Uint8Array(arrayBuffer);
         } catch (error) {
-          throw wrapCryptoError("encryptWithPassword", error);
+          throw new Error(`Failed to encrypt with password: ${error}`);
         }
       }
       async decryptWithPassword(encryptedData, password) {
@@ -37560,14 +36961,14 @@ var init_browser2 = __esm({
           const message = await openpgp.readMessage({
             binaryMessage: encryptedData
           });
-          const { data } = await openpgp.decrypt({
+          const { data: decrypted } = await openpgp.decrypt({
             message,
             passwords: [password],
             format: "binary"
           });
-          return new Uint8Array(data);
+          return new Uint8Array(decrypted);
         } catch (error) {
-          throw wrapCryptoError("decryptWithPassword", error);
+          throw new Error(`Failed to decrypt with password: ${error}`);
         }
       }
     };
@@ -37619,6 +37020,9 @@ var init_browser2 = __esm({
     };
     BrowserHttpAdapter = class {
       async fetch(url, options) {
+        if (typeof fetch === "undefined") {
+          throw new Error("Fetch API not available in this browser environment");
+        }
         return fetch(url, options);
       }
     };
@@ -37636,19 +37040,17 @@ var init_browser2 = __esm({
       }
       set(key, value) {
         try {
-          if (typeof sessionStorage === "undefined") {
-            return;
+          if (typeof sessionStorage !== "undefined") {
+            sessionStorage.setItem(this.prefix + key, value);
           }
-          sessionStorage.setItem(this.prefix + key, value);
         } catch {
         }
       }
       delete(key) {
         try {
-          if (typeof sessionStorage === "undefined") {
-            return;
+          if (typeof sessionStorage !== "undefined") {
+            sessionStorage.removeItem(this.prefix + key);
           }
-          sessionStorage.removeItem(this.prefix + key);
         } catch {
         }
       }
@@ -37657,29 +37059,35 @@ var init_browser2 = __esm({
           if (typeof sessionStorage === "undefined") {
             return;
           }
-          const keysToRemove = [];
-          for (let i = 0; i < sessionStorage.length; i++) {
-            const key = sessionStorage.key(i);
-            if (key?.startsWith(this.prefix)) {
-              keysToRemove.push(key);
+          const keys = Object.keys(sessionStorage);
+          for (const key of keys) {
+            if (key.startsWith(this.prefix)) {
+              sessionStorage.removeItem(key);
             }
           }
-          keysToRemove.forEach((key) => sessionStorage.removeItem(key));
         } catch {
         }
       }
     };
     BrowserPlatformAdapter = class {
-      crypto = new BrowserCryptoAdapter();
-      pgp = new BrowserPGPAdapter();
-      http = new BrowserHttpAdapter();
-      cache = new BrowserCacheAdapter();
+      crypto;
+      pgp;
+      http;
+      cache;
       platform = "browser";
+      constructor() {
+        this.crypto = new BrowserCryptoAdapter();
+        this.pgp = new BrowserPGPAdapter();
+        this.http = new BrowserHttpAdapter();
+        this.cache = new BrowserCacheAdapter();
+      }
     };
+    browserPlatformAdapter = new BrowserPlatformAdapter();
   }
 });
 
 // src/platform/node.ts
+init_crypto_utils();
 init_pgp_utils();
 init_error_utils();
 
@@ -37708,129 +37116,15 @@ async function streamToUint8Array(stream) {
 
 // src/platform/node.ts
 init_lazy_import();
-init_WalletKeyEncryptionService();
-init_crypto_utils();
-
-// src/crypto/ecies/node.ts
-init_base();
-import {
-  randomBytes,
-  createHash,
-  createHmac,
-  createCipheriv,
-  createDecipheriv
-} from "crypto";
-var secp256k1;
-try {
-  secp256k1 = __require("secp256k1");
-} catch {
-  throw new Error(
-    "Native secp256k1 module not found. Please install with: npm install secp256k1\nThis is required for optimal performance in Node.js environments."
-  );
-}
-var NodeECIESUint8Provider = class extends BaseECIESUint8 {
-  // 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));
-  }
-  verifyPrivateKey(privateKey) {
-    return secp256k1.privateKeyVerify(Buffer.from(privateKey)) === true;
-  }
-  createPublicKey(privateKey, compressed) {
-    try {
-      return new Uint8Array(
-        secp256k1.publicKeyCreate(Buffer.from(privateKey), compressed)
-      );
-    } catch {
-      return null;
-    }
-  }
-  validatePublicKey(publicKey) {
-    return secp256k1.publicKeyVerify(Buffer.from(publicKey)) === true;
-  }
-  decompressPublicKey(publicKey) {
-    try {
-      return new Uint8Array(
-        secp256k1.publicKeyConvert(Buffer.from(publicKey), false)
-      );
-    } catch {
-      return null;
-    }
-  }
-  performECDH(publicKey, privateKey) {
-    try {
-      const output = Buffer.alloc(32);
-      secp256k1.ecdh(
-        Buffer.from(publicKey),
-        Buffer.from(privateKey),
-        { hashfn: this.identityHashFn },
-        output
-      );
-      return new Uint8Array(output);
-    } catch (error) {
-      throw new Error(
-        `ECDH failed: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  sha512(data) {
-    return new Uint8Array(
-      createHash("sha512").update(Buffer.from(data)).digest()
-    );
-  }
-  hmacSha256(key, data) {
-    return new Uint8Array(
-      createHmac("sha256", Buffer.from(key)).update(Buffer.from(data)).digest()
-    );
-  }
-  async aesEncrypt(key, iv, plaintext) {
-    const cipher = createCipheriv(
-      "aes-256-cbc",
-      Buffer.from(key),
-      Buffer.from(iv)
-    );
-    const encrypted = Buffer.concat([
-      cipher.update(Buffer.from(plaintext)),
-      cipher.final()
-    ]);
-    return new Uint8Array(encrypted);
-  }
-  async aesDecrypt(key, iv, ciphertext) {
-    const decipher = createDecipheriv(
-      "aes-256-cbc",
-      Buffer.from(key),
-      Buffer.from(iv)
-    );
-    const decrypted = Buffer.concat([
-      decipher.update(Buffer.from(ciphertext)),
-      decipher.final()
-    ]);
-    return new Uint8Array(decrypted);
-  }
-  // No Buffer compatibility methods - Uint8Array only public API
-};
-
-// src/platform/node.ts
-init_interface();
 var getOpenPGP = lazyImport(() => import("openpgp"));
+var getEccrypto = lazyImport(() => import("eccrypto"));
 var NodeCryptoAdapter = class {
-  eciesProvider = new NodeECIESUint8Provider();
-  walletKeyEncryptionService = new WalletKeyEncryptionService({
-    eciesProvider: this.eciesProvider
-  });
   async encryptWithPublicKey(data, publicKeyHex) {
     try {
+      const eccrypto = await getEccrypto();
       const publicKey = Buffer.from(publicKeyHex, "hex");
       const message = Buffer.from(data, "utf8");
-      const encrypted = await this.eciesProvider.encrypt(publicKey, message);
+      const encrypted = await eccrypto.encrypt(publicKey, message);
       const result = Buffer.concat([
         encrypted.iv,
         encrypted.ephemPublicKey,
@@ -37839,54 +37133,27 @@ var NodeCryptoAdapter = class {
       ]);
       return result.toString("hex");
     } catch (error) {
-      if (error instanceof ECIESError) {
-        throw error;
-      }
-      throw new ECIESError(
-        `Encryption failed: ${error instanceof Error ? error.message : String(error)}`,
-        "ENCRYPTION_FAILED",
-        error instanceof Error ? error : void 0
-      );
+      throw new Error(`Encryption failed: ${error}`);
     }
   }
   async decryptWithPrivateKey(encryptedData, privateKeyHex) {
     try {
+      const eccrypto = await getEccrypto();
       const privateKeyBuffer = processWalletPrivateKey(privateKeyHex);
       const encryptedBuffer = Buffer.from(encryptedData, "hex");
       const { iv, ephemPublicKey, ciphertext, mac } = parseEncryptedDataBuffer(encryptedBuffer);
-      const encryptedObj = {
-        iv,
-        ephemPublicKey,
-        ciphertext,
-        mac
-      };
-      const decrypted = await this.eciesProvider.decrypt(
-        privateKeyBuffer,
-        encryptedObj
-      );
-      return new TextDecoder().decode(decrypted);
+      const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };
+      const decrypted = await eccrypto.decrypt(privateKeyBuffer, encryptedObj);
+      return decrypted.toString("utf8");
     } catch (error) {
-      if (error instanceof ECIESError) {
-        throw error;
-      }
-      throw new ECIESError(
-        `Decryption failed: ${error instanceof Error ? error.message : String(error)}`,
-        "DECRYPTION_FAILED",
-        error instanceof Error ? error : void 0
-      );
+      throw new Error(`Decryption failed: ${error}`);
     }
   }
   async generateKeyPair() {
     try {
-      const { randomBytes: randomBytes2 } = await import("crypto");
-      const secp256k14 = await import("secp256k1");
-      let privateKey;
-      do {
-        privateKey = randomBytes2(32);
-      } while (!secp256k14.privateKeyVerify(privateKey));
-      const publicKey = Buffer.from(
-        secp256k14.publicKeyCreate(privateKey, true)
-      );
+      const eccrypto = await getEccrypto();
+      const privateKey = eccrypto.generatePrivate();
+      const publicKey = eccrypto.getPublicCompressed(privateKey);
       return {
         privateKey: privateKey.toString("hex"),
         publicKey: publicKey.toString("hex")
@@ -37897,20 +37164,35 @@ var NodeCryptoAdapter = class {
   }
   async encryptWithWalletPublicKey(data, publicKey) {
     try {
-      return await this.walletKeyEncryptionService.encryptWithWalletPublicKey(
-        data,
-        publicKey
+      const eccrypto = await getEccrypto();
+      const uncompressedKey = processWalletPublicKey(publicKey);
+      const encrypted = await eccrypto.encrypt(
+        uncompressedKey,
+        Buffer.from(data)
       );
+      const result = Buffer.concat([
+        encrypted.iv,
+        encrypted.ephemPublicKey,
+        encrypted.ciphertext,
+        encrypted.mac
+      ]);
+      return result.toString("hex");
     } catch (error) {
       throw wrapCryptoError("encrypt with wallet public key", error);
     }
   }
   async decryptWithWalletPrivateKey(encryptedData, privateKey) {
     try {
-      return await this.walletKeyEncryptionService.decryptWithWalletPrivateKey(
-        encryptedData,
-        privateKey
+      const eccrypto = await getEccrypto();
+      const privateKeyBuffer = processWalletPrivateKey(privateKey);
+      const encryptedBuffer = Buffer.from(encryptedData, "hex");
+      const { iv, ephemPublicKey, ciphertext, mac } = parseEncryptedDataBuffer(encryptedBuffer);
+      const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };
+      const decryptedBuffer = await eccrypto.decrypt(
+        privateKeyBuffer,
+        encryptedObj
       );
+      return decryptedBuffer.toString("utf8");
     } catch (error) {
       throw wrapCryptoError("decrypt with wallet private key", error);
     }
@@ -38082,6 +37364,9 @@ var StorageError = class extends Error {
   }
 };
 
+// src/types/index.ts
+init_schemaValidation();
+
 // src/types/external-apis.ts
 function isReplicateAPIResponse(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -38123,7 +37408,7 @@ init_abi();
 
 // src/utils/grantFiles.ts
 init_errors();
-import { keccak256, toHex as toHex2 } from "viem";
+import { keccak256, toHex } from "viem";
 function createGrantFile(params) {
   const grantFile = {
     grantee: params.grantee,
@@ -38246,8 +37531,8 @@ function getGrantFileHash(grantFile) {
       sortedFile.expires = grantFile.expires;
     }
     const jsonString = JSON.stringify(sortedFile);
-    console.info(`Hash: ${keccak256(toHex2(jsonString))}`);
-    return keccak256(toHex2(jsonString));
+    console.info(`Hash: ${keccak256(toHex(jsonString))}`);
+    return keccak256(toHex(jsonString));
   } catch (error) {
     throw new SerializationError(
       `Failed to generate grant file hash: ${error instanceof Error ? error.message : "Unknown error"}`
@@ -38524,8 +37809,7 @@ function validateOperationAccess(grantFile, requestedOperation) {
 }
 
 // src/utils/signatureCache.ts
-import { sha256 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex3 } from "@noble/hashes/utils";
+init_crypto_utils();
 var SignatureCache = class {
   static PREFIX = "vana_sig_";
   static DEFAULT_TTL_HOURS = 2;
@@ -38624,12 +37908,12 @@ var SignatureCache = class {
    * Generate a deterministic hash of a message object for cache key generation
    *
    * @remarks
-   * Creates a cryptographically secure hash from complex objects including EIP-712 typed data.
-   * Uses SHA-256 for collision resistance and deterministic key generation.
-   * Handles BigInt serialization and sorts object keys for consistency.
+   * Creates a consistent hash from complex objects including EIP-712 typed data.
+   * Handles BigInt serialization and produces a 32-character hash that balances
+   * uniqueness with key length constraints.
    *
    * @param message - The message object to hash (typically EIP-712 typed data)
-   * @returns A hex string hash (SHA-256) suitable for cache keys
+   * @returns A 32-character hash string suitable for cache keys
    * @example
    * ```typescript
    * const typedData = {
@@ -38638,35 +37922,30 @@ var SignatureCache = class {
    * };
    *
    * const hash = SignatureCache.hashMessage(typedData);
-   * // Returns SHA-256 hash like: "a1b2c3d4e5f6..."
+   * // Returns something like: "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"
    * ```
    */
   static hashMessage(message) {
-    const jsonString = JSON.stringify(message, this.deterministicReplacer);
-    const hashBytes = sha256(new TextEncoder().encode(jsonString));
-    return bytesToHex3(hashBytes);
+    const jsonString = JSON.stringify(message, this.bigIntReplacer);
+    const base64Hash = toBase64(jsonString);
+    const cleaned = base64Hash.replace(/[^a-zA-Z0-9]/g, "");
+    if (cleaned.length > 32) {
+      return cleaned.substring(0, 16) + cleaned.substring(cleaned.length - 16);
+    }
+    return cleaned.substring(0, 32);
   }
   /**
-   * Deterministic JSON replacer that handles BigInt values and sorts object keys
-   * This ensures consistent cache key generation for EIP-712 typed data
+   * Custom JSON replacer that converts BigInt values to strings for serialization
+   * This ensures deterministic cache key generation for EIP-712 typed data
    *
    * @param _key - The object key being serialized (unused)
    * @param value - The value to serialize
-   * @returns The serialized value with sorted keys for objects
+   * @returns The serialized value
    */
-  static deterministicReplacer(_key, value) {
+  static bigIntReplacer(_key, value) {
     if (typeof value === "bigint") {
       return `__BIGINT__${value.toString()}`;
     }
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      return Object.keys(value).sort().reduce(
-        (sorted, key) => {
-          sorted[key] = value[key];
-          return sorted;
-        },
-        {}
-      );
-    }
     return value;
   }
 };
@@ -42907,6 +42186,29 @@ var DataController = class {
       const userFiles = Array.from(fileMap.values()).sort(
         (a, b) => Number((b.addedAtTimestamp || 0n) - (a.addedAtTimestamp || 0n))
       );
+      if (userFiles.length > 0) {
+        try {
+          const fileIds = userFiles.map((f) => f.id);
+          let proofMap;
+          try {
+            proofMap = await this._fetchProofsFromSubgraph(fileIds, endpoint);
+          } catch (subgraphError) {
+            console.debug(
+              "Failed to fetch proofs from subgraph, trying chain:",
+              subgraphError
+            );
+            proofMap = await this._fetchProofsFromChain(fileIds);
+          }
+          for (const file of userFiles) {
+            const dlpIds = proofMap.get(file.id);
+            if (dlpIds && dlpIds.length > 0) {
+              file.dlpIds = dlpIds;
+            }
+          }
+        } catch (error) {
+          console.warn("Failed to fetch proof data for files:", error);
+        }
+      }
       return userFiles;
     } catch (error) {
       console.error("Failed to fetch user files from subgraph:", error);
@@ -42915,6 +42217,349 @@ var DataController = class {
       );
     }
   }
+  /**
+   * Fetches proof data for multiple files from the subgraph.
+   *
+   * @private
+   * @param fileIds - Array of file IDs to fetch proofs for
+   * @param subgraphUrl - The subgraph endpoint URL
+   * @returns Map of file IDs to their associated DLP IDs
+   */
+  async _fetchProofsFromSubgraph(fileIds, subgraphUrl) {
+    const query = `
+      query GetFileProofs($fileIds: [BigInt!]!) {
+        dataRegistryProofs(where: { fileId_in: $fileIds }) {
+          fileId
+          dlp {
+            id
+          }
+        }
+      }
+    `;
+    const response = await fetch(subgraphUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        query,
+        variables: {
+          fileIds: fileIds.map((id) => id.toString())
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Subgraph request failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const result = await response.json();
+    if (result.errors) {
+      throw new Error(
+        `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
+      );
+    }
+    const proofMap = /* @__PURE__ */ new Map();
+    if (result.data?.dataRegistryProofs) {
+      for (const proof of result.data.dataRegistryProofs) {
+        if (proof.dlp?.id) {
+          const fileId = parseInt(proof.fileId);
+          const dlpId = parseInt(proof.dlp.id);
+          if (!proofMap.has(fileId)) {
+            proofMap.set(fileId, []);
+          }
+          const dlpIds = proofMap.get(fileId);
+          if (!dlpIds.includes(dlpId)) {
+            dlpIds.push(dlpId);
+          }
+        }
+      }
+    }
+    return proofMap;
+  }
+  /**
+   * Fetches proof data for multiple files from the blockchain.
+   * Falls back to this when subgraph is unavailable.
+   *
+   * @private
+   * @param fileIds - Array of file IDs to fetch proofs for
+   * @returns Map of file IDs to their associated DLP IDs
+   */
+  async _fetchProofsFromChain(fileIds) {
+    const chainId = this.context.walletClient.chain?.id;
+    if (!chainId) {
+      throw new Error("Chain ID not available");
+    }
+    const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+    const dataRegistryAbi = getAbi("DataRegistry");
+    const proofMap = /* @__PURE__ */ new Map();
+    for (const fileId of fileIds) {
+      const dlpIds = [];
+      let proofIndex = 0;
+      let hasMoreProofs = true;
+      while (hasMoreProofs) {
+        try {
+          const proof = await this.context.publicClient.readContract({
+            address: dataRegistryAddress,
+            abi: dataRegistryAbi,
+            functionName: "fileProofs",
+            args: [BigInt(fileId), BigInt(proofIndex)]
+          });
+          if (proof?.data?.dlpId) {
+            const dlpId = Number(proof.data.dlpId);
+            if (!dlpIds.includes(dlpId)) {
+              dlpIds.push(dlpId);
+            }
+          }
+          proofIndex++;
+        } catch {
+          hasMoreProofs = false;
+        }
+      }
+      if (dlpIds.length > 0) {
+        proofMap.set(fileId, dlpIds);
+      }
+    }
+    return proofMap;
+  }
+  /**
+   * Retrieves information about a specific Data Liquidity Pool (DLP).
+   *
+   * @remarks
+   * DLPs are entities that process and verify data files in the Vana network.
+   * This method fetches DLP metadata including name, status, and performance rating.
+   * Uses subgraph first for efficiency, falls back to chain if unavailable.
+   *
+   * @param dlpId - The unique identifier of the DLP
+   * @param options - Optional parameters
+   * @param options.subgraphUrl - Custom subgraph URL to override default
+   * @returns Promise resolving to DLP information
+   * @throws {Error} When DLP cannot be found - "DLP not found: {dlpId}"
+   * @throws {Error} When query fails - "Failed to fetch DLP: {error}"
+   * @example
+   * ```typescript
+   * const dlp = await vana.data.getDLP(26);
+   * console.log(`DLP ${dlp.name}: ${dlp.status}`);
+   * ```
+   */
+  async getDLP(dlpId, options = {}) {
+    const subgraphUrl = options.subgraphUrl || this.context.subgraphUrl;
+    if (subgraphUrl) {
+      try {
+        const query = `
+          query GetDLP($id: ID!) {
+            dlp(id: $id) {
+              id
+              name
+              metadata
+              status
+              address
+              owner
+            }
+          }
+        `;
+        const response = await fetch(subgraphUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            query,
+            variables: {
+              id: dlpId.toString()
+            }
+          })
+        });
+        if (!response.ok) {
+          throw new Error(
+            `Subgraph request failed: ${response.status} ${response.statusText}`
+          );
+        }
+        const result = await response.json();
+        if (result.errors) {
+          throw new Error(
+            `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
+          );
+        }
+        if (!result.data?.dlp) {
+          throw new Error(`DLP not found: ${dlpId}`);
+        }
+        return {
+          id: parseInt(result.data.dlp.id),
+          name: result.data.dlp.name || "",
+          metadata: result.data.dlp.metadata,
+          status: result.data.dlp.status ? parseInt(result.data.dlp.status) : void 0,
+          address: result.data.dlp.address,
+          owner: result.data.dlp.owner
+        };
+      } catch (error) {
+        console.debug("Subgraph query failed, falling back to chain:", error);
+      }
+    }
+    try {
+      const chainId = this.context.walletClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dlpRegistryAddress = getContractAddress(chainId, "DLPRegistry");
+      const dlpRegistryAbi = getAbi("DLPRegistry");
+      const dlpData = await this.context.publicClient.readContract({
+        address: dlpRegistryAddress,
+        abi: dlpRegistryAbi,
+        functionName: "dlps",
+        args: [BigInt(dlpId)]
+      });
+      if (!dlpData || !dlpData.name) {
+        throw new Error(`DLP not found: ${dlpId}`);
+      }
+      return {
+        id: dlpId,
+        name: dlpData.name,
+        metadata: dlpData.metadata,
+        status: dlpData.status,
+        address: dlpData.dlpAddress,
+        owner: dlpData.ownerAddress
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to fetch DLP: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Lists all Data Liquidity Pools (DLPs) with optional pagination.
+   *
+   * @remarks
+   * Fetches a paginated list of all DLPs registered in the network.
+   * Uses subgraph for efficient querying with fallback to chain multicall.
+   *
+   * @param options - Optional parameters for pagination and filtering
+   * @param options.limit - Maximum number of DLPs to return (default: 100)
+   * @param options.offset - Number of DLPs to skip (default: 0)
+   * @param options.subgraphUrl - Custom subgraph URL to override default
+   * @returns Promise resolving to array of DLP information
+   * @throws {Error} When query fails - "Failed to list DLPs: {error}"
+   * @example
+   * ```typescript
+   * // Get first 10 DLPs
+   * const dlps = await vana.data.listDLPs({ limit: 10 });
+   * dlps.forEach(dlp => console.log(`${dlp.id}: ${dlp.name}`));
+   *
+   * // Get next page
+   * const nextPage = await vana.data.listDLPs({ limit: 10, offset: 10 });
+   * ```
+   */
+  async listDLPs(options = {}) {
+    const { limit = 100, offset = 0 } = options;
+    const subgraphUrl = options.subgraphUrl || this.context.subgraphUrl;
+    if (subgraphUrl) {
+      try {
+        const query = `
+          query ListDLPs($first: Int!, $skip: Int!) {
+            dlps(first: $first, skip: $skip, orderBy: id) {
+              id
+              name
+              metadata
+              status
+              address
+              owner
+            }
+          }
+        `;
+        const response = await fetch(subgraphUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            query,
+            variables: {
+              first: limit,
+              skip: offset
+            }
+          })
+        });
+        if (!response.ok) {
+          throw new Error(
+            `Subgraph request failed: ${response.status} ${response.statusText}`
+          );
+        }
+        const result = await response.json();
+        if (result.errors) {
+          throw new Error(
+            `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
+          );
+        }
+        const dlps = result.data?.dlps || [];
+        return dlps.map((dlp) => ({
+          id: parseInt(dlp.id),
+          name: dlp.name || "",
+          metadata: dlp.metadata,
+          status: dlp.status ? parseInt(dlp.status) : void 0,
+          address: dlp.address,
+          owner: dlp.owner
+        }));
+      } catch (error) {
+        console.debug("Subgraph query failed, falling back to chain:", error);
+      }
+    }
+    try {
+      const chainId = this.context.walletClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dlpRegistryAddress = getContractAddress(chainId, "DLPRegistry");
+      const dlpRegistryAbi = getAbi("DLPRegistry");
+      const dlpCount = await this.context.publicClient.readContract({
+        address: dlpRegistryAddress,
+        abi: dlpRegistryAbi,
+        functionName: "dlpsCount",
+        args: []
+      });
+      const totalCount = Number(dlpCount);
+      const start = offset;
+      const end = Math.min(start + limit, totalCount);
+      if (end <= start) {
+        return [];
+      }
+      const calls = [];
+      for (let i = start + 1; i <= end; i++) {
+        calls.push({
+          address: dlpRegistryAddress,
+          abi: dlpRegistryAbi,
+          functionName: "dlps",
+          args: [BigInt(i)]
+        });
+      }
+      const results = await gasAwareMulticall(this.context.publicClient, {
+        contracts: calls,
+        allowFailure: true,
+        batchSize: 50
+      });
+      const dlps = [];
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === "success" && result.result) {
+          const dlpData = result.result;
+          if (dlpData.name) {
+            dlps.push({
+              id: start + i + 1,
+              name: dlpData.name,
+              metadata: dlpData.metadata,
+              status: dlpData.status,
+              address: dlpData.dlpAddress,
+              owner: dlpData.ownerAddress
+            });
+          }
+        }
+      }
+      return dlps;
+    } catch (error) {
+      throw new Error(
+        `Failed to list DLPs: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
   /**
    * Retrieves a list of permissions granted by a user.
    *
@@ -44341,10 +43986,10 @@ var DataController = class {
     );
   }
   /**
-   * Validates a data schema against the Vana meta-schema.
+   * Validates a data schema definition against the Vana meta-schema.
    *
-   * @param schema - The data schema to validate
-   * @returns Assertion that schema is valid (throws if invalid)
+   * @param schema - The data schema definition to validate
+   * @returns The validated DataSchema
    * @throws SchemaValidationError if invalid
    * @example
    * ```typescript
@@ -44361,11 +44006,11 @@ var DataController = class {
    *   }
    * };
    *
-   * vana.data.validateDataSchema(schema);
+   * const validatedSchema = vana.data.validateDataSchemaAgainstMetaSchema(schema);
    * ```
    */
-  validateDataSchema(schema) {
-    return validateDataSchema(schema);
+  validateDataSchemaAgainstMetaSchema(schema) {
+    return validateDataSchemaAgainstMetaSchema(schema);
   }
   /**
    * Validates data against a JSON Schema from a data schema.
@@ -44398,9 +44043,9 @@ var DataController = class {
     return validateDataAgainstSchema(data, schema);
   }
   /**
-   * Fetches and validates a schema from a URL, then returns the parsed data schema.
+   * Fetches and validates a data schema from a URL, then returns the parsed data schema.
    *
-   * @param url - The URL to fetch the schema from
+   * @param url - The URL to fetch the data schema from
    * @returns The validated data schema
    * @throws SchemaValidationError if invalid or fetch fails
    * @example
@@ -45598,7 +45243,7 @@ var GoogleDriveStorage = class {
 };
 
 // src/storage/providers/ipfs.ts
-init_encoding();
+init_crypto_utils();
 var IpfsStorage = class _IpfsStorage {
   constructor(config) {
     this.config = config;
@@ -45638,9 +45283,8 @@ var IpfsStorage = class _IpfsStorage {
    * ```
    */
   static forInfura(credentials) {
-    const encoder = new TextEncoder();
     const auth = toBase64(
-      encoder.encode(`${credentials.projectId}:${credentials.projectSecret}`)
+      `${credentials.projectId}:${credentials.projectSecret}`
     );
     return new _IpfsStorage({
       apiEndpoint: "https://ipfs.infura.io:5001/api/v0/add",
@@ -46500,7 +46144,7 @@ var vanaMainnet2 = {
       url: "https://vanascan.io"
     }
   },
-  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/vana/7.0.7/gn"
+  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/vana/prod/gn"
 };
 var moksha = {
   id: 14800,
@@ -46521,7 +46165,7 @@ var moksha = {
       url: "https://moksha.vanascan.io"
     }
   },
-  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/moksha/7.0.7/gn"
+  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/moksha/prod/gn"
 };
 function getChainConfig(chainId) {
   switch (chainId) {
@@ -47550,7 +47194,7 @@ async function handleRelayerRequest(sdk, payload) {
 
 // src/index.node.ts
 init_transactionHandle();
-init_browser2();
+init_browser();
 
 // src/platform/utils.ts
 function detectPlatform() {
@@ -47575,7 +47219,7 @@ async function createPlatformAdapter() {
       const { NodePlatformAdapter: NodePlatformAdapter2 } = await import(moduleName);
       return new NodePlatformAdapter2();
     } else {
-      const { BrowserPlatformAdapter: BrowserPlatformAdapter2 } = await Promise.resolve().then(() => (init_browser2(), browser_exports));
+      const { BrowserPlatformAdapter: BrowserPlatformAdapter2 } = await Promise.resolve().then(() => (init_browser(), browser_exports));
       return new BrowserPlatformAdapter2();
     }
   } catch (error) {
@@ -47596,7 +47240,7 @@ async function createPlatformAdapterFor(platformType) {
       const { NodePlatformAdapter: NodePlatformAdapter2 } = await import(moduleName);
       return new NodePlatformAdapter2();
     } else {
-      const { BrowserPlatformAdapter: BrowserPlatformAdapter2 } = await Promise.resolve().then(() => (init_browser2(), browser_exports));
+      const { BrowserPlatformAdapter: BrowserPlatformAdapter2 } = await Promise.resolve().then(() => (init_browser(), browser_exports));
       return new BrowserPlatformAdapter2();
     }
   } catch (error) {
@@ -47623,7 +47267,7 @@ function getPlatformCapabilities() {
 }
 
 // src/platform/browser-safe.ts
-init_browser2();
+init_browser();
 async function createNodePlatformAdapter() {
   if (typeof window !== "undefined") {
     throw new Error(
@@ -48069,7 +47713,7 @@ export {
   storeGrantFile,
   summarizeGrant,
   validateDataAgainstSchema,
-  validateDataSchema,
+  validateDataSchemaAgainstMetaSchema,
   validateGrant,
   validateGrantExpiry,
   validateGrantFile,