@opendatalabs/vana-sdk 0.1.0-alpha.5e925dc → 0.1.0-alpha.e64ec83

package/dist/index.browser.js

@@ -10,6 +10,418 @@ var __export = (target, all) => {
 };
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
+// 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 uint8ArrayToHex(array) {
+  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+var init_crypto_utils = __esm({
+  "src/platform/shared/crypto-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/platform/shared/pgp-utils.ts
+function processPGPKeyOptions(options) {
+  return {
+    name: options?.name || "Vana User",
+    email: options?.email || "user@vana.org",
+    passphrase: options?.passphrase
+  };
+}
+function getPGPKeyGenParams(options) {
+  const { name, email, passphrase } = processPGPKeyOptions(options);
+  return {
+    type: "rsa",
+    rsaBits: 2048,
+    userIDs: [{ name, email }],
+    passphrase,
+    config: STANDARD_PGP_CONFIG
+  };
+}
+var STANDARD_PGP_CONFIG;
+var init_pgp_utils = __esm({
+  "src/platform/shared/pgp-utils.ts"() {
+    "use strict";
+    STANDARD_PGP_CONFIG = {
+      preferredCompressionAlgorithm: 2,
+      // zlib (openpgp.enums.compression.zlib)
+      preferredSymmetricAlgorithm: 7
+      // aes256 (openpgp.enums.symmetric.aes256)
+    };
+  }
+});
+
+// src/platform/shared/error-utils.ts
+function wrapCryptoError(operation, error) {
+  const message = error instanceof Error ? error.message : "Unknown error";
+  return new Error(`${operation} failed: ${message}`);
+}
+var init_error_utils = __esm({
+  "src/platform/shared/error-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/platform/browser.ts
+import * as openpgp from "openpgp";
+function hexToUint8Array(hex) {
+  const result = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    result[i / 2] = parseInt(hex.substr(i, 2), 16);
+  }
+  return result;
+}
+var BrowserECDH, BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserPlatformAdapter, browserPlatformAdapter;
+var init_browser = __esm({
+  "src/platform/browser.ts"() {
+    "use strict";
+    init_crypto_utils();
+    init_pgp_utils();
+    init_error_utils();
+    BrowserECDH = class {
+      async generateKeyPair() {
+        const keyPair = await crypto.subtle.generateKey(
+          {
+            name: "ECDH",
+            namedCurve: "P-256"
+          },
+          true,
+          ["deriveKey", "deriveBits"]
+        );
+        return keyPair;
+      }
+      async encrypt(publicKeyHex, message) {
+        const ephemeralKeyPair = await this.generateKeyPair();
+        const publicKeyData = hexToUint8Array(publicKeyHex);
+        const importedPublicKey = await crypto.subtle.importKey(
+          "raw",
+          publicKeyData,
+          { name: "ECDH", namedCurve: "P-256" },
+          false,
+          []
+        );
+        const sharedKey = await crypto.subtle.deriveKey(
+          { name: "ECDH", public: importedPublicKey },
+          ephemeralKeyPair.privateKey,
+          { name: "AES-GCM", length: 256 },
+          false,
+          ["encrypt"]
+        );
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const encoder = new TextEncoder();
+        const data = encoder.encode(message);
+        const encrypted = await crypto.subtle.encrypt(
+          { name: "AES-GCM", iv },
+          sharedKey,
+          data
+        );
+        const ephemeralPublicKeyData = await crypto.subtle.exportKey(
+          "raw",
+          ephemeralKeyPair.publicKey
+        );
+        return JSON.stringify({
+          encrypted: Array.from(new Uint8Array(encrypted)),
+          iv: Array.from(iv),
+          ephemeralPublicKey: Array.from(new Uint8Array(ephemeralPublicKeyData)),
+          publicKey: publicKeyHex
+        });
+      }
+      async decrypt(privateKeyHex, encryptedData) {
+        try {
+          const data = JSON.parse(encryptedData);
+          if (!data.encrypted || !data.iv || !data.ephemeralPublicKey) {
+            throw new Error("Invalid encrypted data format");
+          }
+          const privateKeyData = hexToUint8Array(privateKeyHex);
+          const importedPrivateKey = await crypto.subtle.importKey(
+            "pkcs8",
+            privateKeyData,
+            { name: "ECDH", namedCurve: "P-256" },
+            false,
+            ["deriveKey"]
+          );
+          const ephemeralPublicKey = await crypto.subtle.importKey(
+            "raw",
+            new Uint8Array(data.ephemeralPublicKey),
+            { name: "ECDH", namedCurve: "P-256" },
+            false,
+            []
+          );
+          const sharedKey = await crypto.subtle.deriveKey(
+            { name: "ECDH", public: ephemeralPublicKey },
+            importedPrivateKey,
+            { name: "AES-GCM", length: 256 },
+            false,
+            ["decrypt"]
+          );
+          const decrypted = await crypto.subtle.decrypt(
+            { name: "AES-GCM", iv: new Uint8Array(data.iv) },
+            sharedKey,
+            new Uint8Array(data.encrypted)
+          );
+          return new TextDecoder().decode(decrypted);
+        } catch (error) {
+          throw new Error(
+            `Decryption failed: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+    };
+    BrowserCryptoAdapter = class {
+      async encryptWithPublicKey(data, publicKeyHex) {
+        try {
+          const ecdh = new BrowserECDH();
+          return await ecdh.encrypt(publicKeyHex, data);
+        } catch (error) {
+          throw new Error(`Encryption failed: ${error}`);
+        }
+      }
+      async decryptWithPrivateKey(encryptedData, privateKeyHex) {
+        try {
+          const ecdh = new BrowserECDH();
+          return await ecdh.decrypt(privateKeyHex, encryptedData);
+        } catch (error) {
+          throw new Error(`Decryption failed: ${error}`);
+        }
+      }
+      async generateKeyPair() {
+        try {
+          const keyPair = await crypto.subtle.generateKey(
+            {
+              name: "ECDH",
+              namedCurve: "P-256"
+            },
+            true,
+            ["deriveKey", "deriveBits"]
+          );
+          const publicKeyBuffer = await crypto.subtle.exportKey(
+            "raw",
+            keyPair.publicKey
+          );
+          const privateKeyBuffer = await crypto.subtle.exportKey(
+            "pkcs8",
+            keyPair.privateKey
+          );
+          return {
+            publicKey: uint8ArrayToHex(new Uint8Array(publicKeyBuffer)),
+            privateKey: uint8ArrayToHex(new Uint8Array(privateKeyBuffer))
+          };
+        } catch (error) {
+          throw wrapCryptoError("key generation", error);
+        }
+      }
+      async encryptWithWalletPublicKey(data, publicKey) {
+        try {
+          const eccrypto = await import("eccrypto-js");
+          const uncompressedKey = processWalletPublicKey(publicKey);
+          const iv = Buffer.from([
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15,
+            16
+          ]);
+          const ephemeralKey = Buffer.from([
+            17,
+            34,
+            51,
+            68,
+            85,
+            102,
+            119,
+            136,
+            153,
+            170,
+            187,
+            204,
+            221,
+            238,
+            255,
+            0,
+            16,
+            32,
+            48,
+            64,
+            80,
+            96,
+            112,
+            128,
+            144,
+            160,
+            176,
+            192,
+            208,
+            224,
+            240,
+            0
+          ]);
+          const encryptedBuffer = await eccrypto.encrypt(
+            uncompressedKey,
+            Buffer.from(data),
+            {
+              iv,
+              ephemPrivateKey: ephemeralKey
+            }
+          );
+          const result = Buffer.concat([
+            encryptedBuffer.iv,
+            encryptedBuffer.ephemPublicKey,
+            encryptedBuffer.ciphertext,
+            encryptedBuffer.mac
+          ]);
+          return result.toString("hex");
+        } catch (error) {
+          throw wrapCryptoError("encrypt with wallet public key", error);
+        }
+      }
+      async decryptWithWalletPrivateKey(encryptedData, privateKey) {
+        try {
+          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("decrypt with wallet private key", error);
+        }
+      }
+      async encryptWithPassword(data, password) {
+        try {
+          const openpgp2 = await import("openpgp");
+          const message = await openpgp2.createMessage({
+            binary: data
+          });
+          const encrypted = await openpgp2.encrypt({
+            message,
+            passwords: [password],
+            format: "binary"
+          });
+          const response = new Response(encrypted);
+          const arrayBuffer = await response.arrayBuffer();
+          return new Uint8Array(arrayBuffer);
+        } catch (error) {
+          throw new Error(`Failed to encrypt with password: ${error}`);
+        }
+      }
+      async decryptWithPassword(encryptedData, password) {
+        try {
+          const openpgp2 = await import("openpgp");
+          const message = await openpgp2.readMessage({
+            binaryMessage: encryptedData
+          });
+          const { data: decrypted } = await openpgp2.decrypt({
+            message,
+            passwords: [password],
+            format: "binary"
+          });
+          return new Uint8Array(decrypted);
+        } catch (error) {
+          throw new Error(`Failed to decrypt with password: ${error}`);
+        }
+      }
+    };
+    BrowserPGPAdapter = class {
+      async encrypt(data, publicKeyArmored) {
+        try {
+          const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
+          const encrypted = await openpgp.encrypt({
+            message: await openpgp.createMessage({ text: data }),
+            encryptionKeys: publicKey,
+            config: {
+              preferredCompressionAlgorithm: openpgp.enums.compression.zlib
+            }
+          });
+          return encrypted;
+        } catch (error) {
+          throw new Error(`PGP encryption failed: ${error}`);
+        }
+      }
+      async decrypt(encryptedData, privateKeyArmored) {
+        try {
+          const privateKey = await openpgp.readPrivateKey({
+            armoredKey: privateKeyArmored
+          });
+          const message = await openpgp.readMessage({
+            armoredMessage: encryptedData
+          });
+          const { data: decrypted } = await openpgp.decrypt({
+            message,
+            decryptionKeys: privateKey
+          });
+          return decrypted;
+        } catch (error) {
+          throw new Error(`PGP decryption failed: ${error}`);
+        }
+      }
+      async generateKeyPair(options) {
+        try {
+          const keyGenParams = getPGPKeyGenParams(options);
+          const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
+          return { publicKey, privateKey };
+        } catch (error) {
+          throw wrapCryptoError("PGP key generation", error);
+        }
+      }
+    };
+    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);
+      }
+    };
+    BrowserPlatformAdapter = class {
+      constructor() {
+        __publicField(this, "crypto");
+        __publicField(this, "pgp");
+        __publicField(this, "http");
+        __publicField(this, "platform", "browser");
+        this.crypto = new BrowserCryptoAdapter();
+        this.pgp = new BrowserPGPAdapter();
+        this.http = new BrowserHttpAdapter();
+      }
+    };
+    browserPlatformAdapter = new BrowserPlatformAdapter();
+  }
+});
+
 // src/utils/ipfs.ts
 var ipfs_exports = {};
 __export(ipfs_exports, {
@@ -117,394 +529,8 @@ var init_ipfs = __esm({
   }
 });
 
-// src/platform/browser.ts
-import * as openpgp from "openpgp";
-
-// 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 uint8ArrayToHex(array) {
-  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
-    ""
-  );
-}
-
-// src/platform/shared/pgp-utils.ts
-var STANDARD_PGP_CONFIG = {
-  preferredCompressionAlgorithm: 2,
-  // zlib (openpgp.enums.compression.zlib)
-  preferredSymmetricAlgorithm: 7
-  // aes256 (openpgp.enums.symmetric.aes256)
-};
-function processPGPKeyOptions(options) {
-  return {
-    name: options?.name || "Vana User",
-    email: options?.email || "user@vana.org",
-    passphrase: options?.passphrase
-  };
-}
-function getPGPKeyGenParams(options) {
-  const { name, email, passphrase } = processPGPKeyOptions(options);
-  return {
-    type: "rsa",
-    rsaBits: 2048,
-    userIDs: [{ name, email }],
-    passphrase,
-    config: STANDARD_PGP_CONFIG
-  };
-}
-
-// src/platform/shared/error-utils.ts
-function wrapCryptoError(operation, error) {
-  const message = error instanceof Error ? error.message : "Unknown error";
-  return new Error(`${operation} failed: ${message}`);
-}
-
-// src/platform/browser.ts
-var BrowserECDH = class {
-  async generateKeyPair() {
-    const keyPair = await crypto.subtle.generateKey(
-      {
-        name: "ECDH",
-        namedCurve: "P-256"
-      },
-      true,
-      ["deriveKey", "deriveBits"]
-    );
-    return keyPair;
-  }
-  async encrypt(publicKeyHex, message) {
-    const ephemeralKeyPair = await this.generateKeyPair();
-    const publicKeyData = hexToUint8Array(publicKeyHex);
-    const importedPublicKey = await crypto.subtle.importKey(
-      "raw",
-      publicKeyData,
-      { name: "ECDH", namedCurve: "P-256" },
-      false,
-      []
-    );
-    const sharedKey = await crypto.subtle.deriveKey(
-      { name: "ECDH", public: importedPublicKey },
-      ephemeralKeyPair.privateKey,
-      { name: "AES-GCM", length: 256 },
-      false,
-      ["encrypt"]
-    );
-    const iv = crypto.getRandomValues(new Uint8Array(12));
-    const encoder = new TextEncoder();
-    const data = encoder.encode(message);
-    const encrypted = await crypto.subtle.encrypt(
-      { name: "AES-GCM", iv },
-      sharedKey,
-      data
-    );
-    const ephemeralPublicKeyData = await crypto.subtle.exportKey(
-      "raw",
-      ephemeralKeyPair.publicKey
-    );
-    return JSON.stringify({
-      encrypted: Array.from(new Uint8Array(encrypted)),
-      iv: Array.from(iv),
-      ephemeralPublicKey: Array.from(new Uint8Array(ephemeralPublicKeyData)),
-      publicKey: publicKeyHex
-    });
-  }
-  async decrypt(privateKeyHex, encryptedData) {
-    try {
-      const data = JSON.parse(encryptedData);
-      if (!data.encrypted || !data.iv || !data.ephemeralPublicKey) {
-        throw new Error("Invalid encrypted data format");
-      }
-      const privateKeyData = hexToUint8Array(privateKeyHex);
-      const importedPrivateKey = await crypto.subtle.importKey(
-        "pkcs8",
-        privateKeyData,
-        { name: "ECDH", namedCurve: "P-256" },
-        false,
-        ["deriveKey"]
-      );
-      const ephemeralPublicKey = await crypto.subtle.importKey(
-        "raw",
-        new Uint8Array(data.ephemeralPublicKey),
-        { name: "ECDH", namedCurve: "P-256" },
-        false,
-        []
-      );
-      const sharedKey = await crypto.subtle.deriveKey(
-        { name: "ECDH", public: ephemeralPublicKey },
-        importedPrivateKey,
-        { name: "AES-GCM", length: 256 },
-        false,
-        ["decrypt"]
-      );
-      const decrypted = await crypto.subtle.decrypt(
-        { name: "AES-GCM", iv: new Uint8Array(data.iv) },
-        sharedKey,
-        new Uint8Array(data.encrypted)
-      );
-      return new TextDecoder().decode(decrypted);
-    } catch (error) {
-      throw new Error(
-        `Decryption failed: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-};
-function hexToUint8Array(hex) {
-  const result = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    result[i / 2] = parseInt(hex.substr(i, 2), 16);
-  }
-  return result;
-}
-var BrowserCryptoAdapter = class {
-  async encryptWithPublicKey(data, publicKeyHex) {
-    try {
-      const ecdh = new BrowserECDH();
-      return await ecdh.encrypt(publicKeyHex, data);
-    } catch (error) {
-      throw new Error(`Encryption failed: ${error}`);
-    }
-  }
-  async decryptWithPrivateKey(encryptedData, privateKeyHex) {
-    try {
-      const ecdh = new BrowserECDH();
-      return await ecdh.decrypt(privateKeyHex, encryptedData);
-    } catch (error) {
-      throw new Error(`Decryption failed: ${error}`);
-    }
-  }
-  async generateKeyPair() {
-    try {
-      const keyPair = await crypto.subtle.generateKey(
-        {
-          name: "ECDH",
-          namedCurve: "P-256"
-        },
-        true,
-        ["deriveKey", "deriveBits"]
-      );
-      const publicKeyBuffer = await crypto.subtle.exportKey(
-        "raw",
-        keyPair.publicKey
-      );
-      const privateKeyBuffer = await crypto.subtle.exportKey(
-        "pkcs8",
-        keyPair.privateKey
-      );
-      return {
-        publicKey: uint8ArrayToHex(new Uint8Array(publicKeyBuffer)),
-        privateKey: uint8ArrayToHex(new Uint8Array(privateKeyBuffer))
-      };
-    } catch (error) {
-      throw wrapCryptoError("key generation", error);
-    }
-  }
-  async encryptWithWalletPublicKey(data, publicKey) {
-    try {
-      const eccrypto = await import("eccrypto-js");
-      const uncompressedKey = processWalletPublicKey(publicKey);
-      const iv = Buffer.from([
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-        8,
-        9,
-        10,
-        11,
-        12,
-        13,
-        14,
-        15,
-        16
-      ]);
-      const ephemeralKey = Buffer.from([
-        17,
-        34,
-        51,
-        68,
-        85,
-        102,
-        119,
-        136,
-        153,
-        170,
-        187,
-        204,
-        221,
-        238,
-        255,
-        0,
-        16,
-        32,
-        48,
-        64,
-        80,
-        96,
-        112,
-        128,
-        144,
-        160,
-        176,
-        192,
-        208,
-        224,
-        240,
-        0
-      ]);
-      const encryptedBuffer = await eccrypto.encrypt(
-        uncompressedKey,
-        Buffer.from(data),
-        {
-          iv,
-          ephemPrivateKey: ephemeralKey
-        }
-      );
-      const result = Buffer.concat([
-        encryptedBuffer.iv,
-        encryptedBuffer.ephemPublicKey,
-        encryptedBuffer.ciphertext,
-        encryptedBuffer.mac
-      ]);
-      return result.toString("hex");
-    } catch (error) {
-      throw wrapCryptoError("encrypt with wallet public key", error);
-    }
-  }
-  async decryptWithWalletPrivateKey(encryptedData, privateKey) {
-    try {
-      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("decrypt with wallet private key", error);
-    }
-  }
-  async encryptWithPassword(data, password) {
-    try {
-      const openpgp2 = await import("openpgp");
-      const message = await openpgp2.createMessage({
-        binary: data
-      });
-      const encrypted = await openpgp2.encrypt({
-        message,
-        passwords: [password],
-        format: "binary"
-      });
-      const response = new Response(encrypted);
-      const arrayBuffer = await response.arrayBuffer();
-      return new Uint8Array(arrayBuffer);
-    } catch (error) {
-      throw new Error(`Failed to encrypt with password: ${error}`);
-    }
-  }
-  async decryptWithPassword(encryptedData, password) {
-    try {
-      const openpgp2 = await import("openpgp");
-      const message = await openpgp2.readMessage({
-        binaryMessage: encryptedData
-      });
-      const { data: decrypted } = await openpgp2.decrypt({
-        message,
-        passwords: [password],
-        format: "binary"
-      });
-      return new Uint8Array(decrypted);
-    } catch (error) {
-      throw new Error(`Failed to decrypt with password: ${error}`);
-    }
-  }
-};
-var BrowserPGPAdapter = class {
-  async encrypt(data, publicKeyArmored) {
-    try {
-      const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
-      const encrypted = await openpgp.encrypt({
-        message: await openpgp.createMessage({ text: data }),
-        encryptionKeys: publicKey,
-        config: {
-          preferredCompressionAlgorithm: openpgp.enums.compression.zlib
-        }
-      });
-      return encrypted;
-    } catch (error) {
-      throw new Error(`PGP encryption failed: ${error}`);
-    }
-  }
-  async decrypt(encryptedData, privateKeyArmored) {
-    try {
-      const privateKey = await openpgp.readPrivateKey({
-        armoredKey: privateKeyArmored
-      });
-      const message = await openpgp.readMessage({
-        armoredMessage: encryptedData
-      });
-      const { data: decrypted } = await openpgp.decrypt({
-        message,
-        decryptionKeys: privateKey
-      });
-      return decrypted;
-    } catch (error) {
-      throw new Error(`PGP decryption failed: ${error}`);
-    }
-  }
-  async generateKeyPair(options) {
-    try {
-      const keyGenParams = getPGPKeyGenParams(options);
-      const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
-      return { publicKey, privateKey };
-    } catch (error) {
-      throw wrapCryptoError("PGP key generation", error);
-    }
-  }
-};
-var 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);
-  }
-};
-var BrowserPlatformAdapter = class {
-  constructor() {
-    __publicField(this, "crypto");
-    __publicField(this, "pgp");
-    __publicField(this, "http");
-    __publicField(this, "platform", "browser");
-    this.crypto = new BrowserCryptoAdapter();
-    this.pgp = new BrowserPGPAdapter();
-    this.http = new BrowserHttpAdapter();
-  }
-};
-var browserPlatformAdapter = new BrowserPlatformAdapter();
+// src/index.browser.ts
+init_browser();
 
 // src/types/config.ts
 function isWalletConfig(config) {
@@ -40200,6 +40226,45 @@ var CircuitBreaker = class {
   }
 };
 
+// src/index.browser.ts
+init_browser();
+
+// src/platform/browser-only.ts
+init_browser();
+function createBrowserPlatformAdapter() {
+  return new BrowserPlatformAdapter();
+}
+function createPlatformAdapterSafe() {
+  return createBrowserPlatformAdapter();
+}
+
+// src/platform/utils.ts
+function detectPlatform() {
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    return "node";
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return "browser";
+  }
+  return "node";
+}
+function isPlatformSupported(platformType) {
+  const currentPlatform = detectPlatform();
+  return currentPlatform === platformType;
+}
+function getPlatformCapabilities() {
+  const platform = detectPlatform();
+  return {
+    platform,
+    crypto: {
+      webCrypto: typeof crypto !== "undefined" && crypto.subtle,
+      nodeCrypto: typeof process !== "undefined" && process.versions && process.versions.node
+    },
+    fetch: typeof fetch !== "undefined" || typeof globalThis.fetch !== "undefined",
+    streams: typeof ReadableStream !== "undefined"
+  };
+}
+
 // src/core/apiClient.ts
 var ApiClient = class {
   constructor(config = {}) {
@@ -40572,12 +40637,15 @@ export {
   convertIpfsUrl,
   convertIpfsUrlWithFallbacks,
   createAndStoreGrant,
+  createBrowserPlatformAdapter,
   createGrantFile,
+  createPlatformAdapterSafe,
   createValidatedGrant,
   decryptUserData,
   decryptWithPrivateKey,
   decryptWithWalletPrivateKey,
   index_browser_default as default,
+  detectPlatform,
   encryptFileKey,
   encryptUserData,
   encryptWithWalletPublicKey,
@@ -40600,11 +40668,13 @@ export {
   getGatewayUrls,
   getGrantFileHash,
   getGrantTimeRemaining,
+  getPlatformCapabilities,
   isAPIResponse,
   isGrantExpired,
   isIdentityServerOutput,
   isIpfsUrl,
   isPersonalServerOutput,
+  isPlatformSupported,
   isReplicateAPIResponse,
   moksha,
   mokshaTestnet,