@bandeira-tech/b3nd-web 0.2.1 → 0.2.3

package/dist/{chunk-Z3LAGZSM.js → chunk-S7NJA6B6.js}

@@ -16,6 +16,16 @@ var WalletClient = class {
       this.fetchImpl = fetch;
     }
   }
+  buildUrl(path) {
+    const normalized = path.startsWith("/") ? path : `/${path}`;
+    return `${this.walletServerUrl}${this.apiBasePath}${normalized}`;
+  }
+  buildAppKeyUrl(path, appKey) {
+    if (!appKey || typeof appKey !== "string") {
+      throw new Error("appKey is required");
+    }
+    return `${this.buildUrl(path)}/${appKey}`;
+  }
   /**
    * Get the current authenticated session
    */
@@ -82,12 +92,12 @@ var WalletClient = class {
    * Change password for current user
    * Requires active authentication session
    */
-  async changePassword(oldPassword, newPassword) {
+  async changePassword(appKey, oldPassword, newPassword) {
     if (!this.currentSession) {
       throw new Error("Not authenticated. Please login first.");
     }
     const response = await this.fetchImpl(
-      `${this.walletServerUrl}${this.apiBasePath}/auth/change-password`,
+      this.buildAppKeyUrl("/auth/credentials/change-password", appKey),
       {
         method: "POST",
         headers: {
@@ -110,24 +120,30 @@ var WalletClient = class {
    * Does not require authentication
    */
   async requestPasswordReset(_username) {
-    throw new Error("Use requestPasswordResetWithToken(token, username)");
+    throw new Error("Use requestPasswordResetWithToken(appKey, username)");
   }
   /**
    * Reset password using a reset token
    * Returns session data - call setSession() to activate it
    */
   async resetPassword(_username, _resetToken, _newPassword) {
-    throw new Error("Use resetPasswordWithToken(token, username, resetToken, newPassword)");
+    throw new Error("Use resetPasswordWithToken(appKey, username, resetToken, newPassword)");
   }
   /**
    * Sign up with app token (scoped to an app)
    */
-  async signupWithToken(token, credentials) {
-    if (!token) throw new Error("token is required");
-    const response = await this.fetchImpl(`${this.walletServerUrl}${this.apiBasePath}/auth/signup`, {
+  async signupWithToken(appKey, tokenOrCredentials, maybeCredentials) {
+    const credentials = typeof tokenOrCredentials === "string" ? maybeCredentials : tokenOrCredentials;
+    if (!credentials) throw new Error("credentials are required");
+    const response = await this.fetchImpl(this.buildAppKeyUrl("/auth/signup", appKey), {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ token, username: credentials.username, password: credentials.password })
+      body: JSON.stringify({
+        token: typeof tokenOrCredentials === "string" ? tokenOrCredentials : void 0,
+        type: "password",
+        username: credentials.username,
+        password: credentials.password
+      })
     });
     const data = await response.json();
     if (!response.ok || !data.success) {
@@ -138,13 +154,20 @@ var WalletClient = class {
   /**
    * Login with app token and session (scoped to an app)
    */
-  async loginWithTokenSession(token, session, credentials) {
-    if (!token) throw new Error("token is required");
-    if (!session) throw new Error("session is required");
-    const response = await this.fetchImpl(`${this.walletServerUrl}${this.apiBasePath}/auth/login`, {
+  async loginWithTokenSession(appKey, tokenOrSession, sessionOrCredentials, maybeCredentials) {
+    const session = typeof sessionOrCredentials === "string" && maybeCredentials ? sessionOrCredentials : tokenOrSession;
+    const credentials = maybeCredentials || sessionOrCredentials;
+    if (!session || typeof session !== "string") throw new Error("session is required");
+    const response = await this.fetchImpl(this.buildAppKeyUrl("/auth/login", appKey), {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ token, session, username: credentials.username, password: credentials.password })
+      body: JSON.stringify({
+        token: typeof tokenOrSession === "string" && maybeCredentials ? tokenOrSession : void 0,
+        session,
+        type: "password",
+        username: credentials.username,
+        password: credentials.password
+      })
     });
     const data = await response.json();
     if (!response.ok || !data.success) {
@@ -155,12 +178,12 @@ var WalletClient = class {
   /**
    * Request password reset scoped to app token
    */
-  async requestPasswordResetWithToken(token, username) {
-    if (!token) throw new Error("token is required");
-    const response = await this.fetchImpl(`${this.walletServerUrl}${this.apiBasePath}/auth/request-password-reset`, {
+  async requestPasswordResetWithToken(appKey, tokenOrUsername, maybeUsername) {
+    const username = maybeUsername || tokenOrUsername;
+    const response = await this.fetchImpl(this.buildAppKeyUrl("/auth/credentials/request-password-reset", appKey), {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ token, username })
+      body: JSON.stringify({ username })
     });
     const data = await response.json();
     if (!response.ok || !data.success) {
@@ -169,14 +192,17 @@ var WalletClient = class {
     return { resetToken: data.resetToken, expiresIn: data.expiresIn };
   }
   /**
-   * Reset password scoped to app token
+   * Reset password scoped to an app
    */
-  async resetPasswordWithToken(token, username, resetToken, newPassword) {
-    if (!token) throw new Error("token is required");
-    const response = await this.fetchImpl(`${this.walletServerUrl}${this.apiBasePath}/auth/reset-password`, {
+  async resetPasswordWithToken(appKey, _tokenOrUsername, usernameOrReset, resetToken, newPassword) {
+    const username = usernameOrReset;
+    if (!resetToken || !newPassword) {
+      throw new Error("resetToken and newPassword are required");
+    }
+    const response = await this.fetchImpl(this.buildAppKeyUrl("/auth/credentials/reset-password", appKey), {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ token, username, resetToken, newPassword })
+      body: JSON.stringify({ username, resetToken, newPassword })
     });
     const data = await response.json();
     if (!response.ok || !data.success) {
@@ -188,12 +214,15 @@ var WalletClient = class {
    * Get public keys for the current authenticated user.
    * Requires an active authentication session.
    */
-  async getPublicKeys() {
+  async getPublicKeys(appKey) {
     if (!this.currentSession) {
       throw new Error("Not authenticated. Please login first.");
     }
+    if (!appKey || typeof appKey !== "string") {
+      throw new Error("appKey is required");
+    }
     const response = await this.fetchImpl(
-      `${this.walletServerUrl}${this.apiBasePath}/public-keys`,
+      this.buildAppKeyUrl("/auth/public-keys", appKey),
       {
         headers: {
           Authorization: `Bearer ${this.currentSession.token}`
@@ -238,12 +267,37 @@ var WalletClient = class {
     }
     return data;
   }
+  /**
+   * Proxy a read request through the wallet server
+   * The server decrypts encrypted data using user's encryption key
+   * Requires active authentication session
+   */
+  async proxyRead(request) {
+    if (!this.currentSession) {
+      throw new Error("Not authenticated. Please login first.");
+    }
+    const url = new URL(`${this.walletServerUrl}${this.apiBasePath}/proxy/read`);
+    url.searchParams.set("uri", request.uri);
+    const response = await this.fetchImpl(url.toString(), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${this.currentSession.token}`
+      }
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(
+        data.error || `Proxy read failed: ${response.statusText}`
+      );
+    }
+    return data;
+  }
   /**
    * Convenience method: Get current user's public keys
    * Requires active authentication session
    */
-  async getMyPublicKeys() {
-    return this.getPublicKeys();
+  async getMyPublicKeys(appKey) {
+    return this.getPublicKeys(appKey);
   }
   /**
    * Get server's public keys
@@ -265,6 +319,66 @@ var WalletClient = class {
       encryptionPublicKeyHex: data.encryptionPublicKeyHex
     };
   }
+  /**
+   * Sign up with Google OAuth (scoped to app token)
+   * Returns session data with Google profile info - call setSession() to activate it
+   *
+   * @param token - App token from app server
+   * @param googleIdToken - Google ID token from Google Sign-In
+   * @returns GoogleAuthSession with username, JWT token, and Google profile info
+   */
+  async signupWithGoogle(appKey, token, googleIdToken) {
+    if (!token) throw new Error("token is required");
+    if (!googleIdToken) throw new Error("googleIdToken is required");
+    const response = await this.fetchImpl(this.buildAppKeyUrl("/auth/signup", appKey), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token, type: "google", googleIdToken })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Google signup failed: ${response.statusText}`);
+    }
+    return {
+      username: data.username,
+      token: data.token,
+      expiresIn: data.expiresIn,
+      email: data.email,
+      name: data.name,
+      picture: data.picture
+    };
+  }
+  /**
+   * Login with Google OAuth (scoped to app token and session)
+   * Returns session data with Google profile info - call setSession() to activate it
+   *
+   * @param token - App token from app server
+   * @param session - Session key from app server
+   * @param googleIdToken - Google ID token from Google Sign-In
+   * @returns GoogleAuthSession with username, JWT token, and Google profile info
+   */
+  async loginWithGoogle(appKey, token, session, googleIdToken) {
+    if (!token) throw new Error("token is required");
+    if (!session) throw new Error("session is required");
+    if (!googleIdToken) throw new Error("googleIdToken is required");
+    const response = await this.fetchImpl(this.buildAppKeyUrl("/auth/login", appKey), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token, session, type: "google", googleIdToken })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Google login failed: ${response.statusText}`);
+    }
+    return {
+      username: data.username,
+      token: data.token,
+      expiresIn: data.expiresIn,
+      email: data.email,
+      name: data.name,
+      picture: data.picture
+    };
+  }
 };
 
 export {

package/dist/{chunk-YJKJJ323.js → chunk-VAZUCGED.js}

@@ -5,7 +5,6 @@ var AppsClient = class {
     if (!cfg.apiBasePath) throw new Error("apiBasePath is required");
     this.base = cfg.appServerUrl.replace(/\/$/, "");
     this.api = (cfg.apiBasePath.startsWith("/") ? cfg.apiBasePath : `/${cfg.apiBasePath}`).replace(/\/$/, "");
-    if (cfg.authToken) this.authToken = cfg.authToken;
     if (cfg.fetch) {
       this.f = cfg.fetch;
     } else if (typeof window !== "undefined" && typeof window.fetch === "function") {
@@ -14,55 +13,62 @@ var AppsClient = class {
       this.f = fetch;
     }
   }
-  setAuthToken(token) {
-    this.authToken = token;
-  }
   async health() {
     const r = await this.f(`${this.base}${this.api}/health`);
     if (!r.ok) throw new Error(`health failed: ${r.statusText}`);
     return r.json();
   }
-  async registerApp(reg) {
-    const r = await this.f(`${this.base}${this.api}/apps/register`, {
+  async updateOrigins(appKey, message) {
+    const r = await this.f(`${this.base}${this.api}/apps/origins/${encodeURIComponent(appKey)}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
+    });
+    const j = await r.json();
+    if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
+    return j;
+  }
+  async updateGoogleClientId(appKey, message) {
+    const r = await this.f(`${this.base}${this.api}/apps/google-client-id/${encodeURIComponent(appKey)}`, {
       method: "POST",
-      headers: { "Content-Type": "application/json", ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {} },
-      body: JSON.stringify(reg)
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
     });
     const j = await r.json();
     if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
     return j;
   }
-  async updateSchema(appKey, actions) {
-    const r = await this.f(`${this.base}${this.api}/apps/${encodeURIComponent(appKey)}/schema`, {
+  async updateSchema(appKey, message) {
+    const r = await this.f(`${this.base}${this.api}/apps/schema/${encodeURIComponent(appKey)}`, {
       method: "POST",
-      headers: { "Content-Type": "application/json", ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {} },
-      body: JSON.stringify(actions)
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
     });
     const j = await r.json();
     if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
     return j;
   }
   async getSchema(appKey) {
-    const r = await this.f(`${this.base}${this.api}/apps/${encodeURIComponent(appKey)}/schema`, { headers: { ...this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {} } });
+    const r = await this.f(`${this.base}${this.api}/apps/schema/${encodeURIComponent(appKey)}`);
     const j = await r.json();
     if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
     return j;
   }
-  async createSession(appKey, token) {
+  async createSession(appKey, message) {
     const r = await this.f(`${this.base}${this.api}/app/${encodeURIComponent(appKey)}/session`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ token })
+      body: JSON.stringify(message)
     });
     const j = await r.json();
     if (!r.ok || !j.success) throw new Error(j.error || r.statusText);
     return j;
   }
-  async invokeAction(appKey, action, payload, origin) {
+  async invokeAction(appKey, action, signedMessage, origin) {
     const r = await this.f(`${this.base}${this.api}/app/${encodeURIComponent(appKey)}/${encodeURIComponent(action)}`, {
       method: "POST",
-      headers: { "Content-Type": "text/plain", ...origin ? { Origin: origin } : {} },
-      body: payload
+      headers: { "Content-Type": "application/json", ...origin ? { Origin: origin } : {} },
+      body: JSON.stringify(signedMessage)
     });
     const j = await r.json();
     if (!r.ok || !j.success) throw new Error(j.error || r.statusText);

package/dist/encrypt/mod.d.ts

@@ -1 +1 @@
-export { A as AuthenticatedMessage, a as EncryptedPayload, E as EncryptionKeyPair, K as KeyPair, S as SignedEncryptedMessage, h as createAuthenticatedMessage, i as createSignedEncryptedMessage, d as decrypt, f as decryptWithHex, e as encrypt, b as generateEncryptionKeyPair, k as generateNonce, l as generateRandomData, g as generateSigningKeyPair, s as sign, c as signWithHex, v as verify, j as verifyAndDecrypt } from '../mod-DHjjiF1o.js';
+export { A as AuthenticatedMessage, a as EncryptedPayload, E as EncryptionKeyPair, I as IdentityKey, K as KeyPair, d as PrivateEncryptionKey, P as PublicEncryptionKey, c as SecretEncryptionKey, S as SignedEncryptedMessage, b as SignedSymmetricMessage, k as createAuthenticatedMessage, l as createAuthenticatedMessageWithHex, w as createSignedEncryptedMessage, B as createSignedSymmetricMessage, i as decrypt, z as decryptSymmetric, j as decryptWithHex, n as deriveKeyFromSeed, h as encrypt, y as encryptSymmetric, r as exportPrivateKeyPem, e as generateEncryptionKeyPair, o as generateNonce, q as generateRandomData, g as generateSigningKeyPair, p as pemToCryptoKey, s as sign, t as signPayload, f as signWithHex, v as verify, x as verifyAndDecryptMessage, u as verifyPayload } from '../mod-D02790g_.js';

package/dist/encrypt/mod.js

@@ -1,31 +1,57 @@
 import {
+  IdentityKey,
+  PrivateEncryptionKey,
+  PublicEncryptionKey,
+  SecretEncryptionKey,
   createAuthenticatedMessage,
+  createAuthenticatedMessageWithHex,
   createSignedEncryptedMessage,
+  createSignedSymmetricMessage,
   decrypt,
+  decryptSymmetric,
   decryptWithHex,
+  deriveKeyFromSeed,
   encrypt,
+  encryptSymmetric,
+  exportPrivateKeyPem,
   generateEncryptionKeyPair,
   generateNonce,
   generateRandomData,
   generateSigningKeyPair,
+  pemToCryptoKey,
   sign,
+  signPayload,
   signWithHex,
   verify,
-  verifyAndDecrypt
-} from "../chunk-FUMSJI3N.js";
+  verifyAndDecryptMessage,
+  verifyPayload
+} from "../chunk-K3ZSSVHR.js";
 import "../chunk-MLKGABMK.js";
 export {
+  IdentityKey,
+  PrivateEncryptionKey,
+  PublicEncryptionKey,
+  SecretEncryptionKey,
   createAuthenticatedMessage,
+  createAuthenticatedMessageWithHex,
   createSignedEncryptedMessage,
+  createSignedSymmetricMessage,
   decrypt,
+  decryptSymmetric,
   decryptWithHex,
+  deriveKeyFromSeed,
   encrypt,
+  encryptSymmetric,
+  exportPrivateKeyPem,
   generateEncryptionKeyPair,
   generateNonce,
   generateRandomData,
   generateSigningKeyPair,
+  pemToCryptoKey,
   sign,
+  signPayload,
   signWithHex,
   verify,
-  verifyAndDecrypt
+  verifyAndDecryptMessage,
+  verifyPayload
 };

package/dist/mod-D02790g_.d.ts

@@ -0,0 +1,241 @@
+interface KeyPair {
+    publicKey: CryptoKey;
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+    privateKeyHex: string;
+}
+interface EncryptionKeyPair {
+    publicKey: CryptoKey;
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+}
+interface EncryptedPayload {
+    data: string;
+    nonce: string;
+    ephemeralPublicKey?: string;
+}
+interface AuthenticatedMessage<T = unknown> {
+    auth: Array<{
+        pubkey: string;
+        signature: string;
+    }>;
+    payload: T;
+}
+interface SignedEncryptedMessage {
+    auth: Array<{
+        pubkey: string;
+        signature: string;
+    }>;
+    payload: EncryptedPayload;
+}
+interface SignedSymmetricMessage {
+    auth: Array<{
+        pubkey: string;
+        signature: string;
+    }>;
+    payload: EncryptedPayload;
+}
+declare class IdentityKey {
+    private readonly privateKey;
+    readonly publicKeyHex: string;
+    private constructor();
+    static generate(): Promise<{
+        key: IdentityKey;
+        privateKeyPem: string;
+        publicKeyHex: string;
+    }>;
+    static fromPem(pem: string, publicKeyHex: string): Promise<IdentityKey>;
+    static fromHex(params: {
+        privateKeyHex: string;
+        publicKeyHex: string;
+    }): Promise<IdentityKey>;
+    sign(payload: unknown): Promise<string>;
+}
+declare class PublicEncryptionKey {
+    readonly publicKeyHex: string;
+    readonly publicKey: CryptoKey | null;
+    constructor(publicKeyHex: string, publicKey: CryptoKey | null);
+    static fromHex(publicKeyHex: string): Promise<PublicEncryptionKey>;
+    static generatePair(): Promise<{
+        publicKey: PublicEncryptionKey;
+        privateKeyHex: string;
+    }>;
+    encrypt(data: unknown): Promise<EncryptedPayload>;
+    toHex(): string;
+}
+declare class SecretEncryptionKey {
+    readonly keyHex: string;
+    private constructor();
+    static fromSecret(params: {
+        secret: string;
+        salt: string;
+        iterations?: number;
+    }): Promise<SecretEncryptionKey>;
+    static fromHex(keyHex: string): SecretEncryptionKey;
+    encrypt(data: unknown): Promise<EncryptedPayload>;
+    decrypt(payload: EncryptedPayload): Promise<unknown>;
+}
+declare class PrivateEncryptionKey {
+    readonly privateKey: CryptoKey;
+    readonly privateKeyHex: string;
+    readonly publicKeyHex: string;
+    constructor(privateKey: CryptoKey, privateKeyHex: string, publicKeyHex: string);
+    static fromHex(params: {
+        privateKeyHex: string;
+        publicKeyHex: string;
+    }): Promise<PrivateEncryptionKey>;
+    static generatePair(): Promise<{
+        privateKey: PrivateEncryptionKey;
+        publicKey: PublicEncryptionKey;
+    }>;
+    toPublic(): PublicEncryptionKey;
+    decrypt(payload: EncryptedPayload): Promise<unknown>;
+    toHex(): string;
+}
+/**
+ * Convert a PEM-encoded private key to a CryptoKey
+ */
+declare function pemToCryptoKey(pem: string, algorithm: "Ed25519" | "X25519"): Promise<CryptoKey>;
+/**
+ * Generate an Ed25519 keypair for signing
+ */
+declare function generateSigningKeyPair(): Promise<KeyPair>;
+/**
+ * Generate an X25519 keypair for encryption (ECDH)
+ */
+declare function generateEncryptionKeyPair(): Promise<EncryptionKeyPair>;
+/**
+ * Sign a payload with an Ed25519 private key
+ */
+declare function sign<T>(privateKey: CryptoKey, payload: T): Promise<string>;
+/**
+ * Sign a payload with an Ed25519 private key from hex
+ */
+declare function signWithHex<T>(privateKeyHex: string, payload: T): Promise<string>;
+/**
+ * Verify a signature using Ed25519 public key
+ */
+declare function verify<T>(publicKeyHex: string, signatureHex: string, payload: T): Promise<boolean>;
+/**
+ * Encrypt data using X25519 ECDH + AES-GCM
+ * Uses ephemeral keypair for forward secrecy
+ */
+declare function encrypt(data: unknown, recipientPublicKeyHex: string): Promise<EncryptedPayload>;
+/**
+ * Decrypt data using X25519 ECDH + AES-GCM
+ */
+declare function decrypt(encryptedPayload: EncryptedPayload, recipientPrivateKey: CryptoKey): Promise<unknown>;
+/**
+ * Decrypt data using private key from hex
+ */
+declare function decryptWithHex(encryptedPayload: EncryptedPayload, recipientPrivateKeyHex: string): Promise<unknown>;
+/**
+ * Create an authenticated message (signed but not encrypted)
+ */
+declare function createAuthenticatedMessage<T>(payload: T, signers: Array<{
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+}>): Promise<AuthenticatedMessage<T>>;
+/**
+ * Create an authenticated message with hex-encoded keys (convenience wrapper)
+ */
+declare function createAuthenticatedMessageWithHex<T>(payload: T, pubkeyHex: string, privateKeyHex: string): Promise<AuthenticatedMessage<T>>;
+/**
+ * Derive an encryption key from seed and salt using PBKDF2
+ * Returns hex-encoded key suitable for encrypt/decrypt functions
+ */
+declare function deriveKeyFromSeed(seed: string, salt: string, iterations?: number): Promise<string>;
+declare function generateNonce(length?: number): Uint8Array;
+declare function generateRandomData(size: number): Uint8Array;
+declare function exportPrivateKeyPem(privateKey: CryptoKey, label: string): Promise<string>;
+declare function signPayload(params: {
+    payload: unknown;
+    identity: IdentityKey;
+}): Promise<Array<{
+    pubkey: string;
+    signature: string;
+}>>;
+declare function verifyPayload(params: {
+    payload: unknown;
+    auth: Array<{
+        pubkey: string;
+        signature: string;
+    }>;
+}): Promise<{
+    verified: boolean;
+    signers: string[];
+}>;
+declare function createSignedEncryptedMessage(params: {
+    data: unknown;
+    identity: IdentityKey;
+    encryptionKey: SecretEncryptionKey | PublicEncryptionKey;
+}): Promise<SignedEncryptedMessage>;
+declare function createSignedEncryptedMessage(data: unknown, signers: Array<{
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+}>, recipientPublicKeyHex: string): Promise<SignedEncryptedMessage>;
+declare function verifyAndDecryptMessage(params: {
+    message: SignedEncryptedMessage;
+    encryptionKey: SecretEncryptionKey | PrivateEncryptionKey;
+}): Promise<{
+    data: unknown;
+    verified: boolean;
+    signers: string[];
+}>;
+/**
+ * Encrypt data using a symmetric key (AES-GCM) provided as hex
+ */
+declare function encryptSymmetric(data: unknown, keyHex: string): Promise<EncryptedPayload>;
+/**
+ * Decrypt data using a symmetric key (AES-GCM) provided as hex
+ */
+declare function decryptSymmetric(payload: EncryptedPayload, keyHex: string): Promise<unknown>;
+/**
+ * Create a signed symmetric message (signs encrypted payload)
+ */
+declare function createSignedSymmetricMessage(data: unknown, signers: Array<{
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+}>, keyHex: string): Promise<SignedSymmetricMessage>;
+
+type mod_AuthenticatedMessage<T = unknown> = AuthenticatedMessage<T>;
+type mod_EncryptedPayload = EncryptedPayload;
+type mod_EncryptionKeyPair = EncryptionKeyPair;
+type mod_IdentityKey = IdentityKey;
+declare const mod_IdentityKey: typeof IdentityKey;
+type mod_KeyPair = KeyPair;
+type mod_PrivateEncryptionKey = PrivateEncryptionKey;
+declare const mod_PrivateEncryptionKey: typeof PrivateEncryptionKey;
+type mod_PublicEncryptionKey = PublicEncryptionKey;
+declare const mod_PublicEncryptionKey: typeof PublicEncryptionKey;
+type mod_SecretEncryptionKey = SecretEncryptionKey;
+declare const mod_SecretEncryptionKey: typeof SecretEncryptionKey;
+type mod_SignedEncryptedMessage = SignedEncryptedMessage;
+type mod_SignedSymmetricMessage = SignedSymmetricMessage;
+declare const mod_createAuthenticatedMessage: typeof createAuthenticatedMessage;
+declare const mod_createAuthenticatedMessageWithHex: typeof createAuthenticatedMessageWithHex;
+declare const mod_createSignedEncryptedMessage: typeof createSignedEncryptedMessage;
+declare const mod_createSignedSymmetricMessage: typeof createSignedSymmetricMessage;
+declare const mod_decrypt: typeof decrypt;
+declare const mod_decryptSymmetric: typeof decryptSymmetric;
+declare const mod_decryptWithHex: typeof decryptWithHex;
+declare const mod_deriveKeyFromSeed: typeof deriveKeyFromSeed;
+declare const mod_encrypt: typeof encrypt;
+declare const mod_encryptSymmetric: typeof encryptSymmetric;
+declare const mod_exportPrivateKeyPem: typeof exportPrivateKeyPem;
+declare const mod_generateEncryptionKeyPair: typeof generateEncryptionKeyPair;
+declare const mod_generateNonce: typeof generateNonce;
+declare const mod_generateRandomData: typeof generateRandomData;
+declare const mod_generateSigningKeyPair: typeof generateSigningKeyPair;
+declare const mod_pemToCryptoKey: typeof pemToCryptoKey;
+declare const mod_sign: typeof sign;
+declare const mod_signPayload: typeof signPayload;
+declare const mod_signWithHex: typeof signWithHex;
+declare const mod_verify: typeof verify;
+declare const mod_verifyAndDecryptMessage: typeof verifyAndDecryptMessage;
+declare const mod_verifyPayload: typeof verifyPayload;
+declare namespace mod {
+  export { type mod_AuthenticatedMessage as AuthenticatedMessage, type mod_EncryptedPayload as EncryptedPayload, type mod_EncryptionKeyPair as EncryptionKeyPair, mod_IdentityKey as IdentityKey, type mod_KeyPair as KeyPair, mod_PrivateEncryptionKey as PrivateEncryptionKey, mod_PublicEncryptionKey as PublicEncryptionKey, mod_SecretEncryptionKey as SecretEncryptionKey, type mod_SignedEncryptedMessage as SignedEncryptedMessage, type mod_SignedSymmetricMessage as SignedSymmetricMessage, mod_createAuthenticatedMessage as createAuthenticatedMessage, mod_createAuthenticatedMessageWithHex as createAuthenticatedMessageWithHex, mod_createSignedEncryptedMessage as createSignedEncryptedMessage, mod_createSignedSymmetricMessage as createSignedSymmetricMessage, mod_decrypt as decrypt, mod_decryptSymmetric as decryptSymmetric, mod_decryptWithHex as decryptWithHex, mod_deriveKeyFromSeed as deriveKeyFromSeed, mod_encrypt as encrypt, mod_encryptSymmetric as encryptSymmetric, mod_exportPrivateKeyPem as exportPrivateKeyPem, mod_generateEncryptionKeyPair as generateEncryptionKeyPair, mod_generateNonce as generateNonce, mod_generateRandomData as generateRandomData, mod_generateSigningKeyPair as generateSigningKeyPair, mod_pemToCryptoKey as pemToCryptoKey, mod_sign as sign, mod_signPayload as signPayload, mod_signWithHex as signWithHex, mod_verify as verify, mod_verifyAndDecryptMessage as verifyAndDecryptMessage, mod_verifyPayload as verifyPayload };
+}
+
+export { type AuthenticatedMessage as A, createSignedSymmetricMessage as B, type EncryptionKeyPair as E, IdentityKey as I, type KeyPair as K, PublicEncryptionKey as P, type SignedEncryptedMessage as S, type EncryptedPayload as a, type SignedSymmetricMessage as b, SecretEncryptionKey as c, PrivateEncryptionKey as d, generateEncryptionKeyPair as e, signWithHex as f, generateSigningKeyPair as g, encrypt as h, decrypt as i, decryptWithHex as j, createAuthenticatedMessage as k, createAuthenticatedMessageWithHex as l, mod as m, deriveKeyFromSeed as n, generateNonce as o, pemToCryptoKey as p, generateRandomData as q, exportPrivateKeyPem as r, sign as s, signPayload as t, verifyPayload as u, verify as v, createSignedEncryptedMessage as w, verifyAndDecryptMessage as x, encryptSymmetric as y, decryptSymmetric as z };

package/dist/src/mod.web.d.ts

@@ -4,4 +4,4 @@ export { WebSocketClient } from '../clients/websocket/mod.js';
 export { LocalStorageClient } from '../clients/local-storage/mod.js';
 export { WalletClient } from '../wallet/mod.js';
 export { AppsClient } from '../apps/mod.js';
-export { m as encrypt } from '../mod-DHjjiF1o.js';
+export { m as encrypt } from '../mod-D02790g_.js';