@opendatalabs/vana-sdk 0.1.0-alpha.376e2fd → 0.1.0-alpha.3bc04d8

package/dist/platform.js

@@ -75,26 +75,46 @@ var init_error_utils = __esm({
   }
 });
 
+// src/utils/lazy-import.ts
+function lazyImport(importFn) {
+  let cached = null;
+  return () => {
+    if (!cached) {
+      cached = importFn().catch((err) => {
+        cached = null;
+        throw new Error("Failed to load module", { cause: err });
+      });
+    }
+    return cached;
+  };
+}
+var init_lazy_import = __esm({
+  "src/utils/lazy-import.ts"() {
+    "use strict";
+  }
+});
+
 // src/platform/browser.ts
 var browser_exports = {};
 __export(browser_exports, {
   BrowserPlatformAdapter: () => BrowserPlatformAdapter,
   browserPlatformAdapter: () => browserPlatformAdapter
 });
-import * as openpgp from "openpgp";
-var BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserPlatformAdapter, browserPlatformAdapter;
+var getOpenPGP, 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();
+    getOpenPGP = lazyImport(() => import("openpgp"));
     BrowserCryptoAdapter = class {
       async encryptWithPublicKey(data, publicKeyHex) {
         try {
-          const eccrypto2 = await import("eccrypto-js");
+          const eccrypto = await import("eccrypto-js");
           const publicKeyBuffer = Buffer.from(publicKeyHex, "hex");
-          const encrypted = await eccrypto2.encrypt(
+          const encrypted = await eccrypto.encrypt(
             publicKeyBuffer,
             Buffer.from(data, "utf8")
           );
@@ -111,12 +131,12 @@ var init_browser = __esm({
       }
       async decryptWithPrivateKey(encryptedData, privateKeyHex) {
         try {
-          const eccrypto2 = await import("eccrypto-js");
+          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 eccrypto2.decrypt(
+          const decryptedBuffer = await eccrypto.decrypt(
             privateKeyBuffer,
             encryptedObj
           );
@@ -127,11 +147,11 @@ var init_browser = __esm({
       }
       async generateKeyPair() {
         try {
-          const eccrypto2 = await import("eccrypto-js");
+          const eccrypto = await import("eccrypto-js");
           const privateKeyBytes = new Uint8Array(32);
           crypto.getRandomValues(privateKeyBytes);
           const privateKey = Buffer.from(privateKeyBytes);
-          const publicKey = eccrypto2.getPublicCompressed(privateKey);
+          const publicKey = eccrypto.getPublicCompressed(privateKey);
           return {
             privateKey: privateKey.toString("hex"),
             publicKey: publicKey.toString("hex")
@@ -142,9 +162,9 @@ var init_browser = __esm({
       }
       async encryptWithWalletPublicKey(data, publicKey) {
         try {
-          const eccrypto2 = await import("eccrypto-js");
+          const eccrypto = await import("eccrypto-js");
           const uncompressedKey = processWalletPublicKey(publicKey);
-          const encryptedBuffer = await eccrypto2.encrypt(
+          const encryptedBuffer = await eccrypto.encrypt(
             uncompressedKey,
             Buffer.from(data)
           );
@@ -161,12 +181,12 @@ var init_browser = __esm({
       }
       async decryptWithWalletPrivateKey(encryptedData, privateKey) {
         try {
-          const eccrypto2 = await import("eccrypto-js");
+          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 eccrypto2.decrypt(
+          const decryptedBuffer = await eccrypto.decrypt(
             privateKeyBuffer,
             encryptedObj
           );
@@ -177,11 +197,11 @@ var init_browser = __esm({
       }
       async encryptWithPassword(data, password) {
         try {
-          const openpgp3 = await import("openpgp");
-          const message = await openpgp3.createMessage({
+          const openpgp = await getOpenPGP();
+          const message = await openpgp.createMessage({
             binary: data
           });
-          const encrypted = await openpgp3.encrypt({
+          const encrypted = await openpgp.encrypt({
             message,
             passwords: [password],
             format: "binary"
@@ -195,11 +215,11 @@ var init_browser = __esm({
       }
       async decryptWithPassword(encryptedData, password) {
         try {
-          const openpgp3 = await import("openpgp");
-          const message = await openpgp3.readMessage({
+          const openpgp = await getOpenPGP();
+          const message = await openpgp.readMessage({
             binaryMessage: encryptedData
           });
-          const { data: decrypted } = await openpgp3.decrypt({
+          const { data: decrypted } = await openpgp.decrypt({
             message,
             passwords: [password],
             format: "binary"
@@ -213,6 +233,7 @@ var init_browser = __esm({
     BrowserPGPAdapter = class {
       async encrypt(data, publicKeyArmored) {
         try {
+          const openpgp = await getOpenPGP();
           const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
           const encrypted = await openpgp.encrypt({
             message: await openpgp.createMessage({ text: data }),
@@ -228,6 +249,7 @@ var init_browser = __esm({
       }
       async decrypt(encryptedData, privateKeyArmored) {
         try {
+          const openpgp = await getOpenPGP();
           const privateKey = await openpgp.readPrivateKey({
             armoredKey: privateKeyArmored
           });
@@ -245,6 +267,7 @@ var init_browser = __esm({
       }
       async generateKeyPair(options) {
         try {
+          const openpgp = await getOpenPGP();
           const keyGenParams = getPGPKeyGenParams(options);
           const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
           return { publicKey, privateKey };
@@ -261,15 +284,60 @@ var init_browser = __esm({
         return fetch(url, options);
       }
     };
+    BrowserCacheAdapter = class {
+      prefix = "vana_cache_";
+      get(key) {
+        try {
+          if (typeof sessionStorage === "undefined") {
+            return null;
+          }
+          return sessionStorage.getItem(this.prefix + key);
+        } catch {
+          return null;
+        }
+      }
+      set(key, value) {
+        try {
+          if (typeof sessionStorage !== "undefined") {
+            sessionStorage.setItem(this.prefix + key, value);
+          }
+        } catch {
+        }
+      }
+      delete(key) {
+        try {
+          if (typeof sessionStorage !== "undefined") {
+            sessionStorage.removeItem(this.prefix + key);
+          }
+        } catch {
+        }
+      }
+      clear() {
+        try {
+          if (typeof sessionStorage === "undefined") {
+            return;
+          }
+          const keys = Object.keys(sessionStorage);
+          for (const key of keys) {
+            if (key.startsWith(this.prefix)) {
+              sessionStorage.removeItem(key);
+            }
+          }
+        } catch {
+        }
+      }
+    };
     BrowserPlatformAdapter = class {
       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();
@@ -283,8 +351,6 @@ init_browser();
 init_crypto_utils();
 init_pgp_utils();
 init_error_utils();
-import { randomBytes } from "crypto";
-import * as openpgp2 from "openpgp";
 
 // src/platform/shared/stream-utils.ts
 async function streamToUint8Array(stream) {
@@ -310,29 +376,16 @@ async function streamToUint8Array(stream) {
 }
 
 // src/platform/node.ts
-var eccrypto = null;
-async function getEccrypto() {
-  if (!eccrypto) {
-    try {
-      const eccryptoLib = await import("eccrypto");
-      eccrypto = {
-        encrypt: eccryptoLib.encrypt,
-        decrypt: eccryptoLib.decrypt,
-        getPublicCompressed: eccryptoLib.getPublicCompressed
-      };
-    } catch (error) {
-      throw new Error(`Failed to load eccrypto library: ${error}`);
-    }
-  }
-  return eccrypto;
-}
+init_lazy_import();
+var getOpenPGP2 = lazyImport(() => import("openpgp"));
+var getEccrypto = lazyImport(() => import("eccrypto"));
 var NodeCryptoAdapter = class {
   async encryptWithPublicKey(data, publicKeyHex) {
     try {
-      const eccryptoLib = await getEccrypto();
+      const eccrypto = await getEccrypto();
       const publicKey = Buffer.from(publicKeyHex, "hex");
       const message = Buffer.from(data, "utf8");
-      const encrypted = await eccryptoLib.encrypt(publicKey, message);
+      const encrypted = await eccrypto.encrypt(publicKey, message);
       const result = Buffer.concat([
         encrypted.iv,
         encrypted.ephemPublicKey,
@@ -346,15 +399,12 @@ var NodeCryptoAdapter = class {
   }
   async decryptWithPrivateKey(encryptedData, privateKeyHex) {
     try {
-      const eccryptoLib = await getEccrypto();
+      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 eccryptoLib.decrypt(
-        privateKeyBuffer,
-        encryptedObj
-      );
+      const decrypted = await eccrypto.decrypt(privateKeyBuffer, encryptedObj);
       return decrypted.toString("utf8");
     } catch (error) {
       throw new Error(`Decryption failed: ${error}`);
@@ -362,9 +412,9 @@ var NodeCryptoAdapter = class {
   }
   async generateKeyPair() {
     try {
-      const eccryptoLib = await getEccrypto();
-      const privateKey = randomBytes(32);
-      const publicKey = eccryptoLib.getPublicCompressed(privateKey);
+      const eccrypto = await getEccrypto();
+      const privateKey = eccrypto.generatePrivate();
+      const publicKey = eccrypto.getPublicCompressed(privateKey);
       return {
         privateKey: privateKey.toString("hex"),
         publicKey: publicKey.toString("hex")
@@ -375,9 +425,9 @@ var NodeCryptoAdapter = class {
   }
   async encryptWithWalletPublicKey(data, publicKey) {
     try {
-      const eccryptoLib = await getEccrypto();
+      const eccrypto = await getEccrypto();
       const uncompressedKey = processWalletPublicKey(publicKey);
-      const encrypted = await eccryptoLib.encrypt(
+      const encrypted = await eccrypto.encrypt(
         uncompressedKey,
         Buffer.from(data)
       );
@@ -394,12 +444,12 @@ var NodeCryptoAdapter = class {
   }
   async decryptWithWalletPrivateKey(encryptedData, privateKey) {
     try {
-      const eccryptoLib = await getEccrypto();
+      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 eccryptoLib.decrypt(
+      const decryptedBuffer = await eccrypto.decrypt(
         privateKeyBuffer,
         encryptedObj
       );
@@ -410,10 +460,11 @@ var NodeCryptoAdapter = class {
   }
   async encryptWithPassword(data, password) {
     try {
-      const message = await openpgp2.createMessage({
+      const openpgp = await getOpenPGP2();
+      const message = await openpgp.createMessage({
         binary: data
       });
-      const encrypted = await openpgp2.encrypt({
+      const encrypted = await openpgp.encrypt({
         message,
         passwords: [password],
         format: "binary"
@@ -433,10 +484,11 @@ var NodeCryptoAdapter = class {
   }
   async decryptWithPassword(encryptedData, password) {
     try {
-      const message = await openpgp2.readMessage({
+      const openpgp = await getOpenPGP2();
+      const message = await openpgp.readMessage({
         binaryMessage: encryptedData
       });
-      const { data: decrypted } = await openpgp2.decrypt({
+      const { data: decrypted } = await openpgp.decrypt({
         message,
         passwords: [password],
         format: "binary"
@@ -450,12 +502,13 @@ var NodeCryptoAdapter = class {
 var NodePGPAdapter = class {
   async encrypt(data, publicKeyArmored) {
     try {
-      const publicKey = await openpgp2.readKey({ armoredKey: publicKeyArmored });
-      const encrypted = await openpgp2.encrypt({
-        message: await openpgp2.createMessage({ text: data }),
+      const openpgp = await getOpenPGP2();
+      const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
+      const encrypted = await openpgp.encrypt({
+        message: await openpgp.createMessage({ text: data }),
         encryptionKeys: publicKey,
         config: {
-          preferredCompressionAlgorithm: openpgp2.enums.compression.zlib
+          preferredCompressionAlgorithm: openpgp.enums.compression.zlib
         }
       });
       return encrypted;
@@ -465,13 +518,14 @@ var NodePGPAdapter = class {
   }
   async decrypt(encryptedData, privateKeyArmored) {
     try {
-      const privateKey = await openpgp2.readPrivateKey({
+      const openpgp = await getOpenPGP2();
+      const privateKey = await openpgp.readPrivateKey({
         armoredKey: privateKeyArmored
       });
-      const message = await openpgp2.readMessage({
+      const message = await openpgp.readMessage({
         armoredMessage: encryptedData
       });
-      const { data: decrypted } = await openpgp2.decrypt({
+      const { data: decrypted } = await openpgp.decrypt({
         message,
         decryptionKeys: privateKey
       });
@@ -482,8 +536,9 @@ var NodePGPAdapter = class {
   }
   async generateKeyPair(options) {
     try {
+      const openpgp = await getOpenPGP2();
       const keyGenParams = getPGPKeyGenParams(options);
-      const { privateKey, publicKey } = await openpgp2.generateKey(keyGenParams);
+      const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
       return { publicKey, privateKey };
     } catch (error) {
       throw wrapCryptoError("PGP key generation", error);
@@ -498,15 +553,45 @@ var NodeHttpAdapter = class {
     throw new Error("No fetch implementation available in Node.js environment");
   }
 };
+var NodeCacheAdapter = class {
+  cache = /* @__PURE__ */ new Map();
+  defaultTtl = 2 * 60 * 60 * 1e3;
+  // 2 hours in milliseconds
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() > entry.expires) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  set(key, value) {
+    this.cache.set(key, {
+      value,
+      expires: Date.now() + this.defaultTtl
+    });
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
 var NodePlatformAdapter = class {
   crypto;
   pgp;
   http;
+  cache;
   platform = "node";
   constructor() {
     this.crypto = new NodeCryptoAdapter();
     this.pgp = new NodePGPAdapter();
     this.http = new NodeHttpAdapter();
+    this.cache = new NodeCacheAdapter();
   }
 };
 var nodePlatformAdapter = new NodePlatformAdapter();