@enbox/browser 0.3.39 → 0.3.40

package/src/dweb-connect-messages.ts

@@ -0,0 +1,91 @@
+/**
+ * Wire shapes for the DWeb Connect popup/postMessage channel.
+ *
+ * The dapp and the wallet exchange exactly three message kinds over
+ * `window.postMessage`:
+ *
+ * 1. `loaded` beacon (wallet → dapp): announces the wallet page is ready and
+ *    carries a fresh ephemeral X25519 public key plus the wallet's origin.
+ * 2. `request` (dapp → wallet): the sealed connect request JWE — ciphertext
+ *    only, encrypted to the beacon key with ECDH-ES and the wallet origin
+ *    bound into the JWE `apv` header.
+ * 3. `response` (wallet → dapp): the sealed connect response JWE, or the
+ *    literal deny token — again ciphertext only.
+ *
+ * Plaintext never crosses the channel, and both sides pin `targetOrigin`
+ * and verify `event.origin` / `event.source` on every message.
+ *
+ * @module
+ */
+
+import type { Jwk } from '@enbox/crypto';
+
+/** Path of the wallet's DWeb Connect page, opened as a popup by the dapp. */
+export const DWEB_CONNECT_PATH = '/dweb-connect';
+
+/** Message type of the wallet's `loaded` beacon (wallet → dapp). */
+export const DWEB_CONNECT_LOADED_MESSAGE_TYPE = 'enbox-connect-loaded';
+
+/** Message type carrying the sealed connect request JWE (dapp → wallet). */
+export const DWEB_CONNECT_REQUEST_MESSAGE_TYPE = 'enbox-connect-request';
+
+/** Message type carrying the sealed connect response JWE or deny token (wallet → dapp). */
+export const DWEB_CONNECT_RESPONSE_MESSAGE_TYPE = 'enbox-connect-response';
+
+/**
+ * The wallet's readiness beacon. Emitted to `window.opener` once the wallet's
+ * DWeb Connect page has generated its per-session ephemeral X25519 key.
+ */
+export type DWebConnectLoadedMessage = {
+  type: typeof DWEB_CONNECT_LOADED_MESSAGE_TYPE;
+
+  /** Fresh ephemeral X25519 public JWK the dapp seals the request to. */
+  walletEpk: Jwk;
+
+  /** The wallet's own origin; must match the origin the dapp has pinned. */
+  walletOrigin: string;
+};
+
+/** The dapp's sealed connect request, posted to the wallet popup. */
+export type DWebConnectRequestMessage = {
+  type: typeof DWEB_CONNECT_REQUEST_MESSAGE_TYPE;
+
+  /** The sealed connect request as a Compact JWE string. */
+  jwe: string;
+};
+
+/** The wallet's sealed connect response, posted back to the opener. */
+export type DWebConnectResponseMessage = {
+  type: typeof DWEB_CONNECT_RESPONSE_MESSAGE_TYPE;
+
+  /** The sealed connect response JWE, or the literal `CONNECT_DENIED_TOKEN`. */
+  payload: string;
+};
+
+/**
+ * Applies the shared inbound-message trust filter for the popup channel:
+ * pins the message to the expected `event.origin`, pins its `event.source` to
+ * the expected window, and requires a non-null object payload.
+ *
+ * Returns the payload cast to a plain record when every check passes, or
+ * `undefined` when the message must be dropped. Both the dapp-side and
+ * wallet-side transports early-return on `undefined` before inspecting any
+ * message field — this is the security-critical filter that keeps hostile
+ * origins and stray windows off the channel.
+ */
+export function getTrustedMessage(
+  event: MessageEvent,
+  expectedOrigin: string,
+  expectedSource: Window | undefined,
+): Record<string, unknown> | undefined {
+  // Origin pinning: only messages from the expected origin count.
+  if (event.origin !== expectedOrigin) { return undefined; }
+
+  // Source pinning: the message must come from the expected window.
+  if (event.source !== expectedSource) { return undefined; }
+
+  const data: unknown = event.data;
+  if (typeof data !== 'object' || data === null) { return undefined; }
+
+  return data as Record<string, unknown>;
+}

package/src/dweb-connect-wallet.ts

@@ -0,0 +1,258 @@
+/**
+ * DWeb Connect wallet transport — the wallet side of the popup/postMessage
+ * connect flow, exported for wallet apps (e.g. the Enbox web wallet).
+ *
+ * A wallet's `/dweb-connect` page creates one transport per session:
+ *
+ * 1. `create()` generates a fresh ephemeral X25519 key pair and emits the
+ *    `loaded` beacon (public key + wallet origin) to the opener window with a
+ *    pinned `targetOrigin`.
+ * 2. `awaitRequest()` receives the sealed request ciphertext and opens it via
+ *    the `@enbox/connect` kernel (`ConnectProvider.openRequest`), which
+ *    value-checks the `apv` origin binding against this wallet's origin.
+ * 3. After the consent ceremony, the wallet posts the sealed response JWE via
+ *    `sendResponse()` — or the deny token via `deny()` — back to the opener,
+ *    again with a pinned `targetOrigin`.
+ *
+ * The dapp origin is never assumed: it is taken from an explicit option or
+ * derived from `document.referrer`, and `create()` fails when neither is
+ * available. `'*'` is never used as a `targetOrigin`.
+ *
+ * @module
+ */
+
+import type { ConnectRequest } from '@enbox/connect';
+import type { Jwk } from '@enbox/crypto';
+
+import { X25519 } from '@enbox/crypto';
+import { CONNECT_DENIED_TOKEN, ConnectProvider } from '@enbox/connect';
+
+import {
+  DWEB_CONNECT_LOADED_MESSAGE_TYPE,
+  DWEB_CONNECT_REQUEST_MESSAGE_TYPE,
+  DWEB_CONNECT_RESPONSE_MESSAGE_TYPE,
+  getTrustedMessage,
+} from './dweb-connect-messages.js';
+
+/** Default budget for awaiting the dapp's sealed request. */
+const DEFAULT_REQUEST_TIMEOUT_MS = 300_000;
+
+/** Options for creating a {@link WalletPostMessageTransport}. */
+export type WalletPostMessageTransportOptions = {
+  /**
+   * Origin of the dapp that opened this wallet popup. When omitted, it is
+   * derived from `document.referrer`; creation fails when neither is
+   * available — the transport never falls back to `'*'`.
+   */
+  dappOrigin?: string;
+
+  /**
+   * The dapp window to exchange messages with.
+   * @default window.opener
+   */
+  dappWindow?: Window;
+
+  /**
+   * Budget in milliseconds for awaiting the dapp's sealed request.
+   * @default 300_000 (5 minutes)
+   */
+  timeoutMs?: number;
+};
+
+/**
+ * Wallet-side postMessage transport for the DWeb Connect popup flow.
+ *
+ * Security properties:
+ * - `targetOrigin` of every outbound `postMessage` (beacon and response) is
+ *   pinned to the dapp origin — never `'*'`.
+ * - Inbound messages are dropped unless `event.origin` equals the pinned dapp
+ *   origin AND `event.source` is the dapp window.
+ * - The ephemeral X25519 private key never leaves the transport; the request
+ *   JWE is opened by the kernel with the `apv` header value-checked against
+ *   this wallet's own origin.
+ */
+export class WalletPostMessageTransport {
+  private readonly _dappOrigin: string;
+  private readonly _dappWindow: Window;
+  private readonly _recipientPrivateKey: Jwk;
+
+  private _requestReceived = false;
+  private _timeoutId?: ReturnType<typeof setTimeout>;
+  private _messageListener?: (event: MessageEvent) => void;
+
+  private readonly _requestPromise: Promise<ConnectRequest>;
+  private _resolveRequest?: (request: ConnectRequest) => void;
+  private _rejectRequest?: (error: Error) => void;
+
+  private constructor(params: { dappOrigin: string; dappWindow: Window; recipientPrivateKey: Jwk; timeoutMs: number }) {
+    this._dappOrigin = params.dappOrigin;
+    this._dappWindow = params.dappWindow;
+    this._recipientPrivateKey = params.recipientPrivateKey;
+
+    this._requestPromise = new Promise<ConnectRequest>((resolve, reject): void => {
+      this._resolveRequest = resolve;
+      this._rejectRequest = reject;
+    });
+    // Mark early rejections (timeout before `awaitRequest()` is called) as
+    // handled until the wallet attaches its own handlers.
+    this._requestPromise.catch((): undefined => undefined);
+
+    this._messageListener = (event: MessageEvent): void => { this.onMessage(event); };
+    window.addEventListener('message', this._messageListener);
+
+    this._timeoutId = setTimeout((): void => {
+      this.close();
+      this._rejectRequest?.(new Error('[@enbox/browser] Timed out waiting for the connect request from the dapp.'));
+    }, params.timeoutMs);
+  }
+
+  /**
+   * Creates the transport for one connect session: resolves and pins the dapp
+   * origin, generates a fresh ephemeral X25519 key pair, starts listening for
+   * the sealed request, and emits the `loaded` beacon to the dapp window.
+   *
+   * @throws If not in a browser, if no dapp window is available, or if the
+   *         dapp origin can neither be supplied nor derived from the referrer.
+   */
+  public static async create(options: WalletPostMessageTransportOptions = {}): Promise<WalletPostMessageTransport> {
+    if (typeof window === 'undefined') {
+      throw new Error('[@enbox/browser] WalletPostMessageTransport is only available in browser environments.');
+    }
+
+    const dappWindow = options.dappWindow ?? window.opener as Window | null;
+    if (!dappWindow) {
+      throw new Error('[@enbox/browser] No opener window: the DWeb Connect page must be opened as a popup by the dapp.');
+    }
+
+    const dappOrigin = resolveDappOrigin(options.dappOrigin);
+
+    const recipientPrivateKey = await X25519.generateKey();
+    const walletEpk: Jwk = { kty: 'OKP', crv: 'X25519', x: recipientPrivateKey.x };
+
+    const transport = new WalletPostMessageTransport({
+      dappOrigin,
+      dappWindow,
+      recipientPrivateKey,
+      timeoutMs: options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+    });
+
+    // The listener is registered, so the beacon cannot race the request.
+    dappWindow.postMessage({
+      type         : DWEB_CONNECT_LOADED_MESSAGE_TYPE,
+      walletEpk,
+      walletOrigin : globalThis.location.origin,
+    }, dappOrigin);
+
+    return transport;
+  }
+
+  /** The pinned origin of the dapp this transport exchanges messages with. */
+  public get dappOrigin(): string {
+    return this._dappOrigin;
+  }
+
+  /**
+   * Awaits the dapp's sealed request and opens it via the kernel: ECDH-ES
+   * decryption with this session's ephemeral key, `apv` value-checked against
+   * this wallet's origin, JWT signature verification, and payload shape
+   * assertion. Rejects on timeout, on an unopenable request, or when the
+   * request does not use the `post_message` reply mode.
+   */
+  public async awaitRequest(): Promise<ConnectRequest> {
+    return await this._requestPromise;
+  }
+
+  /**
+   * Posts the sealed response JWE (or the deny token) back to the dapp window
+   * with the `targetOrigin` pinned to the dapp origin, then closes the
+   * transport.
+   *
+   * @param idToken - The sealed response JWE, or the literal deny token.
+   */
+  public sendResponse(idToken: string): void {
+    this._dappWindow.postMessage({
+      type    : DWEB_CONNECT_RESPONSE_MESSAGE_TYPE,
+      payload : idToken,
+    }, this._dappOrigin);
+    this.close();
+  }
+
+  /** Posts the deny token back to the dapp — the user rejected the request. */
+  public deny(): void {
+    this.sendResponse(CONNECT_DENIED_TOKEN);
+  }
+
+  /** Stops listening and releases the session's timers. Idempotent. */
+  public close(): void {
+    clearTimeout(this._timeoutId);
+    if (this._messageListener !== undefined) {
+      window.removeEventListener('message', this._messageListener);
+      this._messageListener = undefined;
+    }
+  }
+
+  private onMessage(event: MessageEvent): void {
+    const message = getTrustedMessage(event, this._dappOrigin, this._dappWindow);
+    if (message === undefined) { return; }
+
+    if (message.type !== DWEB_CONNECT_REQUEST_MESSAGE_TYPE || this._requestReceived) { return; }
+    this._requestReceived = true;
+
+    if (typeof message.jwe !== 'string') {
+      this.settleRequest(new Error('[@enbox/browser] Connect request message did not carry a ciphertext payload.'));
+      return;
+    }
+
+    void this.openRequest(message.jwe);
+  }
+
+  private async openRequest(jwe: string): Promise<void> {
+    try {
+      const request = await ConnectProvider.openRequest({
+        jwe,
+        decryption: {
+          mode                : 'ecdh-es',
+          recipientPrivateKey : this._recipientPrivateKey,
+          walletOrigin        : globalThis.location.origin,
+        },
+      });
+
+      if (request.reply.mode !== 'post_message') {
+        this.settleRequest(new Error('[@enbox/browser] Connect request over the popup channel must use the `post_message` reply mode.'));
+        return;
+      }
+
+      this.settleRequest(request);
+    } catch (error) {
+      this.settleRequest(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  private settleRequest(outcome: ConnectRequest | Error): void {
+    clearTimeout(this._timeoutId);
+    if (outcome instanceof Error) {
+      this.close();
+      this._rejectRequest?.(outcome);
+      return;
+    }
+    this._resolveRequest?.(outcome);
+  }
+}
+
+/**
+ * Resolves the dapp origin to pin: the explicit option when provided,
+ * otherwise the origin of `document.referrer`. Never falls back to `'*'`.
+ */
+function resolveDappOrigin(explicitOrigin: string | undefined): string {
+  if (explicitOrigin !== undefined) {
+    return new URL(explicitOrigin).origin;
+  }
+
+  if (document.referrer) {
+    return new URL(document.referrer).origin;
+  }
+
+  throw new Error(
+    '[@enbox/browser] Unable to determine the dapp origin: no `dappOrigin` option was provided and `document.referrer` is empty.'
+  );
+}

package/src/index.ts

@@ -74,15 +74,34 @@ export type {
   WalletConnectOptions,
 } from '@enbox/auth/browser';
 
+// ─── Re-exports from @enbox/connect ─────────────────────────────
+//
+// The connect kernel pieces wallet apps need alongside the popup
+// transports: opening/sealing envelopes and the deny token.
+
+export { CONNECT_DENIED_TOKEN, ConnectProvider } from '@enbox/connect';
+export type { ConnectApproval, ConnectPermissionRequest, ConnectRequest } from '@enbox/connect';
+
 // ─── Browser-specific exports ───────────────────────────────────
 //
-// DWeb Connect, wallet selector, DRL polyfills.
+// DWeb Connect popup transports, wallet selector, DRL polyfills.
 
 export * from './web-features.js';
 export { BrowserConnectHandler, DEFAULT_WALLETS } from './browser-connect-handler.js';
 export type { BrowserConnectHandlerOptions, WalletOption } from './browser-connect-handler.js';
-export { DWebConnect } from './dweb-connect-client.js';
-export type { DWebConnectClientOptions } from './dweb-connect-client.js';
+export { connectViaPopup, PopupClientTransport, PopupWindowClosedError } from './dweb-connect-client.js';
+export type { PopupClientTransportOptions, PopupConnectOptions } from './dweb-connect-client.js';
+export { WalletPostMessageTransport } from './dweb-connect-wallet.js';
+export type { WalletPostMessageTransportOptions } from './dweb-connect-wallet.js';
+export {
+  DWEB_CONNECT_LOADED_MESSAGE_TYPE,
+  DWEB_CONNECT_PATH,
+  DWEB_CONNECT_REQUEST_MESSAGE_TYPE,
+  DWEB_CONNECT_RESPONSE_MESSAGE_TYPE,
+} from './dweb-connect-messages.js';
+export type {
+  DWebConnectLoadedMessage,
+  DWebConnectRequestMessage,
+  DWebConnectResponseMessage,
+} from './dweb-connect-messages.js';
 export { showWalletSelector } from './ui/wallet-selector.js';
-export { encryptPostMessagePayload, generateEphemeralKeyPair } from './dweb-connect-crypto.js';
-export type { EncryptedPostMessagePayload } from './dweb-connect-crypto.js';

package/dist/esm/dweb-connect-crypto.js

@@ -1,112 +0,0 @@
-/**
- * ECDH + AES-256-GCM encryption for the DWeb Connect postMessage channel.
- *
- * Protects the authorization response (delegate private keys, decryption
- * keys, grants) from same-origin XSS interception. Both the dapp and
- * wallet generate ephemeral P-256 keypairs, exchange public keys during
- * the handshake, derive a shared AES-256-GCM key via ECDH + HKDF, and
- * encrypt/decrypt the payload.
- *
- * P-256 is used (instead of X25519) because `crypto.subtle.deriveKey`
- * with ECDH requires a NIST curve in all major browsers. The keys are
- * ephemeral — generated fresh for each connect session.
- *
- * @module
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-const ECDH_PARAMS = { name: 'ECDH', namedCurve: 'P-256' };
-const AES_KEY_PARAMS = { name: 'AES-GCM', length: 256 };
-const HKDF_INFO = new TextEncoder().encode('dweb-connect-v1');
-/**
- * Generate an ephemeral P-256 ECDH keypair for a single connect session.
- *
- * @returns The keypair and the public key as a base64url-encoded raw export.
- */
-export function generateEphemeralKeyPair() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const keyPair = yield crypto.subtle.generateKey(ECDH_PARAMS, false, ['deriveBits']);
-        const rawPub = yield crypto.subtle.exportKey('raw', keyPair.publicKey);
-        return { keyPair, publicKeyBase64url: toBase64url(new Uint8Array(rawPub)) };
-    });
-}
-/**
- * Derive a shared AES-256-GCM key from a local ECDH private key and a
- * remote public key.
- */
-function deriveSharedKey(localPrivateKey, remotePublicKeyBase64url) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const remotePubRaw = fromBase64url(remotePublicKeyBase64url);
-        const remotePublicKey = yield crypto.subtle.importKey('raw', remotePubRaw, ECDH_PARAMS, false, []);
-        // ECDH → raw shared secret, then HKDF → AES-256-GCM key.
-        const sharedBits = yield crypto.subtle.deriveBits({ name: 'ECDH', public: remotePublicKey }, localPrivateKey, 256);
-        const hkdfKey = yield crypto.subtle.importKey('raw', sharedBits, 'HKDF', false, ['deriveKey']);
-        return crypto.subtle.deriveKey({ name: 'HKDF', hash: 'SHA-256', salt: new Uint8Array(32), info: HKDF_INFO }, hkdfKey, AES_KEY_PARAMS, false, ['encrypt', 'decrypt']);
-    });
-}
-/**
- * Encrypt a JSON-serializable payload for postMessage transport.
- *
- * Called by the **wallet** side. Uses the wallet's ephemeral private key
- * and the dapp's ephemeral public key to derive the shared AES key.
- *
- * @returns The encrypted payload plus the wallet's public key (for the dapp to derive the same shared key).
- */
-export function encryptPostMessagePayload(payload, walletKeyPair, walletPublicKeyBase64url, dappPublicKeyBase64url) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const sharedKey = yield deriveSharedKey(walletKeyPair.privateKey, dappPublicKeyBase64url);
-        const iv = crypto.getRandomValues(new Uint8Array(12));
-        const plaintext = new TextEncoder().encode(JSON.stringify(payload));
-        const ciphertextBuf = yield crypto.subtle.encrypt({ name: 'AES-GCM', iv }, sharedKey, plaintext);
-        return {
-            ciphertext: toBase64url(new Uint8Array(ciphertextBuf)),
-            iv: toBase64url(iv),
-            walletPublicKey: walletPublicKeyBase64url,
-        };
-    });
-}
-/**
- * Decrypt a postMessage payload received from the wallet.
- *
- * Called by the **dapp** side. Uses the dapp's ephemeral private key
- * and the wallet's ephemeral public key to derive the same shared key.
- */
-export function decryptPostMessagePayload(encrypted, dappKeyPair) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const sharedKey = yield deriveSharedKey(dappKeyPair.privateKey, encrypted.walletPublicKey);
-        const iv = fromBase64url(encrypted.iv);
-        const ciphertext = fromBase64url(encrypted.ciphertext);
-        const plaintextBuf = yield crypto.subtle.decrypt({ name: 'AES-GCM', iv }, sharedKey, ciphertext);
-        return JSON.parse(new TextDecoder().decode(plaintextBuf));
-    });
-}
-// ── Base64url helpers ────────────────────────────────────────────
-function toBase64url(bytes) {
-    let binary = '';
-    for (let i = 0; i < bytes.length; i++) {
-        binary += String.fromCodePoint(bytes[i]);
-    }
-    let b64 = btoa(binary).replaceAll('+', '-').replaceAll('/', '_');
-    // Strip trailing padding without a backtracking-vulnerable regex.
-    while (b64.endsWith('=')) {
-        b64 = b64.slice(0, -1);
-    }
-    return b64;
-}
-function fromBase64url(str) {
-    const padded = str.replaceAll('-', '+').replaceAll('_', '/');
-    const binary = atob(padded);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-        bytes[i] = binary.codePointAt(i);
-    }
-    return bytes;
-}
-//# sourceMappingURL=dweb-connect-crypto.js.map

package/dist/esm/dweb-connect-crypto.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dweb-connect-crypto.js","sourceRoot":"","sources":["../../src/dweb-connect-crypto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;;;;;;;;;;AAeH,MAAM,WAAW,GAAmB,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC;AAC1E,MAAM,cAAc,GAAwB,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;AAC7E,MAAM,SAAS,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAE9D;;;;GAIG;AACH,MAAM,UAAgB,wBAAwB;;QAI5C,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,WAAW,EAAE,KAAK,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;QACpF,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;QACvE,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,WAAW,CAAC,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;IAC9E,CAAC;CAAA;AAED;;;GAGG;AACH,SAAe,eAAe,CAC5B,eAA0B,EAC1B,wBAAgC;;QAEhC,MAAM,YAAY,GAAG,aAAa,CAAC,wBAAwB,CAAC,CAAC;QAC7D,MAAM,eAAe,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,SAAS,CACnD,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,EAAE,EAAE,CAC5C,CAAC;QAEF,yDAAyD;QACzD,MAAM,UAAU,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,UAAU,CAC/C,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAyB,EAChE,eAAe,EACf,GAAG,CACJ,CAAC;QAEF,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,SAAS,CAC3C,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,WAAW,CAAC,CAChD,CAAC;QAEF,OAAO,MAAM,CAAC,MAAM,CAAC,SAAS,CAC5B,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,UAAU,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,EAC5E,OAAO,EACP,cAAc,EACd,KAAK,EACL,CAAC,SAAS,EAAE,SAAS,CAAC,CACvB,CAAC;IACJ,CAAC;CAAA;AAED;;;;;;;GAOG;AACH,MAAM,UAAgB,yBAAyB,CAC7C,OAAgC,EAChC,aAA4B,EAC5B,wBAAgC,EAChC,sBAA8B;;QAE9B,MAAM,SAAS,GAAG,MAAM,eAAe,CAAC,aAAa,CAAC,UAAU,EAAE,sBAAsB,CAAC,CAAC;QAC1F,MAAM,EAAE,GAAG,MAAM,CAAC,eAAe,CAAC,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;QACtD,MAAM,SAAS,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;QAEpE,MAAM,aAAa,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,OAAO,CAC/C,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAkB,EACvC,SAAS,EACT,SAAS,CACV,CAAC;QAEF,OAAO;YACL,UAAU,EAAQ,WAAW,CAAC,IAAI,UAAU,CAAC,aAAa,CAAC,CAAC;YAC5D,EAAE,EAAgB,WAAW,CAAC,EAAE,CAAC;YACjC,eAAe,EAAG,wBAAwB;SAC3C,CAAC;IACJ,CAAC;CAAA;AAED;;;;;GAKG;AACH,MAAM,UAAgB,yBAAyB,CAC7C,SAAsC,EACtC,WAA0B;;QAE1B,MAAM,SAAS,GAAG,MAAM,eAAe,CAAC,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC;QAC3F,MAAM,EAAE,GAAG,aAAa,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QACvC,MAAM,UAAU,GAAG,aAAa,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAEvD,MAAM,YAAY,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,OAAO,CAC9C,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAkB,EACvC,SAAS,EACT,UAAU,CACX,CAAC;QAEF,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;IAC5D,CAAC;CAAA;AAED,oEAAoE;AAEpE,SAAS,WAAW,CAAC,KAAiB;IACpC,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C,CAAC;IACD,IAAI,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACjE,kEAAkE;IAClE,OAAO,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAAC,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAAC,CAAC;IACrD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,aAAa,CAAC,GAAW;IAChC,MAAM,MAAM,GAAG,GAAG,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC7D,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5B,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,CAAE,CAAC;IACpC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/types/dweb-connect-crypto.d.ts

@@ -1,52 +0,0 @@
-/**
- * ECDH + AES-256-GCM encryption for the DWeb Connect postMessage channel.
- *
- * Protects the authorization response (delegate private keys, decryption
- * keys, grants) from same-origin XSS interception. Both the dapp and
- * wallet generate ephemeral P-256 keypairs, exchange public keys during
- * the handshake, derive a shared AES-256-GCM key via ECDH + HKDF, and
- * encrypt/decrypt the payload.
- *
- * P-256 is used (instead of X25519) because `crypto.subtle.deriveKey`
- * with ECDH requires a NIST curve in all major browsers. The keys are
- * ephemeral — generated fresh for each connect session.
- *
- * @module
- */
-/** Exported public key as raw bytes (base64url-encoded for postMessage). */
-export type ExportedPublicKey = string;
-/** Encrypted payload sent via postMessage. */
-export interface EncryptedPostMessagePayload {
-    /** The encrypted JSON payload as base64url. */
-    ciphertext: string;
-    /** AES-GCM initialization vector as base64url. */
-    iv: string;
-    /** The wallet's ephemeral P-256 public key as base64url raw bytes. */
-    walletPublicKey: string;
-}
-/**
- * Generate an ephemeral P-256 ECDH keypair for a single connect session.
- *
- * @returns The keypair and the public key as a base64url-encoded raw export.
- */
-export declare function generateEphemeralKeyPair(): Promise<{
-    keyPair: CryptoKeyPair;
-    publicKeyBase64url: ExportedPublicKey;
-}>;
-/**
- * Encrypt a JSON-serializable payload for postMessage transport.
- *
- * Called by the **wallet** side. Uses the wallet's ephemeral private key
- * and the dapp's ephemeral public key to derive the shared AES key.
- *
- * @returns The encrypted payload plus the wallet's public key (for the dapp to derive the same shared key).
- */
-export declare function encryptPostMessagePayload(payload: Record<string, unknown>, walletKeyPair: CryptoKeyPair, walletPublicKeyBase64url: string, dappPublicKeyBase64url: string): Promise<EncryptedPostMessagePayload>;
-/**
- * Decrypt a postMessage payload received from the wallet.
- *
- * Called by the **dapp** side. Uses the dapp's ephemeral private key
- * and the wallet's ephemeral public key to derive the same shared key.
- */
-export declare function decryptPostMessagePayload(encrypted: EncryptedPostMessagePayload, dappKeyPair: CryptoKeyPair): Promise<Record<string, unknown>>;
-//# sourceMappingURL=dweb-connect-crypto.d.ts.map

package/dist/types/dweb-connect-crypto.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dweb-connect-crypto.d.ts","sourceRoot":"","sources":["../../src/dweb-connect-crypto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,4EAA4E;AAC5E,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC;AAEvC,8CAA8C;AAC9C,MAAM,WAAW,2BAA2B;IAC1C,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,EAAE,EAAE,MAAM,CAAC;IACX,sEAAsE;IACtE,eAAe,EAAE,MAAM,CAAC;CACzB;AAMD;;;;GAIG;AACH,wBAAsB,wBAAwB,IAAI,OAAO,CAAC;IACxD,OAAO,EAAE,aAAa,CAAC;IACvB,kBAAkB,EAAE,iBAAiB,CAAC;CACvC,CAAC,CAID;AAmCD;;;;;;;GAOG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,aAAa,EAAE,aAAa,EAC5B,wBAAwB,EAAE,MAAM,EAChC,sBAAsB,EAAE,MAAM,GAC7B,OAAO,CAAC,2BAA2B,CAAC,CAgBtC;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,SAAS,EAAE,2BAA2B,EACtC,WAAW,EAAE,aAAa,GACzB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAYlC"}