@aztec/wallet-sdk 0.0.1-commit.fcb71a6 → 3.0.0-devnet.2-patch.1

package/src/providers/extension/extension_wallet.ts

@@ -5,106 +5,245 @@ import { type PromiseWithResolvers, promiseWithResolvers } from '@aztec/foundati
 import { schemaHasMethod } from '@aztec/foundation/schemas';
 import type { FunctionsOf } from '@aztec/foundation/types';
 
-import type { WalletMessage, WalletResponse } from '../types.js';
+import { type EncryptedPayload, decrypt, encrypt } from '../../crypto.js';
+import { type WalletInfo, type WalletMessage, WalletMessageType, type WalletResponse } from '../../types.js';
 
 /**
- * Message payload for posting to extension
+ * Internal type representing a wallet method call before encryption.
+ * @internal
  */
 type WalletMethodCall = {
-  /**
-   * The wallet method name to invoke
-   */
+  /** The wallet method name to invoke */
   type: keyof FunctionsOf<Wallet>;
-  /**
-   * Arguments to pass to the wallet method
-   */
+  /** Arguments to pass to the wallet method */
   args: unknown[];
 };
 
+/**
+ * Callback type for wallet disconnect events.
+ */
+export type DisconnectCallback = () => void;
+
 /**
  * A wallet implementation that communicates with browser extension wallets
- * Supports multiple extensions by targeting specific extension IDs
+ * using a secure encrypted MessageChannel.
+ *
+ * This class uses a pre-established secure channel from the discovery phase:
+ *
+ * 1. **MessageChannel**: A private communication channel created during discovery,
+ *    not visible to other scripts on the page (unlike window.postMessage).
+ *
+ * 2. **ECDH Key Exchange**: The shared secret was derived during discovery using
+ *    Elliptic Curve Diffie-Hellman key exchange.
+ *
+ * 3. **AES-GCM Encryption**: All messages are encrypted using AES-256-GCM,
+ *    providing both confidentiality and authenticity.
+ *
+ * @example
+ * ```typescript
+ * // Discovery returns wallets with secure channel components
+ * const wallets = await ExtensionProvider.discoverExtensions(chainInfo);
+ * const { info, port, sharedKey } = wallets[0];
+ *
+ * // User can verify emoji if desired
+ * console.log('Verify:', hashToEmoji(info.verificationHash!));
+ *
+ * // Create wallet using the discovered components
+ * const wallet = await ExtensionWallet.create(info, chainInfo, port, sharedKey, 'my-dapp');
+ *
+ * // All subsequent calls are encrypted
+ * const accounts = await wallet.getAccounts();
+ * ```
  */
 export class ExtensionWallet {
+  /** Map of pending requests awaiting responses, keyed by message ID */
   private inFlight = new Map<string, PromiseWithResolvers<unknown>>();
+  private disconnected = false;
+  private disconnectCallbacks: DisconnectCallback[] = [];
 
+  /**
+   * Private constructor - use {@link ExtensionWallet.create} to instantiate.
+   * @param chainInfo - The chain information (chainId and version)
+   * @param appId - Application identifier for the requesting dApp
+   * @param extensionId - The unique identifier of the target wallet extension
+   * @param port - The MessagePort for private communication with the wallet
+   * @param sharedKey - The derived AES-256-GCM shared key for encryption
+   */
   private constructor(
     private chainInfo: ChainInfo,
     private appId: string,
     private extensionId: string,
+    private port: MessagePort,
+    private sharedKey: CryptoKey,
   ) {}
 
+  /** Cached Wallet proxy instance */
+  private walletProxy: Wallet | null = null;
+
   /**
-   * Creates an ExtensionWallet instance that proxies wallet calls to a browser extension
-   * @param chainInfo - The chain information (chainId and version)
-   * @param appId - Application identifier for the requesting dapp
-   * @param extensionId - Specific extension ID to communicate with
-   * @returns A Proxy object that implements the Wallet interface
+   * Creates an ExtensionWallet instance that communicates with a browser extension
+   * over a secure encrypted MessageChannel.
+   *
+   * @param walletInfo - The wallet info from ExtensionProvider.discoverExtensions()
+   * @param chainInfo - The chain information (chainId and version) for request context
+   * @param port - The MessagePort for private communication with the wallet
+   * @param sharedKey - The derived AES-256-GCM shared key for encryption
+   * @param appId - Application identifier used to identify the requesting dApp to the wallet
+   * @returns The ExtensionWallet instance. Use {@link getWallet} to get the Wallet interface.
+   *
+   * @example
+   * ```typescript
+   * const wallets = await ExtensionProvider.discoverExtensions(chainInfo);
+   * const { info, port, sharedKey } = wallets[0];
+   * const extensionWallet = ExtensionWallet.create(
+   *   info,
+   *   { chainId: Fr(31337), version: Fr(0) },
+   *   port,
+   *   sharedKey,
+   *   'my-defi-app'
+   * );
+   *
+   * // Register disconnect handler
+   * extensionWallet.onDisconnect(() => console.log('Disconnected!'));
+   *
+   * // Get the Wallet interface for dApp usage
+   * const wallet = extensionWallet.getWallet();
+   * const accounts = await wallet.getAccounts();
+   * ```
    */
-  static create(chainInfo: ChainInfo, appId: string, extensionId: string): Wallet {
-    const wallet = new ExtensionWallet(chainInfo, appId, extensionId);
+  static create(
+    walletInfo: WalletInfo,
+    chainInfo: ChainInfo,
+    port: MessagePort,
+    sharedKey: CryptoKey,
+    appId: string,
+  ): ExtensionWallet {
+    const wallet = new ExtensionWallet(chainInfo, appId, walletInfo.id, port, sharedKey);
 
-    // Set up message listener for responses from extensions
-    window.addEventListener('message', event => {
-      if (event.source !== window) {
-        return;
-      }
+    // Set up message handler - all messages are now encrypted
+    wallet.port.onmessage = (event: MessageEvent<EncryptedPayload>) => {
+      void wallet.handleEncryptedResponse(event.data);
+    };
 
-      let data: WalletResponse;
-      try {
-        data = JSON.parse(event.data);
-      } catch {
-        return;
-      }
+    wallet.port.start();
+
+    return wallet;
+  }
+
+  /**
+   * Returns a Wallet interface that proxies all method calls through the secure channel.
+   *
+   * The returned Wallet can be used directly by dApps - all method calls are automatically
+   * encrypted and sent to the wallet extension.
+   *
+   * @returns A Wallet implementation that encrypts all communication
+   *
+   * @example
+   * ```typescript
+   * const extensionWallet = ExtensionWallet.create(info, chainInfo, port, sharedKey, 'my-app');
+   * const wallet = extensionWallet.getWallet();
+   * const accounts = await wallet.getAccounts();
+   * ```
+   */
+  getWallet(): Wallet {
+    if (this.walletProxy) {
+      return this.walletProxy;
+    }
 
-      // Ignore request messages (only process responses)
-      if ('type' in data) {
+    // Create a Proxy that intercepts wallet method calls and forwards them to the extension
+    this.walletProxy = new Proxy(this, {
+      get: (target, prop) => {
+        if (schemaHasMethod(WalletSchema, prop.toString())) {
+          return async (...args: unknown[]) => {
+            const result = await target.postMessage({
+              type: prop.toString() as keyof FunctionsOf<Wallet>,
+              args,
+            });
+            return WalletSchema[prop.toString() as keyof typeof WalletSchema].returnType().parseAsync(result);
+          };
+        } else {
+          return target[prop as keyof ExtensionWallet];
+        }
+      },
+    }) as unknown as Wallet;
+
+    return this.walletProxy;
+  }
+
+  /**
+   * Handles an encrypted response received from the wallet extension.
+   *
+   * Decrypts the response using the shared AES key and resolves or rejects
+   * the corresponding pending promise based on the response content.
+   *
+   * @param encrypted - The encrypted response from the wallet
+   */
+  private async handleEncryptedResponse(encrypted: EncryptedPayload): Promise<void> {
+    if (!this.sharedKey) {
+      return;
+    }
+
+    try {
+      const response = await decrypt<WalletResponse>(this.sharedKey, encrypted);
+
+      const { messageId, result, error, walletId: responseWalletId } = response;
+
+      // Check for disconnect notification from the wallet backend
+      // This is sent as an encrypted error response with a special type
+      if (
+        error &&
+        typeof error === 'object' &&
+        'type' in error &&
+        (error.type as WalletMessageType) === WalletMessageType.SESSION_DISCONNECTED
+      ) {
+        this.handleDisconnect();
         return;
       }
 
-      const { messageId, result, error, walletId: responseWalletId } = data;
-
       if (!messageId || !responseWalletId) {
         return;
       }
 
-      if (wallet.extensionId !== responseWalletId) {
+      if (this.extensionId !== responseWalletId) {
         return;
       }
 
-      if (!wallet.inFlight.has(messageId)) {
+      if (!this.inFlight.has(messageId)) {
         return;
       }
 
-      const { resolve, reject } = wallet.inFlight.get(messageId)!;
+      const { resolve, reject } = this.inFlight.get(messageId)!;
 
       if (error) {
         reject(new Error(jsonStringify(error)));
       } else {
         resolve(result);
       }
-      wallet.inFlight.delete(messageId);
-    });
-
-    // Create a Proxy that intercepts wallet method calls and forwards them to the extension
-    return new Proxy(wallet, {
-      get: (target, prop) => {
-        if (schemaHasMethod(WalletSchema, prop.toString())) {
-          return async (...args: unknown[]) => {
-            const result = await target.postMessage({
-              type: prop.toString() as keyof FunctionsOf<Wallet>,
-              args,
-            });
-            return WalletSchema[prop.toString() as keyof typeof WalletSchema].returnType().parseAsync(result);
-          };
-        } else {
-          return target[prop as keyof ExtensionWallet];
-        }
-      },
-    }) as unknown as Wallet;
+      this.inFlight.delete(messageId);
+      // eslint-disable-next-line no-empty
+    } catch {}
   }
 
-  private postMessage(call: WalletMethodCall): Promise<unknown> {
+  /**
+   * Sends an encrypted wallet method call over the secure MessageChannel.
+   *
+   * The message is encrypted using AES-256-GCM with the shared key derived
+   * during discovery. A unique message ID is generated to correlate
+   * the response.
+   *
+   * @param call - The wallet method call containing method name and arguments
+   * @returns A Promise that resolves with the decrypted result from the wallet
+   *
+   * @throws Error if the secure channel has not been established or wallet is disconnected
+   */
+  private async postMessage(call: WalletMethodCall): Promise<unknown> {
+    if (this.disconnected) {
+      throw new Error('Wallet has been disconnected');
+    }
+    if (!this.port || !this.sharedKey) {
+      throw new Error('Secure channel not established');
+    }
+
     const messageId = globalThis.crypto.randomUUID();
     const message: WalletMessage = {
       type: call.type,
@@ -115,10 +254,126 @@ export class ExtensionWallet {
       walletId: this.extensionId,
     };
 
-    window.postMessage(jsonStringify(message), '*');
+    // Encrypt the message and send over the private MessageChannel
+    const encrypted = await encrypt(this.sharedKey, message);
+    this.port.postMessage(encrypted);
 
     const { promise, resolve, reject } = promiseWithResolvers<unknown>();
     this.inFlight.set(messageId, { promise, resolve, reject });
     return promise;
   }
+
+  /**
+   * Handles wallet disconnection.
+   * Rejects all pending requests and notifies registered callbacks.
+   * @internal
+   */
+  private handleDisconnect(): void {
+    if (this.disconnected) {
+      return;
+    }
+    this.disconnected = true;
+
+    // Close the port to prevent any further messages
+    if (this.port) {
+      this.port.onmessage = null;
+      this.port.close();
+    }
+
+    // Reject all pending requests
+    // Note: These rejections should be caught by the callers, but we log them
+    // here to help with debugging if they become unhandled
+    const error = new Error('Wallet disconnected');
+    for (const { reject } of this.inFlight.values()) {
+      reject(error);
+    }
+    this.inFlight.clear();
+
+    // Notify registered callbacks
+    for (const callback of this.disconnectCallbacks) {
+      try {
+        callback();
+      } catch {
+        // Ignore errors in callbacks
+      }
+    }
+  }
+
+  /**
+   * Registers a callback to be invoked when the wallet disconnects.
+   *
+   * @param callback - Function to call when wallet disconnects
+   * @returns A function to unregister the callback
+   *
+   * @example
+   * ```typescript
+   * const wallet = await ExtensionWallet.create(...);
+   * const unsubscribe = wallet.onDisconnect(() => {
+   *   console.log('Wallet disconnected! Please reconnect.');
+   *   // Clean up UI, prompt user to reconnect, etc.
+   * });
+   * // Later: unsubscribe(); to stop receiving notifications
+   * ```
+   */
+  onDisconnect(callback: DisconnectCallback): () => void {
+    this.disconnectCallbacks.push(callback);
+    return () => {
+      const index = this.disconnectCallbacks.indexOf(callback);
+      if (index !== -1) {
+        this.disconnectCallbacks.splice(index, 1);
+      }
+    };
+  }
+
+  /**
+   * Returns whether the wallet has been disconnected.
+   *
+   * @returns true if the wallet is no longer connected
+   */
+  isDisconnected(): boolean {
+    return this.disconnected;
+  }
+
+  /**
+   * Disconnects from the wallet and cleans up resources.
+   *
+   * This method notifies the wallet extension that the session is ending,
+   * allowing it to clean up its state. After calling this method, the wallet
+   * instance can no longer be used and any pending requests will be rejected.
+   *
+   * @example
+   * ```typescript
+   * const wallet = await provider.connect('my-app');
+   * // ... use wallet ...
+   * await wallet.disconnect(); // Clean disconnect when done
+   * ```
+   */
+  async disconnect(): Promise<void> {
+    if (this.disconnected) {
+      return;
+    }
+
+    // Send disconnect message to extension before closing
+    if (this.port && this.sharedKey) {
+      try {
+        const message = {
+          type: WalletMessageType.DISCONNECT,
+          messageId: globalThis.crypto.randomUUID(),
+          chainInfo: this.chainInfo,
+          appId: this.appId,
+          walletId: this.extensionId,
+          args: [],
+        };
+        const encrypted = await encrypt(this.sharedKey, message);
+        this.port.postMessage(encrypted);
+      } catch {
+        // Ignore errors sending disconnect message
+      }
+    }
+
+    this.handleDisconnect();
+    if (this.port) {
+      this.port.close();
+    }
+  }
 }

package/src/providers/extension/index.ts

@@ -1,3 +1,5 @@
-export { ExtensionWallet } from './extension_wallet.js';
-export { ExtensionProvider } from './extension_provider.js';
-export type { WalletInfo, WalletMessage, WalletResponse, DiscoveryRequest, DiscoveryResponse } from '../types.js';
+export { ExtensionWallet, type DisconnectCallback } from './extension_wallet.js';
+export { ExtensionProvider, type DiscoveredWallet } from './extension_provider.js';
+export * from '../../crypto.js';
+export { WalletMessageType } from '../../types.js';
+export type { WalletInfo, WalletMessage, WalletResponse, DiscoveryRequest, DiscoveryResponse } from '../../types.js';

package/src/{providers/types.ts → types.ts}

@@ -1,7 +1,24 @@
 import type { ChainInfo } from '@aztec/aztec.js/account';
 
+import type { ExportedPublicKey } from './crypto.js';
+
+/**
+ * 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',
+  /** Session disconnected notification (unencrypted control message) */
+  SESSION_DISCONNECTED = 'aztec-wallet-session-disconnected',
+  /** Explicit disconnect request from dApp */
+  DISCONNECT = 'aztec-wallet-disconnect',
+}
+
 /**
- * Information about an installed Aztec wallet wallet
+ * Information about an installed Aztec wallet
  */
 export interface WalletInfo {
   /** Unique identifier for the wallet */
@@ -12,10 +29,18 @@ export interface WalletInfo {
   icon?: string;
   /** Wallet version */
   version: string;
+  /** Wallet's ECDH public key for secure channel establishment */
+  publicKey: ExportedPublicKey;
+  /**
+   * Hash of the shared secret for anti-MITM 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;
 }
 
 /**
- * Message format for wallet communication
+ * Message format for wallet communication (internal, before encryption)
  */
 export interface WalletMessage {
   /** Unique message ID for tracking responses */
@@ -47,23 +72,25 @@ export interface WalletResponse {
 }
 
 /**
- * Discovery message for finding installed wallets
+ * 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;
   /** Chain information to check if wallet supports this network */
   chainInfo: ChainInfo;
+  /** dApp's ECDH public key for deriving shared secret */
+  publicKey: ExportedPublicKey;
 }
 
 /**
- * Discovery response from an wallet
+ * 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 */

package/dest/providers/types.d.ts

@@ -1,67 +0,0 @@
-import type { ChainInfo } from '@aztec/aztec.js/account';
-/**
- * Information about an installed Aztec wallet wallet
- */
-export interface WalletInfo {
-    /** Unique identifier for the wallet */
-    id: string;
-    /** Display name of the wallet */
-    name: string;
-    /** URL to the wallet's icon */
-    icon?: string;
-    /** Wallet version */
-    version: string;
-}
-/**
- * Message format for wallet communication
- */
-export interface WalletMessage {
-    /** Unique message ID for tracking responses */
-    messageId: string;
-    /** The wallet method to call */
-    type: string;
-    /** Arguments for the method */
-    args: unknown[];
-    /** Chain information */
-    chainInfo: ChainInfo;
-    /** Application ID making the request */
-    appId: string;
-    /** Wallet ID to target a specific wallet */
-    walletId: string;
-}
-/**
- * Response message from wallet
- */
-export interface WalletResponse {
-    /** Message ID matching the request */
-    messageId: string;
-    /** Result data (if successful) */
-    result?: unknown;
-    /** Error data (if failed) */
-    error?: unknown;
-    /** Wallet ID that sent the response */
-    walletId: string;
-}
-/**
- * Discovery message for finding installed wallets
- */
-export interface DiscoveryRequest {
-    /** Message type for discovery */
-    type: 'aztec-wallet-discovery';
-    /** Request ID */
-    requestId: string;
-    /** Chain information to check if wallet supports this network */
-    chainInfo: ChainInfo;
-}
-/**
- * Discovery response from an wallet
- */
-export interface DiscoveryResponse {
-    /** Message type for discovery response */
-    type: 'aztec-wallet-discovery-response';
-    /** Request ID matching the discovery request */
-    requestId: string;
-    /** Wallet information */
-    walletInfo: WalletInfo;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm92aWRlcnMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFekQ7O0dBRUc7QUFDSCxNQUFNLFdBQVcsVUFBVTtJQUN6Qix1Q0FBdUM7SUFDdkMsRUFBRSxFQUFFLE1BQU0sQ0FBQztJQUNYLGlDQUFpQztJQUNqQyxJQUFJLEVBQUUsTUFBTSxDQUFDO0lBQ2IsK0JBQStCO0lBQy9CLElBQUksQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNkLHFCQUFxQjtJQUNyQixPQUFPLEVBQUUsTUFBTSxDQUFDO0NBQ2pCO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFdBQVcsYUFBYTtJQUM1QiwrQ0FBK0M7SUFDL0MsU0FBUyxFQUFFLE1BQU0sQ0FBQztJQUNsQixnQ0FBZ0M7SUFDaEMsSUFBSSxFQUFFLE1BQU0sQ0FBQztJQUNiLCtCQUErQjtJQUMvQixJQUFJLEVBQUUsT0FBTyxFQUFFLENBQUM7SUFDaEIsd0JBQXdCO0lBQ3hCLFNBQVMsRUFBRSxTQUFTLENBQUM7SUFDckIsd0NBQXdDO0lBQ3hDLEtBQUssRUFBRSxNQUFNLENBQUM7SUFDZCw0Q0FBNEM7SUFDNUMsUUFBUSxFQUFFLE1BQU0sQ0FBQztDQUNsQjtBQUVEOztHQUVHO0FBQ0gsTUFBTSxXQUFXLGNBQWM7SUFDN0Isc0NBQXNDO0lBQ3RDLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsa0NBQWtDO0lBQ2xDLE1BQU0sQ0FBQyxFQUFFLE9BQU8sQ0FBQztJQUNqQiw2QkFBNkI7SUFDN0IsS0FBSyxDQUFDLEVBQUUsT0FBTyxDQUFDO0lBQ2hCLHVDQUF1QztJQUN2QyxRQUFRLEVBQUUsTUFBTSxDQUFDO0NBQ2xCO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFdBQVcsZ0JBQWdCO0lBQy9CLGlDQUFpQztJQUNqQyxJQUFJLEVBQUUsd0JBQXdCLENBQUM7SUFDL0IsaUJBQWlCO0lBQ2pCLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsaUVBQWlFO0lBQ2pFLFNBQVMsRUFBRSxTQUFTLENBQUM7Q0FDdEI7QUFFRDs7R0FFRztBQUNILE1BQU0sV0FBVyxpQkFBaUI7SUFDaEMsMENBQTBDO0lBQzFDLElBQUksRUFBRSxpQ0FBaUMsQ0FBQztJQUN4QyxnREFBZ0Q7SUFDaEQsU0FBUyxFQUFFLE1BQU0sQ0FBQztJQUNsQix5QkFBeUI7SUFDekIsVUFBVSxFQUFFLFVBQVUsQ0FBQztDQUN4QiJ9

package/dest/providers/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/providers/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,uCAAuC;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qBAAqB;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,wBAAwB;IACxB,SAAS,EAAE,SAAS,CAAC;IACrB,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,6BAA6B;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iCAAiC;IACjC,IAAI,EAAE,wBAAwB,CAAC;IAC/B,iBAAiB;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,SAAS,EAAE,SAAS,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,0CAA0C;IAC1C,IAAI,EAAE,iCAAiC,CAAC;IACxC,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,yBAAyB;IACzB,UAAU,EAAE,UAAU,CAAC;CACxB"}

package/dest/providers/types.js

@@ -1,3 +0,0 @@
-/**
- * Discovery response from an wallet
- */ export { };