@aztec/wallet-sdk 0.0.1-commit.96bb3f7 → 0.0.1-commit.993d240

package/src/manager/types.ts

@@ -1,6 +1,37 @@
 import type { ChainInfo } from '@aztec/aztec.js/account';
 import type { Wallet } from '@aztec/aztec.js/wallet';
 
+/**
+ * A pending connection that requires user verification before finalizing.
+ *
+ * After key exchange, both dApp and wallet compute a verification hash independently.
+ * The dApp should display this hash (typically as emojis) and let the user confirm
+ * it matches what's shown in their wallet before calling `confirm()`.
+ *
+ * This protects the dApp from connecting to a malicious wallet that might be
+ * intercepting the connection (MITM attack).
+ */
+export interface PendingConnection {
+  /**
+   * The verification hash computed from the shared secret.
+   * Use `hashToEmoji()` to convert to a visual representation for user verification.
+   * The user should confirm this matches what their wallet displays.
+   */
+  verificationHash: string;
+
+  /**
+   * Confirms the connection after user verifies the emojis match.
+   * @returns The connected wallet instance
+   */
+  confirm(): Promise<Wallet>;
+
+  /**
+   * Cancels the pending connection.
+   * Call this if the user indicates the emojis don't match.
+   */
+  cancel(): void;
+}
+
 /**
  * Configuration for extension wallets
  */
@@ -34,7 +65,12 @@ export interface WalletManagerConfig {
 /**
  * Type of wallet provider
  */
-export type WalletProviderType = 'extension' | 'web' | 'embedded';
+export type WalletProviderType = 'extension' | 'web';
+
+/**
+ * Callback type for wallet disconnect events at the provider level.
+ */
+export type ProviderDisconnectionCallback = () => void;
 
 /**
  * A wallet provider that can connect to create a wallet instance.
@@ -52,10 +88,47 @@ export interface WalletProvider {
   /** Additional metadata */
   metadata?: Record<string, unknown>;
   /**
-   * Connect to this wallet provider with an application ID
+   * Establishes a secure channel with this wallet provider.
+   *
+   * This performs the ECDH key exchange and returns a pending connection with the
+   * verification hash. The channel is encrypted but NOT yet verified - the dApp
+   * should display the hash (as emojis) to the user and let them confirm it
+   * matches their wallet before calling `confirm()`.
+   *
    * @param appId - Application identifier for the requesting dapp
+   * @param options - Optional provider-specific options (e.g. container element for iframe wallets)
+   * @returns A pending connection with verification hash and confirm/cancel methods
+   *
+   * @example
+   * ```typescript
+   * const pending = await provider.establishSecureChannel('my-app');
+   *
+   * // Show emojis to user for verification
+   * const emojis = hashToEmoji(pending.verificationHash);
+   * showDialog(`Verify these match your wallet: ${emojis}`);
+   *
+   * // User confirms emojis match
+   * const wallet = await pending.confirm();
+   * ```
+   */
+  establishSecureChannel(appId: string, options?: Record<string, unknown>): Promise<PendingConnection>;
+  /**
+   * Disconnects the current wallet and cleans up resources.
+   * After calling this, the wallet returned from confirm() should no longer be used.
+   * @returns A promise that resolves when disconnection is complete
+   */
+  disconnect(): Promise<void>;
+  /**
+   * Registers a callback to be invoked when the wallet disconnects unexpectedly.
+   * @param callback - Function to call when wallet disconnects
+   * @returns A function to unregister the callback
+   */
+  onDisconnect(callback: ProviderDisconnectionCallback): () => void;
+  /**
+   * Returns whether the provider's wallet connection has been disconnected.
+   * @returns true if the wallet is no longer connected
    */
-  connect(appId: string): Promise<Wallet>;
+  isDisconnected(): boolean;
 }
 
 /**
@@ -64,6 +137,42 @@ export interface WalletProvider {
 export interface DiscoverWalletsOptions {
   /** Chain information to filter by */
   chainInfo: ChainInfo;
-  /** Discovery timeout in milliseconds */
+  /** Application ID making the request */
+  appId: string;
+  /** Discovery timeout in milliseconds. Default: 60000 (60s) */
   timeout?: number;
+  /**
+   * Callback invoked when a wallet provider is discovered.
+   * Use this to show wallets to users as they approve them, rather than
+   * waiting for the full timeout.
+   */
+  onWalletDiscovered?: (provider: WalletProvider) => void;
+}
+
+/**
+ * A cancellable discovery session.
+ *
+ * Returned by `WalletManager.getAvailableWallets()` to allow consumers to
+ * cancel discovery when no longer needed (e.g., network changes, user navigates away).
+ *
+ * @example
+ * ```typescript
+ * const discovery = WalletManager.configure({...}).getAvailableWallets({...});
+ *
+ * // Iterate over discovered wallets
+ * for await (const wallet of discovery.wallets) {
+ *   console.log(`Found: ${wallet.name}`);
+ * }
+ *
+ * // Cancel discovery when no longer needed
+ * discovery.cancel();
+ * ```
+ */
+export interface DiscoverySession {
+  /** Async iterator that yields wallet providers as they're discovered */
+  wallets: AsyncIterable<WalletProvider>;
+  /** Promise that resolves when discovery completes or is cancelled */
+  done: Promise<void>;
+  /** Cancel discovery immediately and clean up resources */
+  cancel: () => void;
 }

package/src/manager/wallet_manager.ts

@@ -1,8 +1,49 @@
-import { ExtensionProvider, ExtensionWallet } from '../providers/extension/index.js';
-import type { DiscoverWalletsOptions, ExtensionWalletConfig, WalletManagerConfig, WalletProvider } from './types.js';
+import type { ChainInfo } from '@aztec/aztec.js/account';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+
+import { type DiscoveredWallet, ExtensionProvider, ExtensionWallet } from '../extension/provider/index.js';
+import { discoverWebWallets } from '../iframe/provider/iframe_discovery.js';
+import { WalletMessageType } from '../types.js';
+import type {
+  DiscoverWalletsOptions,
+  DiscoverySession,
+  ExtensionWalletConfig,
+  PendingConnection,
+  ProviderDisconnectionCallback,
+  WalletManagerConfig,
+  WalletProvider,
+} from './types.js';
 
 /**
- * Manager for wallet discovery, configuration, and connection
+ * Manager for wallet discovery, configuration, and connection.
+ *
+ * This is the main entry point for dApps to discover and connect to wallets.
+ *
+ * @example Basic usage with async iterator
+ * ```typescript
+ * const discovery = WalletManager.configure({ extensions: { enabled: true } })
+ *   .getAvailableWallets({ chainInfo, appId: 'my-app' });
+ *
+ * // Iterate over discovered wallets
+ * for await (const provider of discovery.wallets) {
+ *   console.log(`Found wallet: ${provider.name}`);
+ * }
+ *
+ * // Or cancel early when done
+ * discovery.cancel();
+ * ```
+ *
+ * @example With callback for discovered wallets
+ * ```typescript
+ * const discovery = manager.getAvailableWallets({
+ *   chainInfo,
+ *   appId: 'my-app',
+ *   onWalletDiscovered: (provider) => console.log(`Found: ${provider.name}`),
+ * });
+ *
+ * // Wait for discovery to complete or cancel it
+ * await discovery.done;
+ * ```
  */
 export class WalletManager {
   private config: WalletManagerConfig = {
@@ -27,41 +68,208 @@ export class WalletManager {
 
   /**
    * Discovers all available wallets for a given chain and version.
-   * Only returns wallets that support the requested chain and version.
-   * @param options - Discovery options including chain info and timeout
-   * @returns Array of wallet providers with baked-in chain info
+   *
+   * Returns a `DiscoverySession` with:
+   * - `wallets`: AsyncIterable to iterate over discovered wallets
+   * - `done`: Promise that resolves when discovery completes or is cancelled
+   * - `cancel()`: Function to stop discovery immediately
+   *
+   * If `onWalletDiscovered` callback is provided, wallets are also streamed via callback.
+   *
+   * @param options - Discovery options including chain info, appId, and timeout
+   * @returns A cancellable discovery session
    */
-  async getAvailableWallets(options: DiscoverWalletsOptions): Promise<WalletProvider[]> {
-    const providers: WalletProvider[] = [];
-    const { chainInfo } = options;
+  getAvailableWallets(options: DiscoverWalletsOptions): DiscoverySession {
+    const { chainInfo, appId } = options;
+    const abortController = new AbortController();
+
+    const pendingProviders: WalletProvider[] = [];
+    let pendingResolve: ((result: IteratorResult<WalletProvider>) => void) | null = null;
+    let completed = false;
+
+    const { promise: donePromise, resolve: resolveDone } = promiseWithResolvers<void>();
+
+    const pendingSources = new Set<string>();
+
+    const emit = (provider: WalletProvider) => {
+      options.onWalletDiscovered?.(provider);
+
+      if (pendingResolve) {
+        const resolve = pendingResolve;
+        pendingResolve = null;
+        resolve({ value: provider, done: false });
+      } else {
+        pendingProviders.push(provider);
+      }
+    };
+
+    const markComplete = () => {
+      completed = true;
+      resolveDone();
+      if (pendingResolve) {
+        const resolve = pendingResolve;
+        pendingResolve = null;
+        resolve({ value: undefined, done: true });
+      }
+    };
+
+    const sourceComplete = (source: string) => {
+      pendingSources.delete(source);
+      if (pendingSources.size === 0) {
+        markComplete();
+      }
+    };
 
-    // Discover extension wallets
     if (this.config.extensions?.enabled) {
-      const extensions = await ExtensionProvider.discoverExtensions(chainInfo, options.timeout);
+      pendingSources.add('extensions');
       const extensionConfig = this.config.extensions;
 
-      for (const ext of extensions) {
-        // Apply allow/block lists
-        if (!this.isExtensionAllowed(ext.id, extensionConfig)) {
-          continue;
+      void ExtensionProvider.discoverWallets(chainInfo, {
+        appId,
+        timeout: options.timeout,
+        signal: abortController.signal,
+        onWalletDiscovered: discoveredWallet => {
+          const provider = this.createProviderFromDiscoveredWallet(discoveredWallet, chainInfo, extensionConfig);
+          if (provider) {
+            emit(provider);
+          }
+        },
+      }).then(() => sourceComplete('extensions'));
+    }
+
+    if (this.config.webWallets?.urls && this.config.webWallets.urls.length > 0) {
+      pendingSources.add('webWallets');
+      const webSession = discoverWebWallets(this.config.webWallets.urls, chainInfo);
+
+      // Forward discovered web wallets into the shared iterator
+      void (async () => {
+        try {
+          for await (const provider of webSession.wallets) {
+            if (abortController.signal.aborted) {
+              break;
+            }
+            emit(provider);
+          }
+        } finally {
+          sourceComplete('webWallets');
         }
+      })();
+
+      abortController.signal.addEventListener('abort', () => webSession.cancel(), { once: true });
+    }
+
+    if (pendingSources.size === 0) {
+      markComplete();
+    }
 
-        providers.push({
-          id: ext.id,
-          type: 'extension',
-          name: ext.name,
-          icon: ext.icon,
-          metadata: {
-            version: ext.version,
+    const wallets: AsyncIterable<WalletProvider> = {
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      [Symbol.asyncIterator](): AsyncIterator<WalletProvider> {
+        return {
+          // eslint-disable-next-line jsdoc/require-jsdoc
+          next(): Promise<IteratorResult<WalletProvider>> {
+            if (pendingProviders.length > 0) {
+              return Promise.resolve({ value: pendingProviders.shift()!, done: false });
+            }
+
+            if (completed) {
+              return Promise.resolve({ value: undefined, done: true });
+            }
+
+            return new Promise(resolve => {
+              pendingResolve = resolve;
+            });
           },
-          connect: (appId: string) => ExtensionWallet.create(ext, chainInfo, appId),
-        });
-      }
+        };
+      },
+    };
+
+    return {
+      wallets,
+      done: donePromise,
+      cancel: () => abortController.abort(),
+    };
+  }
+
+  /**
+   * Creates a WalletProvider from a discovered wallet.
+   * Returns null if the wallet is not allowed by config.
+   * @param discoveredWallet - The discovered wallet from extension discovery.
+   * @param chainInfo - Network information.
+   * @param extensionConfig - Extension wallet configuration.
+   */
+  private createProviderFromDiscoveredWallet(
+    discoveredWallet: DiscoveredWallet,
+    chainInfo: ChainInfo,
+    extensionConfig: ExtensionWalletConfig,
+  ): WalletProvider | null {
+    const { info } = discoveredWallet;
+
+    if (!this.isExtensionAllowed(info.id, extensionConfig)) {
+      return null;
     }
 
-    // TODO: Add web wallet discovery when implemented
+    let extensionWallet: ExtensionWallet | null = null;
+
+    const provider: WalletProvider = {
+      id: info.id,
+      type: 'extension',
+      name: info.name,
+      icon: info.icon,
+      metadata: {
+        version: info.version,
+      },
+      establishSecureChannel: async (connectAppId: string): Promise<PendingConnection> => {
+        const connection = await discoveredWallet.establishSecureChannel();
+
+        provider.metadata = {
+          ...provider.metadata,
+          verificationHash: connection.info.verificationHash,
+        };
+
+        return {
+          verificationHash: connection.info.verificationHash!,
+          confirm: () => {
+            extensionWallet = ExtensionWallet.create(
+              connection.info.id,
+              connection.port,
+              connection.sharedKey,
+              chainInfo,
+              connectAppId,
+            );
+            return Promise.resolve(extensionWallet.asWallet());
+          },
+          cancel: () => {
+            // Send disconnect to terminate the session on the extension side
+            // but keep the port open so we can retry key exchange
+            connection.port.postMessage({
+              type: WalletMessageType.DISCONNECT,
+              requestId: discoveredWallet.requestId,
+            });
+          },
+        };
+      },
+      disconnect: async () => {
+        if (extensionWallet) {
+          await extensionWallet.disconnect();
+          extensionWallet = null;
+        }
+      },
+      onDisconnect: (callback: ProviderDisconnectionCallback) => {
+        if (extensionWallet) {
+          return extensionWallet.onDisconnect(callback);
+        }
+        return () => {};
+      },
+      isDisconnected: () => {
+        if (extensionWallet) {
+          return extensionWallet.isDisconnected();
+        }
+        return true;
+      },
+    };
 
-    return providers;
+    return provider;
   }
 
   /**
@@ -70,17 +278,14 @@ export class WalletManager {
    * @param config - Extension wallet configuration containing allow/block lists
    */
   private isExtensionAllowed(extensionId: string, config: ExtensionWalletConfig): boolean {
-    // Check block list first
     if (config.blockList && config.blockList.includes(extensionId)) {
       return false;
     }
 
-    // If allow list exists, extension must be in it
     if (config.allowList && config.allowList.length > 0) {
       return config.allowList.includes(extensionId);
     }
 
-    // If no allow list, extension is allowed (unless blocked)
     return true;
   }
 }

package/src/types.ts

@@ -3,7 +3,40 @@ import type { ChainInfo } from '@aztec/aztec.js/account';
 import type { ExportedPublicKey } from './crypto.js';
 
 /**
- * Information about an installed Aztec wallet
+ * Message types for wallet SDK communication.
+ * All types are prefixed with 'aztec-wallet-' for namespacing.
+ */
+export enum WalletMessageType {
+  /** Discovery request to find installed wallets */
+  DISCOVERY = 'aztec-wallet-discovery',
+  /** Discovery response from a wallet */
+  DISCOVERY_RESPONSE = 'aztec-wallet-discovery-response',
+  /** Disconnect message (unencrypted control message, bidirectional) */
+  DISCONNECT = 'aztec-wallet-disconnect',
+  /** Key exchange request sent over MessageChannel */
+  KEY_EXCHANGE_REQUEST = 'aztec-wallet-key-exchange-request',
+  /** Key exchange response sent over MessageChannel */
+  KEY_EXCHANGE_RESPONSE = 'aztec-wallet-key-exchange-response',
+  /** Wallet ready signal */
+  WALLET_READY = 'aztec-wallet-ready',
+  /** Encrypted wallet message wrapper */
+  SECURE_MESSAGE = 'aztec-wallet-secure-message',
+  /** Encrypted wallet response wrapper */
+  SECURE_RESPONSE = 'aztec-wallet-secure-response',
+  /** Session disconnected notification */
+  SESSION_DISCONNECTED = 'aztec-wallet-session-disconnected',
+  /** Liveness probe sent by the dApp while a request is in flight */
+  PING = 'aztec-wallet-ping',
+  /** Liveness response from the wallet. Any inbound message (including a regular
+   * encrypted response) is treated as proof of liveness, so a missing PONG alone
+   * never trips disconnect — the dApp also resets its liveness timer on traffic.
+   */
+  PONG = 'aztec-wallet-pong',
+}
+
+/**
+ * Information about an installed Aztec wallet.
+ * Used during discovery phase before key exchange.
  */
 export interface WalletInfo {
   /** Unique identifier for the wallet */
@@ -14,8 +47,21 @@ export interface WalletInfo {
   icon?: string;
   /** Wallet version */
   version: string;
+}
+
+/**
+ * Full information about a connected Aztec wallet including crypto material.
+ * Available after key exchange completes.
+ */
+export interface ConnectedWalletInfo extends WalletInfo {
   /** Wallet's ECDH public key for secure channel establishment */
   publicKey: ExportedPublicKey;
+  /**
+   * Verification hash for verification.
+   * Both dApp and wallet independently compute this from the ECDH shared secret.
+   * Use {@link hashToEmoji} to convert to a visual representation for user verification.
+   */
+  verificationHash?: string;
 }
 
 /**
@@ -51,39 +97,108 @@ export interface WalletResponse {
 }
 
 /**
- * Discovery message for finding installed wallets (public, unencrypted)
+ * Discovery message for finding installed wallets (public, unencrypted).
  */
 export interface DiscoveryRequest {
   /** Message type for discovery */
-  type: 'aztec-wallet-discovery';
+  type: WalletMessageType.DISCOVERY;
   /** Request ID */
   requestId: string;
+  /** Application ID making the request */
+  appId: string;
   /** Chain information to check if wallet supports this network */
   chainInfo: ChainInfo;
 }
 
 /**
- * Discovery response from a wallet (public, unencrypted)
+ * Discovery response from a wallet (public, unencrypted).
  */
 export interface DiscoveryResponse {
   /** Message type for discovery response */
-  type: 'aztec-wallet-discovery-response';
+  type: WalletMessageType.DISCOVERY_RESPONSE;
   /** Request ID matching the discovery request */
   requestId: string;
-  /** Wallet information */
+  /** Basic wallet information */
   walletInfo: WalletInfo;
 }
 
 /**
- * Connection request to establish secure channel
+ * Key exchange request sent over MessageChannel after discovery approval.
  */
-export interface ConnectRequest {
-  /** Message type for connection */
-  type: 'aztec-wallet-connect';
-  /** Target wallet ID */
-  walletId: string;
-  /** Application ID */
-  appId: string;
+export interface KeyExchangeRequest {
+  /** Message type */
+  type: WalletMessageType.KEY_EXCHANGE_REQUEST;
+  /** Request ID matching the discovery request */
+  requestId: string;
   /** dApp's ECDH public key for deriving shared secret */
   publicKey: ExportedPublicKey;
 }
+
+/**
+ * Key exchange response sent over MessageChannel.
+ */
+export interface KeyExchangeResponse {
+  /** Message type */
+  type: WalletMessageType.KEY_EXCHANGE_RESPONSE;
+  /** Request ID matching the discovery request */
+  requestId: string;
+  /** Wallet's ECDH public key for deriving shared secret */
+  publicKey: ExportedPublicKey;
+}
+
+/**
+ * Callback invoked when a wallet connection is disconnected.
+ */
+export type DisconnectCallback = () => void;
+
+/**
+ * Default heartbeat tuning shared by both transports.
+ *
+ * - `intervalMs`: how often the dApp sends PING probes while a request is in flight.
+ * - `deadAfterMs`: how long the channel can stay silent (no PONG, no encrypted
+ *   response, no DISCONNECT) before the dApp declares the wallet unreachable
+ *   and rejects all in-flight requests. Generous enough that long-running
+ *   operations (proveTx, sendTx) on legacy wallets that don't reply to PING
+ *   still succeed — any inbound traffic resets the timer.
+ */
+export const DEFAULT_HEARTBEAT_INTERVAL_MS = 5_000;
+export const DEFAULT_HEARTBEAT_DEAD_AFTER_MS = 300_000;
+
+/** Override knobs for the heartbeat — mostly useful for tests. */
+export interface HeartbeatOptions {
+  /** How often to send PING probes while a request is in flight (ms). */
+  intervalMs?: number;
+  /** Idle ceiling before declaring disconnect (ms). */
+  deadAfterMs?: number;
+}
+
+/**
+ * Minimal logger surface used by the wallet SDK.
+ *
+ * Defined locally so that wallet hosts (browser extensions, iframe wallet pages)
+ * can pass a simple `console`-backed logger without pulling in the full
+ * `@aztec/foundation` logging runtime, which is non-trivial to bundle in those
+ * contexts. Structurally compatible with `Logger` from `@aztec/foundation/log`,
+ * so dApp-side callers can pass that type directly.
+ */
+export interface WalletSdkLogger {
+  /** Diagnostic messages — typically discarded in production. */
+  debug: (message: string, data?: unknown) => void;
+  /** Informational messages — significant lifecycle events. */
+  info: (message: string, data?: unknown) => void;
+  /** Recoverable problems — channel decryption failure, missed heartbeats, etc. */
+  warn: (message: string, data?: unknown) => void;
+  /** Errors that prevent normal operation. */
+  error: (message: string, errOrData?: unknown, data?: unknown) => void;
+}
+
+/**
+ * No-op logger used as the default when callers don't provide one. Discards all
+ * messages — wallet hosts that want diagnostics should pass their own logger.
+ */
+export const NOOP_LOGGER: WalletSdkLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+};

package/dest/providers/extension/extension_provider.d.ts

@@ -1,17 +0,0 @@
-import type { ChainInfo } from '@aztec/aztec.js/account';
-import type { WalletInfo } from '../../types.js';
-/**
- * Provider for discovering and managing Aztec wallet extensions
- */
-export declare class ExtensionProvider {
-    private static discoveredExtensions;
-    private static discoveryInProgress;
-    /**
-     * Discovers all installed Aztec wallet extensions
-     * @param chainInfo - Chain information to check if extensions support this network
-     * @param timeout - How long to wait for extensions to respond (ms)
-     * @returns Array of discovered extension information
-     */
-    static discoverExtensions(chainInfo: ChainInfo, timeout?: number): Promise<WalletInfo[]>;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZW5zaW9uX3Byb3ZpZGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2V4dGVuc2lvbi9leHRlbnNpb25fcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFJekQsT0FBTyxLQUFLLEVBQXVDLFVBQVUsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRXRGOztHQUVHO0FBQ0gscUJBQWEsaUJBQWlCO0lBQzVCLE9BQU8sQ0FBQyxNQUFNLENBQUMsb0JBQW9CLENBQXNDO0lBQ3pFLE9BQU8sQ0FBQyxNQUFNLENBQUMsbUJBQW1CLENBQVM7SUFFM0M7Ozs7O09BS0c7SUFDSCxPQUFhLGtCQUFrQixDQUFDLFNBQVMsRUFBRSxTQUFTLEVBQUUsT0FBTyxHQUFFLE1BQWEsR0FBRyxPQUFPLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FtRG5HO0NBQ0YifQ==

package/dest/providers/extension/extension_provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extension_provider.d.ts","sourceRoot":"","sources":["../../../src/providers/extension/extension_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAIzD,OAAO,KAAK,EAAuC,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEtF;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAsC;IACzE,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAS;IAE3C;;;;;OAKG;IACH,OAAa,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,GAAE,MAAa,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAmDnG;CACF"}