@aztec/wallet-sdk 0.0.1-commit.21caa21 → 0.0.1-commit.2ed92850

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,46 @@ 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
+   * @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): 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 +136,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,48 @@
-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 { 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 +67,177 @@ 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 markComplete = () => {
+      completed = true;
+      resolveDone();
+      if (pendingResolve) {
+        const resolve = pendingResolve;
+        pendingResolve = null;
+        resolve({ value: undefined, done: true });
+      }
+    };
 
-    // Discover extension wallets
     if (this.config.extensions?.enabled) {
-      const extensions = await ExtensionProvider.discoverExtensions(chainInfo, options.timeout);
       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) {
+            return;
+          }
+
+          // Call user's callback if provided
+          options.onWalletDiscovered?.(provider);
 
-        providers.push({
-          id: ext.id,
-          type: 'extension',
-          name: ext.name,
-          icon: ext.icon,
-          metadata: {
-            version: ext.version,
+          // Also queue for async iterator
+          if (pendingResolve) {
+            const resolve = pendingResolve;
+            pendingResolve = null;
+            resolve({ value: provider, done: false });
+          } else {
+            pendingProviders.push(provider);
+          }
+        },
+      }).then(markComplete);
+    } else {
+      markComplete();
+    }
+
+    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) => Promise.resolve(ExtensionWallet.create(chainInfo, appId, ext.id)),
-        });
-      }
+        };
+      },
+    };
+
+    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: () => {
+            return Promise.resolve(
+              ExtensionWallet.create(
+                connection.info.id,
+                connection.port,
+                connection.sharedKey,
+                chainInfo,
+                connectAppId,
+              ),
+            );
+          },
+          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,
+            });
+            // Don't close the port - allow retry with fresh key exchange
+          },
+        };
+      },
+      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 +246,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

@@ -0,0 +1,132 @@
+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',
+  /** 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',
+}
+
+/**
+ * Information about an installed Aztec wallet.
+ * Used during discovery phase before key exchange.
+ */
+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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Message format for wallet communication (internal, before encryption)
+ */
+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 (public, unencrypted).
+ */
+export interface DiscoveryRequest {
+  /** Message type for 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).
+ */
+export interface DiscoveryResponse {
+  /** Message type for discovery response */
+  type: WalletMessageType.DISCOVERY_RESPONSE;
+  /** Request ID matching the discovery request */
+  requestId: string;
+  /** Basic wallet information */
+  walletInfo: WalletInfo;
+}
+
+/**
+ * Key exchange request sent over MessageChannel after discovery approval.
+ */
+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;
+}

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZW5zaW9uX3Byb3ZpZGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2V4dGVuc2lvbi9leHRlbnNpb25fcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFJekQsT0FBTyxLQUFLLEVBQXVDLFVBQVUsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUVuRjs7R0FFRztBQUNILHFCQUFhLGlCQUFpQjtJQUM1QixPQUFPLENBQUMsTUFBTSxDQUFDLG9CQUFvQixDQUFzQztJQUN6RSxPQUFPLENBQUMsTUFBTSxDQUFDLG1CQUFtQixDQUFTO0lBRTNDOzs7OztPQUtHO0lBQ0gsT0FBYSxrQkFBa0IsQ0FBQyxTQUFTLEVBQUUsU0FBUyxFQUFFLE9BQU8sR0FBRSxNQUFhLEdBQUcsT0FBTyxDQUFDLFVBQVUsRUFBRSxDQUFDLENBbURuRztDQUNGIn0=

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,aAAa,CAAC;AAEnF;;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"}

package/dest/providers/extension/extension_provider.js

@@ -1,56 +0,0 @@
-import { jsonStringify } from '@aztec/foundation/json-rpc';
-import { promiseWithResolvers } from '@aztec/foundation/promise';
-/**
- * Provider for discovering and managing Aztec wallet extensions
- */ export class ExtensionProvider {
-    static discoveredExtensions = new Map();
-    static discoveryInProgress = false;
-    /**
-   * 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 async discoverExtensions(chainInfo, timeout = 1000) {
-        // If discovery is in progress, wait for it to complete
-        if (this.discoveryInProgress) {
-            await new Promise((resolve)=>setTimeout(resolve, timeout));
-            return Array.from(this.discoveredExtensions.values());
-        }
-        this.discoveryInProgress = true;
-        this.discoveredExtensions.clear();
-        const { promise, resolve } = promiseWithResolvers();
-        const requestId = globalThis.crypto.randomUUID();
-        const responses = [];
-        // Set up listener for discovery responses
-        const handleMessage = (event)=>{
-            if (event.source !== window) {
-                return;
-            }
-            let data;
-            try {
-                data = JSON.parse(event.data);
-            } catch  {
-                return;
-            }
-            if (data.type === 'aztec-wallet-discovery-response' && data.requestId === requestId) {
-                responses.push(data.walletInfo);
-                this.discoveredExtensions.set(data.walletInfo.id, data.walletInfo);
-            }
-        };
-        window.addEventListener('message', handleMessage);
-        // Send discovery message
-        const discoveryMessage = {
-            type: 'aztec-wallet-discovery',
-            requestId,
-            chainInfo
-        };
-        window.postMessage(jsonStringify(discoveryMessage), '*');
-        // Wait for responses
-        setTimeout(()=>{
-            window.removeEventListener('message', handleMessage);
-            this.discoveryInProgress = false;
-            resolve(responses);
-        }, timeout);
-        return promise;
-    }
-}

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

@@ -1,23 +0,0 @@
-import type { ChainInfo } from '@aztec/aztec.js/account';
-import { type Wallet } from '@aztec/aztec.js/wallet';
-/**
- * A wallet implementation that communicates with browser extension wallets
- * Supports multiple extensions by targeting specific extension IDs
- */
-export declare class ExtensionWallet {
-    private chainInfo;
-    private appId;
-    private extensionId;
-    private inFlight;
-    private constructor();
-    /**
-     * 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
-     */
-    static create(chainInfo: ChainInfo, appId: string, extensionId: string): Wallet;
-    private postMessage;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZW5zaW9uX3dhbGxldC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy9leHRlbnNpb24vZXh0ZW5zaW9uX3dhbGxldC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUN6RCxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sd0JBQXdCLENBQUM7QUFzQm5FOzs7R0FHRztBQUNILHFCQUFhLGVBQWU7SUFJeEIsT0FBTyxDQUFDLFNBQVM7SUFDakIsT0FBTyxDQUFDLEtBQUs7SUFDYixPQUFPLENBQUMsV0FBVztJQUxyQixPQUFPLENBQUMsUUFBUSxDQUFvRDtJQUVwRSxPQUFPLGVBSUg7SUFFSjs7Ozs7O09BTUc7SUFDSCxNQUFNLENBQUMsTUFBTSxDQUFDLFNBQVMsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxXQUFXLEVBQUUsTUFBTSxHQUFHLE1BQU0sQ0E2RDlFO0lBRUQsT0FBTyxDQUFDLFdBQVc7Q0FpQnBCIn0=

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

@@ -1 +0,0 @@
-{"version":3,"file":"extension_wallet.d.ts","sourceRoot":"","sources":["../../../src/providers/extension/extension_wallet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,wBAAwB,CAAC;AAsBnE;;;GAGG;AACH,qBAAa,eAAe;IAIxB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,WAAW;IALrB,OAAO,CAAC,QAAQ,CAAoD;IAEpE,OAAO,eAIH;IAEJ;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CA6D9E;IAED,OAAO,CAAC,WAAW;CAiBpB"}