@dynamic-labs-sdk/metamask 1.30.3 → 1.31.1

package/dist/index.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.esm.js","names":["uri: string"],"sources":["../package.json","../src/clearMetaMaskSessionStorage/clearMetaMaskSessionStorage.ts","../src/errors/MetaMaskDisplayUriMissingError/MetaMaskDisplayUriMissingError.ts","../src/getMetaMaskExtensionWalletProviderKey/getMetaMaskExtensionWalletProviderKey.ts","../src/connectWithMetaMaskUri/connectWithMetaMaskUri.ts","../src/errors/MetaMaskWalletNotConnectedError/MetaMaskWalletNotConnectedError.ts","../src/exports/index.ts"],"sourcesContent":["","import type { DynamicClient } from '@dynamic-labs-sdk/client';\nimport { getCore } from '@dynamic-labs-sdk/client/core';\n\n// MetaMask SDK persists session state in this IndexedDB database.\n// Hardcoded inside `@metamask/connect-multichain` (the SDK shared by\n// every chain-specific connect-* facade) as `${DB_NAME}${dbNameSuffix}`\n// → `mmconnect` + `-kv-store` on web.\nconst METAMASK_SDK_IDB_NAME = 'mmconnect-kv-store';\n\nconst FAILED_TO_CLEAR_SESSION_MESSAGE =\n  '[metamask] failed to clear the persisted session from IndexedDB; the next pairing may resume a stale session instead of showing a new one';\n\n/**\n * Deletes the MetaMask SDK's IndexedDB session storage so the next connect call\n * emits a fresh `display_uri` synchronously instead of spending the SDK's\n * 10-second resume timeout reviving a dead pairing. Safe in SSR (no-op) and\n * when the DB is held open by another tab (resolves on `blocked`).\n *\n * @example\n * ```ts\n * await clearMetaMaskSessionStorage(client);\n * // Next connectWithMetaMaskUri call will emit a fresh URI immediately.\n * ```\n *\n * @param client - The Dynamic client instance. Required (rather than\n * defaulting to the last-initialized client) so a storage-clear failure is\n * always logged against the client that actually requested it.\n * @returns A promise that resolves once the database is deleted (or immediately in SSR).\n * @see connectWithMetaMaskUri\n * @see getMetaMaskExtensionWalletProviderKey\n * @notInstrumented\n */\nexport const clearMetaMaskSessionStorage = (\n  // No default: avoids misattributing the failure-path warning below.\n  // eslint-disable-next-line custom-rules/check-dynamic-client-param-in-external-functions\n  client: DynamicClient\n): Promise<void> => {\n  if (typeof indexedDB === 'undefined') {\n    return Promise.resolve();\n  }\n\n  return new Promise<void>((resolve) => {\n    try {\n      const request = indexedDB.deleteDatabase(METAMASK_SDK_IDB_NAME);\n      request.onsuccess = () => resolve();\n      // `onblocked` fires when a concurrent tab holds the DB open; that is\n      // expected multi-tab behaviour, not a failure, so it resolves quietly.\n      // We still resolve on `onerror` so the consumer's connect flow is not\n      // stalled indefinitely, but it is logged first: a failed delete here\n      // puts the caller back on the stale session it was trying to escape.\n      // The Promise executor already ignores subsequent resolve calls, so no\n      // extra guard is needed when multiple lifecycle events fire on the\n      // same request.\n      request.onerror = () => {\n        getCore(client).logger.warn(FAILED_TO_CLEAR_SESSION_MESSAGE, request.error);\n        resolve();\n      };\n      request.onblocked = () => resolve();\n    } catch (error) {\n      getCore(client).logger.warn(FAILED_TO_CLEAR_SESSION_MESSAGE, error);\n      resolve();\n    }\n  });\n};\n","import { BaseError } from '@dynamic-labs-sdk/client';\n\nexport class MetaMaskDisplayUriMissingError extends BaseError {\n  constructor() {\n    super({\n      cause: null,\n      code: 'metamask_display_uri_missing',\n      docsUrl: null,\n      name: 'MetaMaskDisplayUriMissingError',\n      shortMessage:\n        'MetaMask SDK completed the connection without emitting a display_uri. The connect helper requires the SDK to produce a pairing URI. Please reach out to Dynamic about this error.',\n    });\n  }\n}\n","import type { Chain, DynamicClient } from '@dynamic-labs-sdk/client';\nimport {\n  getDefaultClient,\n  getWalletProviderRegistry,\n} from '@dynamic-labs-sdk/client/core';\nimport { WalletProviderEnum } from '@dynamic-labs/sdk-api-core';\n\nconst METAMASK_NAME_NEEDLE = 'metamask';\n\ntype GetMetaMaskExtensionWalletProviderKeyParams = {\n  /** Chain to scope the lookup to. */\n  chain: Chain;\n};\n\n/**\n * Returns the wallet provider key of the MetaMask browser extension announced\n * for the given chain (EIP-6963 on EVM, Wallet Standard on Solana), or\n * `undefined` when none is announced. Matches on normalized display name to\n * cover MetaMask, Flask, and other variants. Synchronous and safe to call from\n * a React render. Pass the returned key to `connectWithWalletProvider` to route\n * the connection through the announced provider; fall back to the chain's\n * `connectWithMetaMaskUri<Chain>` helper when `undefined`.\n *\n * @example\n * ```ts\n * const key = getMetaMaskExtensionWalletProviderKey({ chain: 'EVM' });\n * if (key) {\n *   await connectWithWalletProvider({ walletProviderKey: key });\n * }\n * ```\n *\n * @param params.chain - Chain to scope the lookup to.\n * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.\n * @returns The wallet provider key string, or `undefined` if no MetaMask extension is announced.\n * @see connectWithMetaMaskUri\n * @see clearMetaMaskSessionStorage\n * @notInstrumented\n */\nexport const getMetaMaskExtensionWalletProviderKey = (\n  { chain }: GetMetaMaskExtensionWalletProviderKeyParams,\n  client: DynamicClient = getDefaultClient()\n): string | undefined => {\n  const providers = getWalletProviderRegistry(client).listProviders();\n\n  const match = providers.find(\n    (provider) =>\n      provider.chain === chain &&\n      provider.walletProviderType === WalletProviderEnum.BrowserExtension &&\n      provider.metadata.displayName\n        ?.toLowerCase()\n        .includes(METAMASK_NAME_NEEDLE)\n  );\n\n  return match?.key;\n};\n","import type {\n  Chain,\n  DynamicClient,\n  WalletAccount,\n  WalletProviderUriConnectionResult,\n} from '@dynamic-labs-sdk/client';\nimport { NoAddressFoundError } from '@dynamic-labs-sdk/client';\nimport type { WalletProvider } from '@dynamic-labs-sdk/client/core';\nimport {\n  WalletProviderPriority,\n  createDeferredPromise,\n  formatWalletAccountId,\n  getCore,\n  getDefaultClient,\n  getWalletProviderRegistry,\n  reconcileWalletAccountsAgainstClient,\n} from '@dynamic-labs-sdk/client/core';\n\nimport { MetaMaskDisplayUriMissingError } from '../errors/MetaMaskDisplayUriMissingError';\nimport { getMetaMaskExtensionWalletProviderKey } from '../getMetaMaskExtensionWalletProviderKey';\nimport type { MetaMaskController } from '../metamask.types';\n\nexport type ConnectWithMetaMaskUriParams = {\n  /** Whether to add the connected wallet account to the Dynamic client. Defaults to `true`. */\n  addToDynamicWalletAccounts?: boolean;\n  /** Chain being connected; used to scope the extension-installed lookup. */\n  chain: Chain;\n  /** Returns the chain-specific `MetaMaskController` that drives the pairing. */\n  getController: (client: DynamicClient) => Promise<MetaMaskController>;\n  /**\n   * Builds the chain-specific `WalletProvider` AFTER the pairing has been\n   * approved. Must NOT include a `connect` method — the provider is registered\n   * purely for signing routing and would otherwise leak into the wallet picker.\n   */\n  walletProviderBuilder: (client: DynamicClient) => Promise<WalletProvider>;\n};\n\n/**\n * Drives a MetaMask SDK pairing for any chain and returns `{ approval, uri }`\n * so consumers can render the QR / hand the URI to a deeplink. Logs an\n * advisory warning when the extension is already announced for the chain —\n * pairing still proceeds, but the consumer is told which announced provider\n * key to route through for the best UX. Builds and registers the chain-\n * specific wallet provider only after pairing is approved; the provider\n * therefore never appears in the wallet picker (no `connect` method).\n *\n * @example\n * ```ts\n * const { uri, approval } = await connectWithMetaMaskUri({\n *   chain: 'EVM',\n *   getController: (client) => getEvmMetaMaskController(client),\n *   walletProviderBuilder: (client) => buildEvmWalletProvider(client),\n * });\n * // Render QR code with `uri`, then await approval()\n * ```\n *\n * @param params.chain - Chain being connected; used to scope the extension-installed lookup.\n * @param params.getController - Returns the chain-specific MetaMaskController for the pairing.\n * @param params.walletProviderBuilder - Builds the chain-specific WalletProvider after pairing approval.\n * @param [params.addToDynamicWalletAccounts] - Whether to add the wallet to the client. Defaults to `true`.\n * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.\n * @returns An object with `uri` (the pairing URI) and `approval` (async function resolving to wallet accounts).\n * @throws {MetaMaskDisplayUriMissingError} If `connect` settles before a display_uri is emitted.\n * @throws {NoAddressFoundError} If no address is returned after pairing approval.\n * @see clearMetaMaskSessionStorage\n * @see getMetaMaskExtensionWalletProviderKey\n * @notInstrumented\n */\nexport const connectWithMetaMaskUri = async (\n  {\n    addToDynamicWalletAccounts = true,\n    chain,\n    getController,\n    walletProviderBuilder,\n  }: ConnectWithMetaMaskUriParams,\n  client: DynamicClient = getDefaultClient()\n): Promise<WalletProviderUriConnectionResult> => {\n  const announcedKey = getMetaMaskExtensionWalletProviderKey({ chain }, client);\n\n  if (announcedKey !== undefined) {\n    getCore(client).logger.warn(\n      `[metamask] MetaMask extension is announced for ${chain} as wallet provider \"${announcedKey}\"; proceeding with URI pairing. Consider connectWithWalletProvider({ walletProviderKey: \"${announcedKey}\" }) for the best user experience.`\n    );\n  }\n\n  const controller = await getController(client);\n\n  const uriDeferred = createDeferredPromise<string>();\n\n  const unsubscribe = controller.onDisplayUri((displayUri) => {\n    uriDeferred.resolve(displayUri);\n  });\n\n  const connectPromise = controller.connect();\n\n  // If `connect` settles before a `display_uri` is emitted, no URI was made\n  // available and the pairing is unusable. Reject the deferred so the caller\n  // surfaces `MetaMaskDisplayUriMissingError` (or the underlying failure).\n  connectPromise\n    .then(() => {\n      uriDeferred.reject(new MetaMaskDisplayUriMissingError());\n    })\n    .catch((error: unknown) => {\n      uriDeferred.reject(error);\n    });\n\n  let uri: string;\n  try {\n    uri = await uriDeferred.promise;\n  } finally {\n    unsubscribe();\n  }\n\n  const approval = async (): Promise<{ walletAccounts: WalletAccount[] }> => {\n    await connectPromise;\n\n    const walletProvider = await walletProviderBuilder(client);\n\n    getWalletProviderRegistry(client).register({\n      priority: WalletProviderPriority.WALLET_SDK,\n      walletProvider,\n    });\n\n    const { addresses } = await walletProvider.getConnectedAddresses();\n\n    // MetaMask SDK exposes a single active address per pairing (same model as\n    // EIP-1193 `eth_accounts`); we only materialize the first one.\n    const mainAddress = addresses[0];\n\n    if (mainAddress === undefined) {\n      throw new NoAddressFoundError();\n    }\n\n    const walletAccount: WalletAccount = {\n      address: mainAddress,\n      chain: walletProvider.chain,\n      id: formatWalletAccountId({\n        address: mainAddress,\n        chain: walletProvider.chain,\n        walletProviderKey: walletProvider.key,\n      }),\n      lastSelectedAt: null,\n      verifiedCredentialId: null,\n      walletProviderKey: walletProvider.key,\n    };\n\n    const walletAccounts = reconcileWalletAccountsAgainstClient(\n      {\n        addToDynamicWalletAccounts,\n        walletAccounts: [walletAccount],\n        walletProviderKey: walletProvider.key,\n      },\n      client\n    );\n\n    return { walletAccounts };\n  };\n\n  return { approval, uri };\n};\n","import { BaseError } from '@dynamic-labs-sdk/client';\n\nexport class MetaMaskWalletNotConnectedError extends BaseError {\n  constructor() {\n    super({\n      cause: null,\n      code: 'metamask_wallet_not_connected',\n      docsUrl: null,\n      name: 'MetaMaskWalletNotConnectedError',\n      shortMessage:\n        'MetaMask SDK has no connected wallet account. Complete the URI pairing (await the connect approval) before building the MetaMask wallet provider.',\n    });\n  }\n}\n","import { assertPackageVersion } from '@dynamic-labs-sdk/assert-package-version';\n\nimport { name, version } from '../../package.json';\n\nassertPackageVersion(name, version);\n\nexport { clearMetaMaskSessionStorage } from '../clearMetaMaskSessionStorage';\nexport { connectWithMetaMaskUri } from '../connectWithMetaMaskUri';\nexport type { ConnectWithMetaMaskUriParams } from '../connectWithMetaMaskUri';\nexport { MetaMaskDisplayUriMissingError } from '../errors/MetaMaskDisplayUriMissingError';\nexport { MetaMaskWalletNotConnectedError } from '../errors/MetaMaskWalletNotConnectedError';\nexport { getMetaMaskExtensionWalletProviderKey } from '../getMetaMaskExtensionWalletProviderKey';\nexport type {\n  DisplayUriListener,\n  MetaMaskController,\n} from '../metamask.types';\n"],"mappings":";;;;;;;;;;;ACOA,MAAM,wBAAwB;AAE9B,MAAM,kCACJ;;;;;;;;;;;;;;;;;;;;;AAsBF,MAAa,+BAGX,WACkB;AAClB,KAAI,OAAO,cAAc,YACvB,QAAO,QAAQ,SAAS;AAG1B,QAAO,IAAI,SAAe,YAAY;AACpC,MAAI;GACF,MAAM,UAAU,UAAU,eAAe,sBAAsB;AAC/D,WAAQ,kBAAkB,SAAS;AASnC,WAAQ,gBAAgB;AACtB,YAAQ,OAAO,CAAC,OAAO,KAAK,iCAAiC,QAAQ,MAAM;AAC3E,aAAS;;AAEX,WAAQ,kBAAkB,SAAS;WAC5B,OAAO;AACd,WAAQ,OAAO,CAAC,OAAO,KAAK,iCAAiC,MAAM;AACnE,YAAS;;GAEX;;;;;AC5DJ,IAAa,iCAAb,cAAoD,UAAU;CAC5D,cAAc;AACZ,QAAM;GACJ,OAAO;GACP,MAAM;GACN,SAAS;GACT,MAAM;GACN,cACE;GACH,CAAC;;;;;;ACJN,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;AA+B7B,MAAa,yCACX,EAAE,SACF,SAAwB,kBAAkB,KACnB;AAYvB,QAXkB,0BAA0B,OAAO,CAAC,eAAe,CAE3C,MACrB,aACC,SAAS,UAAU,SACnB,SAAS,uBAAuB,mBAAmB,oBACnD,SAAS,SAAS,aACd,aAAa,CACd,SAAS,qBAAqB,CACpC,EAEa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACehB,MAAa,yBAAyB,OACpC,EACE,6BAA6B,MAC7B,OACA,eACA,yBAEF,SAAwB,kBAAkB,KACK;CAC/C,MAAM,eAAe,sCAAsC,EAAE,OAAO,EAAE,OAAO;AAE7E,KAAI,iBAAiB,OACnB,SAAQ,OAAO,CAAC,OAAO,KACrB,kDAAkD,MAAM,uBAAuB,aAAa,2FAA2F,aAAa,oCACrM;CAGH,MAAM,aAAa,MAAM,cAAc,OAAO;CAE9C,MAAM,cAAc,uBAA+B;CAEnD,MAAM,cAAc,WAAW,cAAc,eAAe;AAC1D,cAAY,QAAQ,WAAW;GAC/B;CAEF,MAAM,iBAAiB,WAAW,SAAS;AAK3C,gBACG,WAAW;AACV,cAAY,OAAO,IAAI,gCAAgC,CAAC;GACxD,CACD,OAAO,UAAmB;AACzB,cAAY,OAAO,MAAM;GACzB;CAEJ,IAAIA;AACJ,KAAI;AACF,QAAM,MAAM,YAAY;WAChB;AACR,eAAa;;CAGf,MAAM,WAAW,YAA0D;AACzE,QAAM;EAEN,MAAM,iBAAiB,MAAM,sBAAsB,OAAO;AAE1D,4BAA0B,OAAO,CAAC,SAAS;GACzC,UAAU,uBAAuB;GACjC;GACD,CAAC;EAEF,MAAM,EAAE,cAAc,MAAM,eAAe,uBAAuB;EAIlE,MAAM,cAAc,UAAU;AAE9B,MAAI,gBAAgB,OAClB,OAAM,IAAI,qBAAqB;AAyBjC,SAAO,EAAE,gBATc,qCACrB;GACE;GACA,gBAAgB,CAhBiB;IACnC,SAAS;IACT,OAAO,eAAe;IACtB,IAAI,sBAAsB;KACxB,SAAS;KACT,OAAO,eAAe;KACtB,mBAAmB,eAAe;KACnC,CAAC;IACF,gBAAgB;IAChB,sBAAsB;IACtB,mBAAmB,eAAe;IACnC,CAKkC;GAC/B,mBAAmB,eAAe;GACnC,EACD,OACD,EAEwB;;AAG3B,QAAO;EAAE;EAAU;EAAK;;;;;AC5J1B,IAAa,kCAAb,cAAqD,UAAU;CAC7D,cAAc;AACZ,QAAM;GACJ,OAAO;GACP,MAAM;GACN,SAAS;GACT,MAAM;GACN,cACE;GACH,CAAC;;;;;;ACPN,qBAAqB,MAAM,QAAQ"}
+{"version":3,"file":"index.esm.js","names":["uri: string"],"sources":["../src/clearMetaMaskSessionStorage/clearMetaMaskSessionStorage.ts","../src/errors/MetaMaskDisplayUriMissingError/MetaMaskDisplayUriMissingError.ts","../src/getMetaMaskExtensionWalletProviderKey/getMetaMaskExtensionWalletProviderKey.ts","../src/connectWithMetaMaskUri/connectWithMetaMaskUri.ts","../src/exports/index.ts"],"sourcesContent":["import type { DynamicClient } from '@dynamic-labs-sdk/client';\n\nimport { clearMetaMaskStorage } from '../metaMaskStorage/clearMetaMaskStorage';\n\n/**\n * Resets the MetaMask SDK's persisted session so the next connect call\n * emits a fresh `display_uri` instead of resuming a stale pairing.\n *\n * @deprecated The clearMetaMaskSessionStorage is not needed anymore since the SDK itself will handle the storage\n *\n * @example\n * ```ts\n * await clearMetaMaskSessionStorage(client);\n * // Next connectWithMetaMaskUri call will emit a fresh URI immediately.\n * ```\n *\n * @param client - The Dynamic client instance. Required (rather than\n * defaulting to the last-initialized client) so a storage-clear failure is\n * always logged against the client that actually requested it.\n * @returns A promise that resolves once the persisted session is reset.\n * @see connectWithMetaMaskUri\n * @see createMetaMaskClientInstanceManager\n * @notInstrumented\n */\nexport const clearMetaMaskSessionStorage = (\n  // eslint-disable-next-line custom-rules/check-dynamic-client-param-in-external-functions\n  client: DynamicClient\n): Promise<void> => clearMetaMaskStorage(client);\n","import { BaseError } from '@dynamic-labs-sdk/client';\n\n/**\n * Thrown when the MetaMask SDK's `connect()` call settles (resolves or\n * rejects) without ever emitting a `display_uri` event. `connectWithMetaMaskUri`\n * requires that event to produce the pairing URI/QR code; without it, there\n * is nothing to render and the caller would otherwise hang indefinitely\n * awaiting a URI that will never arrive.\n *\n * @example\n * ```ts\n * try {\n *   await connectWithMetaMaskUri({ onDisplayUri }, client);\n * } catch (error) {\n *   if (error instanceof MetaMaskDisplayUriMissingError) {\n *     // The MetaMask SDK never produced a pairing URI; surface a generic\n *     // connection failure instead of hanging.\n *   }\n * }\n * ```\n * @see connectWithMetaMaskUri\n * @see MetaMaskUnscopedNetworkError\n */\nexport class MetaMaskDisplayUriMissingError extends BaseError {\n  constructor() {\n    super({\n      cause: null,\n      code: 'metamask_display_uri_missing',\n      docsUrl: null,\n      name: 'MetaMaskDisplayUriMissingError',\n      shortMessage:\n        'MetaMask SDK completed the connection without emitting a display_uri. The connect helper requires the SDK to produce a pairing URI. Please reach out to Dynamic about this error.',\n    });\n  }\n}\n","import type { Chain, DynamicClient } from '@dynamic-labs-sdk/client';\nimport {\n  getDefaultClient,\n  getWalletProviderRegistry,\n} from '@dynamic-labs-sdk/client/core';\nimport { WalletProviderEnum } from '@dynamic-labs/sdk-api-core';\n\nconst METAMASK_NAME_NEEDLE = 'metamask';\n\ntype GetMetaMaskExtensionWalletProviderKeyParams = {\n  /** Chain to scope the lookup to. */\n  chain: Chain;\n};\n\n/**\n * Returns the wallet provider key of the MetaMask browser extension announced\n * for the given chain (EIP-6963 on EVM, Wallet Standard on Solana), or\n * `undefined` when none is announced. Matches on normalized display name to\n * cover MetaMask, Flask, and other variants. Synchronous and safe to call from\n * a React render. Pass the returned key to `connectWithWalletProvider` to route\n * the connection through the announced provider; fall back to the chain's\n * `connectWithMetaMaskUri<Chain>` helper when `undefined`.\n *\n * @example\n * ```ts\n * const key = getMetaMaskExtensionWalletProviderKey({ chain: 'EVM' });\n * if (key) {\n *   await connectWithWalletProvider({ walletProviderKey: key });\n * }\n * ```\n *\n * @param params.chain - Chain to scope the lookup to.\n * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.\n * @returns The wallet provider key string, or `undefined` if no MetaMask extension is announced.\n * @see connectWithMetaMaskUri\n * @see clearMetaMaskStorage\n * @notInstrumented\n */\nexport const getMetaMaskExtensionWalletProviderKey = (\n  { chain }: GetMetaMaskExtensionWalletProviderKeyParams,\n  client: DynamicClient = getDefaultClient()\n): string | undefined => {\n  const providers = getWalletProviderRegistry(client).listProviders();\n\n  const match = providers.find(\n    (provider) =>\n      provider.chain === chain &&\n      provider.walletProviderType === WalletProviderEnum.BrowserExtension &&\n      provider.metadata.displayName\n        ?.toLowerCase()\n        .includes(METAMASK_NAME_NEEDLE)\n  );\n\n  return match?.key;\n};\n","import type {\n  Chain,\n  DynamicClient,\n  WalletAccount,\n  WalletProviderUriConnectionResult,\n} from '@dynamic-labs-sdk/client';\nimport { NoAddressFoundError } from '@dynamic-labs-sdk/client';\nimport type { WalletProvider } from '@dynamic-labs-sdk/client/core';\nimport {\n  WalletProviderPriority,\n  createDeferredPromise,\n  formatWalletAccountId,\n  getCore,\n  getDefaultClient,\n  getWalletProviderRegistry,\n  reconcileWalletAccountsAgainstClient,\n} from '@dynamic-labs-sdk/client/core';\n\nimport { MetaMaskDisplayUriMissingError } from '../errors/MetaMaskDisplayUriMissingError';\nimport { getMetaMaskExtensionWalletProviderKey } from '../getMetaMaskExtensionWalletProviderKey';\nimport { getMetaMaskScopes } from '../getMetaMaskScopes';\nimport { getOrCreateMetaMaskClientInstanceManager } from '../metaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager';\n\nexport type ConnectWithMetaMaskUriParams = {\n  /** Whether to add the connected wallet account to the Dynamic client. Defaults to `true`. */\n  addToDynamicWalletAccounts?: boolean;\n  /** Chain being connected; used to scope the extension-installed lookup. */\n  chain: Chain;\n  /**\n   * Builds the chain-specific `WalletProvider` AFTER the pairing has been\n   * approved. Must NOT include a `connect` method — the provider is registered\n   * purely for signing routing and would otherwise leak into the wallet picker.\n   */\n  walletProviderBuilder: (client: DynamicClient) => WalletProvider;\n};\n\n/**\n * Drives a MetaMask SDK pairing for any chain and returns `{ approval, uri }`\n * so consumers can render the QR / hand the URI to a deeplink. Logs an\n * advisory warning when the extension is already announced for the chain —\n * pairing still proceeds, but the consumer is told which announced provider\n * key to route through for the best UX. Builds and registers the chain-\n * specific wallet provider only after pairing is approved; the provider\n * therefore never appears in the wallet picker (no `connect` method).\n *\n * @example\n * ```ts\n * const { uri, approval } = await connectWithMetaMaskUri({\n *   chain: 'EVM',\n *   walletProviderBuilder: (client) => buildEvmWalletProvider(client),\n * });\n * // Render QR code with `uri`, then await approval()\n * ```\n *\n * @param params.chain - Chain being connected; used to scope the extension-installed lookup.\n * @param params.walletProviderBuilder - Builds the chain-specific WalletProvider after pairing approval.\n * @param [params.addToDynamicWalletAccounts] - Whether to add the wallet to the client. Defaults to `true`.\n * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.\n * @returns An object with `uri` (the pairing URI) and `approval` (async function resolving to wallet accounts).\n * @throws {MetaMaskDisplayUriMissingError} If `connect` settles before a display_uri is emitted.\n * @throws {NoAddressFoundError} If no address is returned after pairing approval.\n * @see clearMetaMaskStorage\n * @see getMetaMaskExtensionWalletProviderKey\n * @notInstrumented\n */\nexport const connectWithMetaMaskUri = async (\n  {\n    addToDynamicWalletAccounts = true,\n    chain,\n    walletProviderBuilder,\n  }: ConnectWithMetaMaskUriParams,\n  client: DynamicClient = getDefaultClient()\n): Promise<WalletProviderUriConnectionResult> => {\n  const { logger } = getCore(client);\n  const announcedKey = getMetaMaskExtensionWalletProviderKey({ chain }, client);\n  const uriDeferred = createDeferredPromise<string>();\n  const connectionScopes = getMetaMaskScopes({ chain }, client);\n  const metaMaskClientInstanceManager =\n    getOrCreateMetaMaskClientInstanceManager(client);\n\n  await metaMaskClientInstanceManager.clearMetaMaskStorageAndInstance();\n\n  const metaMaskClient =\n    await metaMaskClientInstanceManager.getMetaMaskClient();\n\n  if (announcedKey !== undefined) {\n    logger.warn(\n      `[MetaMask:Connect] Extension is announced for ${chain} as wallet provider \"${announcedKey}\"; proceeding with URI pairing anyway. Consider connectWithWalletProvider({ walletProviderKey: \"${announcedKey}\" }) for the best user experience.`\n    );\n  }\n\n  // eslint-disable-next-line custom-rules/require-single-object-param -- signature dictated by the SDK's `display_uri` event\n  const onDisplayUri = (displayUri: string) => {\n    logger.debug('[MetaMask:Connect] Received display_uri event', {\n      displayUri,\n    });\n\n    uriDeferred.resolve(displayUri);\n  };\n\n  metaMaskClientInstanceManager.events.on('display_uri', onDisplayUri);\n\n  logger.debug('[MetaMask:Connect] Requesting URI pairing', {\n    chain,\n    connectionScopes,\n  });\n\n  const connectPromise = metaMaskClient.connect(connectionScopes, []);\n\n  connectPromise\n    .then(() => {\n      uriDeferred.reject(new MetaMaskDisplayUriMissingError());\n    })\n    .catch((error: unknown) => {\n      uriDeferred.reject(error);\n    });\n\n  let uri: string;\n  try {\n    uri = await uriDeferred.promise;\n    logger.debug('[MetaMask:Connect] URI ready for display', { chain });\n  } finally {\n    metaMaskClientInstanceManager.events.off('display_uri', onDisplayUri);\n  }\n\n  const approval = async (): Promise<{ walletAccounts: WalletAccount[] }> => {\n    await connectPromise;\n    logger.debug('[MetaMask:Connect] Pairing approved', { chain });\n\n    const walletProvider = walletProviderBuilder(client);\n\n    // A chain extension (e.g. addMetaMaskEvmExtension) may have already\n    // registered a connect-less SDK placeholder under this same deterministic\n    // key at this same WALLET_SDK priority. register() only overwrites an\n    // existing key on a strictly higher priority, so registering directly\n    // here would silently no-op and leave the placeholder in place -- clear\n    // it first so the now-connected provider always takes its slot.\n    getWalletProviderRegistry(client).unregister(walletProvider.key);\n    getWalletProviderRegistry(client).register({\n      priority: WalletProviderPriority.WALLET_SDK,\n      walletProvider,\n    });\n\n    const { addresses } = await walletProvider.getConnectedAddresses();\n    logger.debug('[MetaMask:Connect] Connected addresses resolved', {\n      addresses,\n      chain,\n    });\n\n    // MetaMask SDK exposes a single active address per pairing (same model as\n    // EIP-1193 `eth_accounts`); we only materialize the first one.\n    const mainAddress = addresses[0];\n\n    if (mainAddress === undefined) {\n      throw new NoAddressFoundError();\n    }\n\n    const walletAccount: WalletAccount = {\n      address: mainAddress,\n      chain: walletProvider.chain,\n      id: formatWalletAccountId({\n        address: mainAddress,\n        chain: walletProvider.chain,\n        walletProviderKey: walletProvider.key,\n      }),\n      lastSelectedAt: null,\n      verifiedCredentialId: null,\n      walletProviderKey: walletProvider.key,\n    };\n\n    const walletAccounts = reconcileWalletAccountsAgainstClient(\n      {\n        addToDynamicWalletAccounts,\n        walletAccounts: [walletAccount],\n        walletProviderKey: walletProvider.key,\n      },\n      client\n    );\n\n    return { walletAccounts };\n  };\n  return { approval, uri };\n};\n","import { assertPackageVersion } from '@dynamic-labs-sdk/assert-package-version';\n\nimport { name, version } from '../../package.json';\n\nassertPackageVersion(name, version);\n\nexport { clearMetaMaskSessionStorage } from '../clearMetaMaskSessionStorage';\nexport { connectWithMetaMaskUri } from '../connectWithMetaMaskUri';\nexport type { ConnectWithMetaMaskUriParams } from '../connectWithMetaMaskUri';\nexport { MetaMaskDisplayUriMissingError } from '../errors/MetaMaskDisplayUriMissingError';\nexport { MetaMaskUnscopedNetworkError } from '../errors/MetaMaskUnscopedNetworkError';\nexport { getMetaMaskExtensionWalletProviderKey } from '../getMetaMaskExtensionWalletProviderKey';\nexport type { DisplayUriListener } from '../metamask.types';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,+BAEX,WACkB,qBAAqB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;ACJhD,IAAa,iCAAb,cAAoD,UAAU;CAC5D,cAAc;AACZ,QAAM;GACJ,OAAO;GACP,MAAM;GACN,SAAS;GACT,MAAM;GACN,cACE;GACH,CAAC;;;;;;ACzBN,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;AA+B7B,MAAa,yCACX,EAAE,SACF,SAAwB,kBAAkB,KACnB;AAYvB,QAXkB,0BAA0B,OAAO,CAAC,eAAe,CAE3C,MACrB,aACC,SAAS,UAAU,SACnB,SAAS,uBAAuB,mBAAmB,oBACnD,SAAS,SAAS,aACd,aAAa,CACd,SAAS,qBAAqB,CACpC,EAEa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACYhB,MAAa,yBAAyB,OACpC,EACE,6BAA6B,MAC7B,OACA,yBAEF,SAAwB,kBAAkB,KACK;CAC/C,MAAM,EAAE,WAAW,QAAQ,OAAO;CAClC,MAAM,eAAe,sCAAsC,EAAE,OAAO,EAAE,OAAO;CAC7E,MAAM,cAAc,uBAA+B;CACnD,MAAM,mBAAmB,kBAAkB,EAAE,OAAO,EAAE,OAAO;CAC7D,MAAM,gCACJ,yCAAyC,OAAO;AAElD,OAAM,8BAA8B,iCAAiC;CAErE,MAAM,iBACJ,MAAM,8BAA8B,mBAAmB;AAEzD,KAAI,iBAAiB,OACnB,QAAO,KACL,iDAAiD,MAAM,uBAAuB,aAAa,kGAAkG,aAAa,oCAC3M;CAIH,MAAM,gBAAgB,eAAuB;AAC3C,SAAO,MAAM,iDAAiD,EAC5D,YACD,CAAC;AAEF,cAAY,QAAQ,WAAW;;AAGjC,+BAA8B,OAAO,GAAG,eAAe,aAAa;AAEpE,QAAO,MAAM,6CAA6C;EACxD;EACA;EACD,CAAC;CAEF,MAAM,iBAAiB,eAAe,QAAQ,kBAAkB,EAAE,CAAC;AAEnE,gBACG,WAAW;AACV,cAAY,OAAO,IAAI,gCAAgC,CAAC;GACxD,CACD,OAAO,UAAmB;AACzB,cAAY,OAAO,MAAM;GACzB;CAEJ,IAAIA;AACJ,KAAI;AACF,QAAM,MAAM,YAAY;AACxB,SAAO,MAAM,4CAA4C,EAAE,OAAO,CAAC;WAC3D;AACR,gCAA8B,OAAO,IAAI,eAAe,aAAa;;CAGvE,MAAM,WAAW,YAA0D;AACzE,QAAM;AACN,SAAO,MAAM,uCAAuC,EAAE,OAAO,CAAC;EAE9D,MAAM,iBAAiB,sBAAsB,OAAO;AAQpD,4BAA0B,OAAO,CAAC,WAAW,eAAe,IAAI;AAChE,4BAA0B,OAAO,CAAC,SAAS;GACzC,UAAU,uBAAuB;GACjC;GACD,CAAC;EAEF,MAAM,EAAE,cAAc,MAAM,eAAe,uBAAuB;AAClE,SAAO,MAAM,mDAAmD;GAC9D;GACA;GACD,CAAC;EAIF,MAAM,cAAc,UAAU;AAE9B,MAAI,gBAAgB,OAClB,OAAM,IAAI,qBAAqB;AAyBjC,SAAO,EAAE,gBATc,qCACrB;GACE;GACA,gBAAgB,CAhBiB;IACnC,SAAS;IACT,OAAO,eAAe;IACtB,IAAI,sBAAsB;KACxB,SAAS;KACT,OAAO,eAAe;KACtB,mBAAmB,eAAe;KACnC,CAAC;IACF,gBAAgB;IAChB,sBAAsB;IACtB,mBAAmB,eAAe;IACnC,CAKkC;GAC/B,mBAAmB,eAAe;GACnC,EACD,OACD,EAEwB;;AAE3B,QAAO;EAAE;EAAU;EAAK;;;;;ACjL1B,qBAAqB,MAAM,QAAQ"}

package/dist/index.native.esm.js

@@ -1,50 +1,15 @@
+import { c as name, l as version, n as clearMetaMaskStorage, r as getMetaMaskScopes, s as MetaMaskUnscopedNetworkError, t as getOrCreateMetaMaskClientInstanceManager } from "./getOrCreateMetaMaskClientInstanceManager-Dz57S3Bm.native.esm.js";
 import { assertPackageVersion } from "@dynamic-labs-sdk/assert-package-version";
 import { WalletProviderPriority, createDeferredPromise, formatWalletAccountId, getCore, getDefaultClient, getWalletProviderRegistry, reconcileWalletAccountsAgainstClient } from "@dynamic-labs-sdk/client/core";
-import AsyncStorage from "@react-native-async-storage/async-storage";
 import { BaseError, NoAddressFoundError } from "@dynamic-labs-sdk/client";
 import { WalletProviderEnum } from "@dynamic-labs/sdk-api-core";
 
-//#region package.json
-var name = "@dynamic-labs-sdk/metamask";
-var version = "1.30.3";
-
-//#endregion
-//#region src/clearMetaMaskSessionStorage/clearMetaMaskSessionStorage.native.ts
-/**
-* Keys the MetaMask SDK writes verbatim (its RN store adapter applies no
-* namespace) that together make up a pairing. Deliberately excludes `anonId`,
-* `extensionId` and `DEBUG`: those are analytics and logger configuration, not
-* session state, and starting a new pairing is no reason to reset them.
-*/
-const METAMASK_SESSION_KEYS = new Set([
-	"cache_wallet_getSession",
-	"cache_eth_accounts",
-	"cache_eth_chainId",
-	"pending_session_request",
-	"multichain-transport",
-	"websocket-transport-client-id",
-	"sessions:master-list"
-]);
+//#region src/clearMetaMaskSessionStorage/clearMetaMaskSessionStorage.ts
 /**
-* Prefixes whose full keys embed a session id or relay channel, so they cannot
-* be named up front and have to be matched against the stored key list.
-*/
-const METAMASK_SESSION_KEY_PREFIXES = [
-	"session:",
-	"nonce:",
-	"latest-nonces:"
-];
-const FAILED_TO_CLEAR_SESSION_MESSAGE = "[metamask] failed to clear the persisted session from AsyncStorage; the next pairing may resume a stale session instead of showing a new one";
-/**
-* Deletes the MetaMask SDK's persisted pairing session from AsyncStorage, which
-* is where its React Native store adapter keeps it, so the next connect call
-* starts a fresh pairing and emits a `display_uri` instead of silently resuming
-* a session that no longer works.
+* Resets the MetaMask SDK's persisted session so the next connect call
+* emits a fresh `display_uri` instead of resuming a stale pairing.
 *
-* Call this only when a new pairing is actually being requested. The SDK's
-* mobile transport is built to resume a session across app launches, so wiping
-* it on startup would leave a user who is still connected unable to sign
-* without scanning again.
+* @deprecated The clearMetaMaskSessionStorage is not needed anymore since the SDK itself will handle the storage
 *
 * @example
 * ```ts
@@ -55,24 +20,36 @@ const FAILED_TO_CLEAR_SESSION_MESSAGE = "[metamask] failed to clear the persiste
 * @param client - The Dynamic client instance. Required (rather than
 * defaulting to the last-initialized client) so a storage-clear failure is
 * always logged against the client that actually requested it.
-* @returns A promise that resolves once the keys are removed. Never rejects — a
-* storage failure must not take down the connect flow that depends on it.
+* @returns A promise that resolves once the persisted session is reset.
 * @see connectWithMetaMaskUri
-* @see getMetaMaskExtensionWalletProviderKey
+* @see createMetaMaskClientInstanceManager
 * @notInstrumented
 */
-const clearMetaMaskSessionStorage = async (client) => {
-	try {
-		const keysToRemove = (await AsyncStorage.getAllKeys()).filter((key) => METAMASK_SESSION_KEYS.has(key) || METAMASK_SESSION_KEY_PREFIXES.some((prefix) => key.startsWith(prefix)));
-		if (keysToRemove.length === 0) return;
-		await AsyncStorage.multiRemove(keysToRemove);
-	} catch (error) {
-		getCore(client).logger.warn(FAILED_TO_CLEAR_SESSION_MESSAGE, error);
-	}
-};
+const clearMetaMaskSessionStorage = (client) => clearMetaMaskStorage(client);
 
 //#endregion
 //#region src/errors/MetaMaskDisplayUriMissingError/MetaMaskDisplayUriMissingError.ts
+/**
+* Thrown when the MetaMask SDK's `connect()` call settles (resolves or
+* rejects) without ever emitting a `display_uri` event. `connectWithMetaMaskUri`
+* requires that event to produce the pairing URI/QR code; without it, there
+* is nothing to render and the caller would otherwise hang indefinitely
+* awaiting a URI that will never arrive.
+*
+* @example
+* ```ts
+* try {
+*   await connectWithMetaMaskUri({ onDisplayUri }, client);
+* } catch (error) {
+*   if (error instanceof MetaMaskDisplayUriMissingError) {
+*     // The MetaMask SDK never produced a pairing URI; surface a generic
+*     // connection failure instead of hanging.
+*   }
+* }
+* ```
+* @see connectWithMetaMaskUri
+* @see MetaMaskUnscopedNetworkError
+*/
 var MetaMaskDisplayUriMissingError = class extends BaseError {
 	constructor() {
 		super({
@@ -109,7 +86,7 @@ const METAMASK_NAME_NEEDLE = "metamask";
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 * @returns The wallet provider key string, or `undefined` if no MetaMask extension is announced.
 * @see connectWithMetaMaskUri
-* @see clearMetaMaskSessionStorage
+* @see clearMetaMaskStorage
 * @notInstrumented
 */
 const getMetaMaskExtensionWalletProviderKey = ({ chain }, client = getDefaultClient()) => {
@@ -131,33 +108,41 @@ const getMetaMaskExtensionWalletProviderKey = ({ chain }, client = getDefaultCli
 * ```ts
 * const { uri, approval } = await connectWithMetaMaskUri({
 *   chain: 'EVM',
-*   getController: (client) => getEvmMetaMaskController(client),
 *   walletProviderBuilder: (client) => buildEvmWalletProvider(client),
 * });
 * // Render QR code with `uri`, then await approval()
 * ```
 *
 * @param params.chain - Chain being connected; used to scope the extension-installed lookup.
-* @param params.getController - Returns the chain-specific MetaMaskController for the pairing.
 * @param params.walletProviderBuilder - Builds the chain-specific WalletProvider after pairing approval.
 * @param [params.addToDynamicWalletAccounts] - Whether to add the wallet to the client. Defaults to `true`.
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 * @returns An object with `uri` (the pairing URI) and `approval` (async function resolving to wallet accounts).
 * @throws {MetaMaskDisplayUriMissingError} If `connect` settles before a display_uri is emitted.
 * @throws {NoAddressFoundError} If no address is returned after pairing approval.
-* @see clearMetaMaskSessionStorage
+* @see clearMetaMaskStorage
 * @see getMetaMaskExtensionWalletProviderKey
 * @notInstrumented
 */
-const connectWithMetaMaskUri = async ({ addToDynamicWalletAccounts = true, chain, getController, walletProviderBuilder }, client = getDefaultClient()) => {
+const connectWithMetaMaskUri = async ({ addToDynamicWalletAccounts = true, chain, walletProviderBuilder }, client = getDefaultClient()) => {
+	const { logger } = getCore(client);
 	const announcedKey = getMetaMaskExtensionWalletProviderKey({ chain }, client);
-	if (announcedKey !== void 0) getCore(client).logger.warn(`[metamask] MetaMask extension is announced for ${chain} as wallet provider "${announcedKey}"; proceeding with URI pairing. Consider connectWithWalletProvider({ walletProviderKey: "${announcedKey}" }) for the best user experience.`);
-	const controller = await getController(client);
 	const uriDeferred = createDeferredPromise();
-	const unsubscribe = controller.onDisplayUri((displayUri) => {
+	const connectionScopes = getMetaMaskScopes({ chain }, client);
+	const metaMaskClientInstanceManager = getOrCreateMetaMaskClientInstanceManager(client);
+	await metaMaskClientInstanceManager.clearMetaMaskStorageAndInstance();
+	const metaMaskClient = await metaMaskClientInstanceManager.getMetaMaskClient();
+	if (announcedKey !== void 0) logger.warn(`[MetaMask:Connect] Extension is announced for ${chain} as wallet provider "${announcedKey}"; proceeding with URI pairing anyway. Consider connectWithWalletProvider({ walletProviderKey: "${announcedKey}" }) for the best user experience.`);
+	const onDisplayUri = (displayUri) => {
+		logger.debug("[MetaMask:Connect] Received display_uri event", { displayUri });
 		uriDeferred.resolve(displayUri);
+	};
+	metaMaskClientInstanceManager.events.on("display_uri", onDisplayUri);
+	logger.debug("[MetaMask:Connect] Requesting URI pairing", {
+		chain,
+		connectionScopes
 	});
-	const connectPromise = controller.connect();
+	const connectPromise = metaMaskClient.connect(connectionScopes, []);
 	connectPromise.then(() => {
 		uriDeferred.reject(new MetaMaskDisplayUriMissingError());
 	}).catch((error) => {
@@ -166,17 +151,24 @@ const connectWithMetaMaskUri = async ({ addToDynamicWalletAccounts = true, chain
 	let uri;
 	try {
 		uri = await uriDeferred.promise;
+		logger.debug("[MetaMask:Connect] URI ready for display", { chain });
 	} finally {
-		unsubscribe();
+		metaMaskClientInstanceManager.events.off("display_uri", onDisplayUri);
 	}
 	const approval = async () => {
 		await connectPromise;
-		const walletProvider = await walletProviderBuilder(client);
+		logger.debug("[MetaMask:Connect] Pairing approved", { chain });
+		const walletProvider = walletProviderBuilder(client);
+		getWalletProviderRegistry(client).unregister(walletProvider.key);
 		getWalletProviderRegistry(client).register({
 			priority: WalletProviderPriority.WALLET_SDK,
 			walletProvider
 		});
 		const { addresses } = await walletProvider.getConnectedAddresses();
+		logger.debug("[MetaMask:Connect] Connected addresses resolved", {
+			addresses,
+			chain
+		});
 		const mainAddress = addresses[0];
 		if (mainAddress === void 0) throw new NoAddressFoundError();
 		return { walletAccounts: reconcileWalletAccountsAgainstClient({
@@ -202,24 +194,10 @@ const connectWithMetaMaskUri = async ({ addToDynamicWalletAccounts = true, chain
 	};
 };
 
-//#endregion
-//#region src/errors/MetaMaskWalletNotConnectedError/MetaMaskWalletNotConnectedError.ts
-var MetaMaskWalletNotConnectedError = class extends BaseError {
-	constructor() {
-		super({
-			cause: null,
-			code: "metamask_wallet_not_connected",
-			docsUrl: null,
-			name: "MetaMaskWalletNotConnectedError",
-			shortMessage: "MetaMask SDK has no connected wallet account. Complete the URI pairing (await the connect approval) before building the MetaMask wallet provider."
-		});
-	}
-};
-
 //#endregion
 //#region src/exports/index.ts
 assertPackageVersion(name, version);
 
 //#endregion
-export { MetaMaskDisplayUriMissingError, MetaMaskWalletNotConnectedError, clearMetaMaskSessionStorage, connectWithMetaMaskUri, getMetaMaskExtensionWalletProviderKey };
+export { MetaMaskDisplayUriMissingError, MetaMaskUnscopedNetworkError, clearMetaMaskSessionStorage, connectWithMetaMaskUri, getMetaMaskExtensionWalletProviderKey };
 //# sourceMappingURL=index.native.esm.js.map

package/dist/index.native.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.native.esm.js","names":["uri: string"],"sources":["../package.json","../src/clearMetaMaskSessionStorage/clearMetaMaskSessionStorage.native.ts","../src/errors/MetaMaskDisplayUriMissingError/MetaMaskDisplayUriMissingError.ts","../src/getMetaMaskExtensionWalletProviderKey/getMetaMaskExtensionWalletProviderKey.ts","../src/connectWithMetaMaskUri/connectWithMetaMaskUri.ts","../src/errors/MetaMaskWalletNotConnectedError/MetaMaskWalletNotConnectedError.ts","../src/exports/index.ts"],"sourcesContent":["","import type { DynamicClient } from '@dynamic-labs-sdk/client';\nimport { getCore } from '@dynamic-labs-sdk/client/core';\nimport AsyncStorage from '@react-native-async-storage/async-storage';\n\n/**\n * Keys the MetaMask SDK writes verbatim (its RN store adapter applies no\n * namespace) that together make up a pairing. Deliberately excludes `anonId`,\n * `extensionId` and `DEBUG`: those are analytics and logger configuration, not\n * session state, and starting a new pairing is no reason to reset them.\n */\nconst METAMASK_SESSION_KEYS = new Set([\n  // Cached `wallet_getSession` response — the CAIP session (accounts, scopes).\n  'cache_wallet_getSession',\n  'cache_eth_accounts',\n  'cache_eth_chainId',\n  // A `session_request` the wallet never answered, kept so the SDK can resume\n  // the pairing UI after the app was backgrounded mid-scan.\n  'pending_session_request',\n  // Which transport is active; this is what tells the SDK to resume on launch.\n  'multichain-transport',\n  'websocket-transport-client-id',\n  // Index of every `session:<id>` record, used to enumerate and GC them.\n  'sessions:master-list',\n]);\n\n/**\n * Prefixes whose full keys embed a session id or relay channel, so they cannot\n * be named up front and have to be matched against the stored key list.\n */\nconst METAMASK_SESSION_KEY_PREFIXES = ['session:', 'nonce:', 'latest-nonces:'];\n\nconst FAILED_TO_CLEAR_SESSION_MESSAGE =\n  '[metamask] failed to clear the persisted session from AsyncStorage; the next pairing may resume a stale session instead of showing a new one';\n\n/**\n * Deletes the MetaMask SDK's persisted pairing session from AsyncStorage, which\n * is where its React Native store adapter keeps it, so the next connect call\n * starts a fresh pairing and emits a `display_uri` instead of silently resuming\n * a session that no longer works.\n *\n * Call this only when a new pairing is actually being requested. The SDK's\n * mobile transport is built to resume a session across app launches, so wiping\n * it on startup would leave a user who is still connected unable to sign\n * without scanning again.\n *\n * @example\n * ```ts\n * await clearMetaMaskSessionStorage(client);\n * // Next connectWithMetaMaskUri call will emit a fresh URI immediately.\n * ```\n *\n * @param client - The Dynamic client instance. Required (rather than\n * defaulting to the last-initialized client) so a storage-clear failure is\n * always logged against the client that actually requested it.\n * @returns A promise that resolves once the keys are removed. Never rejects — a\n * storage failure must not take down the connect flow that depends on it.\n * @see connectWithMetaMaskUri\n * @see getMetaMaskExtensionWalletProviderKey\n * @notInstrumented\n */\nexport const clearMetaMaskSessionStorage = async (\n  // No default: avoids misattributing the failure-path warning below.\n  // eslint-disable-next-line custom-rules/check-dynamic-client-param-in-external-functions\n  client: DynamicClient\n): Promise<void> => {\n  try {\n    const storedKeys = await AsyncStorage.getAllKeys();\n\n    // Filtering the fixed names against what is actually stored keeps\n    // `multiRemove` off keys that were never written, and lets the no-op case\n    // skip the write entirely.\n    const keysToRemove = storedKeys.filter(\n      (key) =>\n        METAMASK_SESSION_KEYS.has(key) ||\n        METAMASK_SESSION_KEY_PREFIXES.some((prefix) => key.startsWith(prefix))\n    );\n\n    if (keysToRemove.length === 0) {\n      return;\n    }\n\n    await AsyncStorage.multiRemove(keysToRemove);\n  } catch (error) {\n    // Matches the web implementation in resolving anyway, so the caller's\n    // pairing attempt still proceeds. It is logged rather than dropped because\n    // a failure here puts the caller back on the stale session it was trying to\n    // escape, and this is the only trace of why.\n    //\n    getCore(client).logger.warn(FAILED_TO_CLEAR_SESSION_MESSAGE, error);\n  }\n};\n","import { BaseError } from '@dynamic-labs-sdk/client';\n\nexport class MetaMaskDisplayUriMissingError extends BaseError {\n  constructor() {\n    super({\n      cause: null,\n      code: 'metamask_display_uri_missing',\n      docsUrl: null,\n      name: 'MetaMaskDisplayUriMissingError',\n      shortMessage:\n        'MetaMask SDK completed the connection without emitting a display_uri. The connect helper requires the SDK to produce a pairing URI. Please reach out to Dynamic about this error.',\n    });\n  }\n}\n","import type { Chain, DynamicClient } from '@dynamic-labs-sdk/client';\nimport {\n  getDefaultClient,\n  getWalletProviderRegistry,\n} from '@dynamic-labs-sdk/client/core';\nimport { WalletProviderEnum } from '@dynamic-labs/sdk-api-core';\n\nconst METAMASK_NAME_NEEDLE = 'metamask';\n\ntype GetMetaMaskExtensionWalletProviderKeyParams = {\n  /** Chain to scope the lookup to. */\n  chain: Chain;\n};\n\n/**\n * Returns the wallet provider key of the MetaMask browser extension announced\n * for the given chain (EIP-6963 on EVM, Wallet Standard on Solana), or\n * `undefined` when none is announced. Matches on normalized display name to\n * cover MetaMask, Flask, and other variants. Synchronous and safe to call from\n * a React render. Pass the returned key to `connectWithWalletProvider` to route\n * the connection through the announced provider; fall back to the chain's\n * `connectWithMetaMaskUri<Chain>` helper when `undefined`.\n *\n * @example\n * ```ts\n * const key = getMetaMaskExtensionWalletProviderKey({ chain: 'EVM' });\n * if (key) {\n *   await connectWithWalletProvider({ walletProviderKey: key });\n * }\n * ```\n *\n * @param params.chain - Chain to scope the lookup to.\n * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.\n * @returns The wallet provider key string, or `undefined` if no MetaMask extension is announced.\n * @see connectWithMetaMaskUri\n * @see clearMetaMaskSessionStorage\n * @notInstrumented\n */\nexport const getMetaMaskExtensionWalletProviderKey = (\n  { chain }: GetMetaMaskExtensionWalletProviderKeyParams,\n  client: DynamicClient = getDefaultClient()\n): string | undefined => {\n  const providers = getWalletProviderRegistry(client).listProviders();\n\n  const match = providers.find(\n    (provider) =>\n      provider.chain === chain &&\n      provider.walletProviderType === WalletProviderEnum.BrowserExtension &&\n      provider.metadata.displayName\n        ?.toLowerCase()\n        .includes(METAMASK_NAME_NEEDLE)\n  );\n\n  return match?.key;\n};\n","import type {\n  Chain,\n  DynamicClient,\n  WalletAccount,\n  WalletProviderUriConnectionResult,\n} from '@dynamic-labs-sdk/client';\nimport { NoAddressFoundError } from '@dynamic-labs-sdk/client';\nimport type { WalletProvider } from '@dynamic-labs-sdk/client/core';\nimport {\n  WalletProviderPriority,\n  createDeferredPromise,\n  formatWalletAccountId,\n  getCore,\n  getDefaultClient,\n  getWalletProviderRegistry,\n  reconcileWalletAccountsAgainstClient,\n} from '@dynamic-labs-sdk/client/core';\n\nimport { MetaMaskDisplayUriMissingError } from '../errors/MetaMaskDisplayUriMissingError';\nimport { getMetaMaskExtensionWalletProviderKey } from '../getMetaMaskExtensionWalletProviderKey';\nimport type { MetaMaskController } from '../metamask.types';\n\nexport type ConnectWithMetaMaskUriParams = {\n  /** Whether to add the connected wallet account to the Dynamic client. Defaults to `true`. */\n  addToDynamicWalletAccounts?: boolean;\n  /** Chain being connected; used to scope the extension-installed lookup. */\n  chain: Chain;\n  /** Returns the chain-specific `MetaMaskController` that drives the pairing. */\n  getController: (client: DynamicClient) => Promise<MetaMaskController>;\n  /**\n   * Builds the chain-specific `WalletProvider` AFTER the pairing has been\n   * approved. Must NOT include a `connect` method — the provider is registered\n   * purely for signing routing and would otherwise leak into the wallet picker.\n   */\n  walletProviderBuilder: (client: DynamicClient) => Promise<WalletProvider>;\n};\n\n/**\n * Drives a MetaMask SDK pairing for any chain and returns `{ approval, uri }`\n * so consumers can render the QR / hand the URI to a deeplink. Logs an\n * advisory warning when the extension is already announced for the chain —\n * pairing still proceeds, but the consumer is told which announced provider\n * key to route through for the best UX. Builds and registers the chain-\n * specific wallet provider only after pairing is approved; the provider\n * therefore never appears in the wallet picker (no `connect` method).\n *\n * @example\n * ```ts\n * const { uri, approval } = await connectWithMetaMaskUri({\n *   chain: 'EVM',\n *   getController: (client) => getEvmMetaMaskController(client),\n *   walletProviderBuilder: (client) => buildEvmWalletProvider(client),\n * });\n * // Render QR code with `uri`, then await approval()\n * ```\n *\n * @param params.chain - Chain being connected; used to scope the extension-installed lookup.\n * @param params.getController - Returns the chain-specific MetaMaskController for the pairing.\n * @param params.walletProviderBuilder - Builds the chain-specific WalletProvider after pairing approval.\n * @param [params.addToDynamicWalletAccounts] - Whether to add the wallet to the client. Defaults to `true`.\n * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.\n * @returns An object with `uri` (the pairing URI) and `approval` (async function resolving to wallet accounts).\n * @throws {MetaMaskDisplayUriMissingError} If `connect` settles before a display_uri is emitted.\n * @throws {NoAddressFoundError} If no address is returned after pairing approval.\n * @see clearMetaMaskSessionStorage\n * @see getMetaMaskExtensionWalletProviderKey\n * @notInstrumented\n */\nexport const connectWithMetaMaskUri = async (\n  {\n    addToDynamicWalletAccounts = true,\n    chain,\n    getController,\n    walletProviderBuilder,\n  }: ConnectWithMetaMaskUriParams,\n  client: DynamicClient = getDefaultClient()\n): Promise<WalletProviderUriConnectionResult> => {\n  const announcedKey = getMetaMaskExtensionWalletProviderKey({ chain }, client);\n\n  if (announcedKey !== undefined) {\n    getCore(client).logger.warn(\n      `[metamask] MetaMask extension is announced for ${chain} as wallet provider \"${announcedKey}\"; proceeding with URI pairing. Consider connectWithWalletProvider({ walletProviderKey: \"${announcedKey}\" }) for the best user experience.`\n    );\n  }\n\n  const controller = await getController(client);\n\n  const uriDeferred = createDeferredPromise<string>();\n\n  const unsubscribe = controller.onDisplayUri((displayUri) => {\n    uriDeferred.resolve(displayUri);\n  });\n\n  const connectPromise = controller.connect();\n\n  // If `connect` settles before a `display_uri` is emitted, no URI was made\n  // available and the pairing is unusable. Reject the deferred so the caller\n  // surfaces `MetaMaskDisplayUriMissingError` (or the underlying failure).\n  connectPromise\n    .then(() => {\n      uriDeferred.reject(new MetaMaskDisplayUriMissingError());\n    })\n    .catch((error: unknown) => {\n      uriDeferred.reject(error);\n    });\n\n  let uri: string;\n  try {\n    uri = await uriDeferred.promise;\n  } finally {\n    unsubscribe();\n  }\n\n  const approval = async (): Promise<{ walletAccounts: WalletAccount[] }> => {\n    await connectPromise;\n\n    const walletProvider = await walletProviderBuilder(client);\n\n    getWalletProviderRegistry(client).register({\n      priority: WalletProviderPriority.WALLET_SDK,\n      walletProvider,\n    });\n\n    const { addresses } = await walletProvider.getConnectedAddresses();\n\n    // MetaMask SDK exposes a single active address per pairing (same model as\n    // EIP-1193 `eth_accounts`); we only materialize the first one.\n    const mainAddress = addresses[0];\n\n    if (mainAddress === undefined) {\n      throw new NoAddressFoundError();\n    }\n\n    const walletAccount: WalletAccount = {\n      address: mainAddress,\n      chain: walletProvider.chain,\n      id: formatWalletAccountId({\n        address: mainAddress,\n        chain: walletProvider.chain,\n        walletProviderKey: walletProvider.key,\n      }),\n      lastSelectedAt: null,\n      verifiedCredentialId: null,\n      walletProviderKey: walletProvider.key,\n    };\n\n    const walletAccounts = reconcileWalletAccountsAgainstClient(\n      {\n        addToDynamicWalletAccounts,\n        walletAccounts: [walletAccount],\n        walletProviderKey: walletProvider.key,\n      },\n      client\n    );\n\n    return { walletAccounts };\n  };\n\n  return { approval, uri };\n};\n","import { BaseError } from '@dynamic-labs-sdk/client';\n\nexport class MetaMaskWalletNotConnectedError extends BaseError {\n  constructor() {\n    super({\n      cause: null,\n      code: 'metamask_wallet_not_connected',\n      docsUrl: null,\n      name: 'MetaMaskWalletNotConnectedError',\n      shortMessage:\n        'MetaMask SDK has no connected wallet account. Complete the URI pairing (await the connect approval) before building the MetaMask wallet provider.',\n    });\n  }\n}\n","import { assertPackageVersion } from '@dynamic-labs-sdk/assert-package-version';\n\nimport { name, version } from '../../package.json';\n\nassertPackageVersion(name, version);\n\nexport { clearMetaMaskSessionStorage } from '../clearMetaMaskSessionStorage';\nexport { connectWithMetaMaskUri } from '../connectWithMetaMaskUri';\nexport type { ConnectWithMetaMaskUriParams } from '../connectWithMetaMaskUri';\nexport { MetaMaskDisplayUriMissingError } from '../errors/MetaMaskDisplayUriMissingError';\nexport { MetaMaskWalletNotConnectedError } from '../errors/MetaMaskWalletNotConnectedError';\nexport { getMetaMaskExtensionWalletProviderKey } from '../getMetaMaskExtensionWalletProviderKey';\nexport type {\n  DisplayUriListener,\n  MetaMaskController,\n} from '../metamask.types';\n"],"mappings":";;;;;;;;;;;;;;;;;;ACUA,MAAM,wBAAwB,IAAI,IAAI;CAEpC;CACA;CACA;CAGA;CAEA;CACA;CAEA;CACD,CAAC;;;;;AAMF,MAAM,gCAAgC;CAAC;CAAY;CAAU;CAAiB;AAE9E,MAAM,kCACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BF,MAAa,8BAA8B,OAGzC,WACkB;AAClB,KAAI;EAMF,MAAM,gBALa,MAAM,aAAa,YAAY,EAKlB,QAC7B,QACC,sBAAsB,IAAI,IAAI,IAC9B,8BAA8B,MAAM,WAAW,IAAI,WAAW,OAAO,CAAC,CACzE;AAED,MAAI,aAAa,WAAW,EAC1B;AAGF,QAAM,aAAa,YAAY,aAAa;UACrC,OAAO;AAMd,UAAQ,OAAO,CAAC,OAAO,KAAK,iCAAiC,MAAM;;;;;;ACtFvE,IAAa,iCAAb,cAAoD,UAAU;CAC5D,cAAc;AACZ,QAAM;GACJ,OAAO;GACP,MAAM;GACN,SAAS;GACT,MAAM;GACN,cACE;GACH,CAAC;;;;;;ACJN,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;AA+B7B,MAAa,yCACX,EAAE,SACF,SAAwB,kBAAkB,KACnB;AAYvB,QAXkB,0BAA0B,OAAO,CAAC,eAAe,CAE3C,MACrB,aACC,SAAS,UAAU,SACnB,SAAS,uBAAuB,mBAAmB,oBACnD,SAAS,SAAS,aACd,aAAa,CACd,SAAS,qBAAqB,CACpC,EAEa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACehB,MAAa,yBAAyB,OACpC,EACE,6BAA6B,MAC7B,OACA,eACA,yBAEF,SAAwB,kBAAkB,KACK;CAC/C,MAAM,eAAe,sCAAsC,EAAE,OAAO,EAAE,OAAO;AAE7E,KAAI,iBAAiB,OACnB,SAAQ,OAAO,CAAC,OAAO,KACrB,kDAAkD,MAAM,uBAAuB,aAAa,2FAA2F,aAAa,oCACrM;CAGH,MAAM,aAAa,MAAM,cAAc,OAAO;CAE9C,MAAM,cAAc,uBAA+B;CAEnD,MAAM,cAAc,WAAW,cAAc,eAAe;AAC1D,cAAY,QAAQ,WAAW;GAC/B;CAEF,MAAM,iBAAiB,WAAW,SAAS;AAK3C,gBACG,WAAW;AACV,cAAY,OAAO,IAAI,gCAAgC,CAAC;GACxD,CACD,OAAO,UAAmB;AACzB,cAAY,OAAO,MAAM;GACzB;CAEJ,IAAIA;AACJ,KAAI;AACF,QAAM,MAAM,YAAY;WAChB;AACR,eAAa;;CAGf,MAAM,WAAW,YAA0D;AACzE,QAAM;EAEN,MAAM,iBAAiB,MAAM,sBAAsB,OAAO;AAE1D,4BAA0B,OAAO,CAAC,SAAS;GACzC,UAAU,uBAAuB;GACjC;GACD,CAAC;EAEF,MAAM,EAAE,cAAc,MAAM,eAAe,uBAAuB;EAIlE,MAAM,cAAc,UAAU;AAE9B,MAAI,gBAAgB,OAClB,OAAM,IAAI,qBAAqB;AAyBjC,SAAO,EAAE,gBATc,qCACrB;GACE;GACA,gBAAgB,CAhBiB;IACnC,SAAS;IACT,OAAO,eAAe;IACtB,IAAI,sBAAsB;KACxB,SAAS;KACT,OAAO,eAAe;KACtB,mBAAmB,eAAe;KACnC,CAAC;IACF,gBAAgB;IAChB,sBAAsB;IACtB,mBAAmB,eAAe;IACnC,CAKkC;GAC/B,mBAAmB,eAAe;GACnC,EACD,OACD,EAEwB;;AAG3B,QAAO;EAAE;EAAU;EAAK;;;;;AC5J1B,IAAa,kCAAb,cAAqD,UAAU;CAC7D,cAAc;AACZ,QAAM;GACJ,OAAO;GACP,MAAM;GACN,SAAS;GACT,MAAM;GACN,cACE;GACH,CAAC;;;;;;ACPN,qBAAqB,MAAM,QAAQ"}
+{"version":3,"file":"index.native.esm.js","names":["uri: string"],"sources":["../src/clearMetaMaskSessionStorage/clearMetaMaskSessionStorage.ts","../src/errors/MetaMaskDisplayUriMissingError/MetaMaskDisplayUriMissingError.ts","../src/getMetaMaskExtensionWalletProviderKey/getMetaMaskExtensionWalletProviderKey.ts","../src/connectWithMetaMaskUri/connectWithMetaMaskUri.ts","../src/exports/index.ts"],"sourcesContent":["import type { DynamicClient } from '@dynamic-labs-sdk/client';\n\nimport { clearMetaMaskStorage } from '../metaMaskStorage/clearMetaMaskStorage';\n\n/**\n * Resets the MetaMask SDK's persisted session so the next connect call\n * emits a fresh `display_uri` instead of resuming a stale pairing.\n *\n * @deprecated The clearMetaMaskSessionStorage is not needed anymore since the SDK itself will handle the storage\n *\n * @example\n * ```ts\n * await clearMetaMaskSessionStorage(client);\n * // Next connectWithMetaMaskUri call will emit a fresh URI immediately.\n * ```\n *\n * @param client - The Dynamic client instance. Required (rather than\n * defaulting to the last-initialized client) so a storage-clear failure is\n * always logged against the client that actually requested it.\n * @returns A promise that resolves once the persisted session is reset.\n * @see connectWithMetaMaskUri\n * @see createMetaMaskClientInstanceManager\n * @notInstrumented\n */\nexport const clearMetaMaskSessionStorage = (\n  // eslint-disable-next-line custom-rules/check-dynamic-client-param-in-external-functions\n  client: DynamicClient\n): Promise<void> => clearMetaMaskStorage(client);\n","import { BaseError } from '@dynamic-labs-sdk/client';\n\n/**\n * Thrown when the MetaMask SDK's `connect()` call settles (resolves or\n * rejects) without ever emitting a `display_uri` event. `connectWithMetaMaskUri`\n * requires that event to produce the pairing URI/QR code; without it, there\n * is nothing to render and the caller would otherwise hang indefinitely\n * awaiting a URI that will never arrive.\n *\n * @example\n * ```ts\n * try {\n *   await connectWithMetaMaskUri({ onDisplayUri }, client);\n * } catch (error) {\n *   if (error instanceof MetaMaskDisplayUriMissingError) {\n *     // The MetaMask SDK never produced a pairing URI; surface a generic\n *     // connection failure instead of hanging.\n *   }\n * }\n * ```\n * @see connectWithMetaMaskUri\n * @see MetaMaskUnscopedNetworkError\n */\nexport class MetaMaskDisplayUriMissingError extends BaseError {\n  constructor() {\n    super({\n      cause: null,\n      code: 'metamask_display_uri_missing',\n      docsUrl: null,\n      name: 'MetaMaskDisplayUriMissingError',\n      shortMessage:\n        'MetaMask SDK completed the connection without emitting a display_uri. The connect helper requires the SDK to produce a pairing URI. Please reach out to Dynamic about this error.',\n    });\n  }\n}\n","import type { Chain, DynamicClient } from '@dynamic-labs-sdk/client';\nimport {\n  getDefaultClient,\n  getWalletProviderRegistry,\n} from '@dynamic-labs-sdk/client/core';\nimport { WalletProviderEnum } from '@dynamic-labs/sdk-api-core';\n\nconst METAMASK_NAME_NEEDLE = 'metamask';\n\ntype GetMetaMaskExtensionWalletProviderKeyParams = {\n  /** Chain to scope the lookup to. */\n  chain: Chain;\n};\n\n/**\n * Returns the wallet provider key of the MetaMask browser extension announced\n * for the given chain (EIP-6963 on EVM, Wallet Standard on Solana), or\n * `undefined` when none is announced. Matches on normalized display name to\n * cover MetaMask, Flask, and other variants. Synchronous and safe to call from\n * a React render. Pass the returned key to `connectWithWalletProvider` to route\n * the connection through the announced provider; fall back to the chain's\n * `connectWithMetaMaskUri<Chain>` helper when `undefined`.\n *\n * @example\n * ```ts\n * const key = getMetaMaskExtensionWalletProviderKey({ chain: 'EVM' });\n * if (key) {\n *   await connectWithWalletProvider({ walletProviderKey: key });\n * }\n * ```\n *\n * @param params.chain - Chain to scope the lookup to.\n * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.\n * @returns The wallet provider key string, or `undefined` if no MetaMask extension is announced.\n * @see connectWithMetaMaskUri\n * @see clearMetaMaskStorage\n * @notInstrumented\n */\nexport const getMetaMaskExtensionWalletProviderKey = (\n  { chain }: GetMetaMaskExtensionWalletProviderKeyParams,\n  client: DynamicClient = getDefaultClient()\n): string | undefined => {\n  const providers = getWalletProviderRegistry(client).listProviders();\n\n  const match = providers.find(\n    (provider) =>\n      provider.chain === chain &&\n      provider.walletProviderType === WalletProviderEnum.BrowserExtension &&\n      provider.metadata.displayName\n        ?.toLowerCase()\n        .includes(METAMASK_NAME_NEEDLE)\n  );\n\n  return match?.key;\n};\n","import type {\n  Chain,\n  DynamicClient,\n  WalletAccount,\n  WalletProviderUriConnectionResult,\n} from '@dynamic-labs-sdk/client';\nimport { NoAddressFoundError } from '@dynamic-labs-sdk/client';\nimport type { WalletProvider } from '@dynamic-labs-sdk/client/core';\nimport {\n  WalletProviderPriority,\n  createDeferredPromise,\n  formatWalletAccountId,\n  getCore,\n  getDefaultClient,\n  getWalletProviderRegistry,\n  reconcileWalletAccountsAgainstClient,\n} from '@dynamic-labs-sdk/client/core';\n\nimport { MetaMaskDisplayUriMissingError } from '../errors/MetaMaskDisplayUriMissingError';\nimport { getMetaMaskExtensionWalletProviderKey } from '../getMetaMaskExtensionWalletProviderKey';\nimport { getMetaMaskScopes } from '../getMetaMaskScopes';\nimport { getOrCreateMetaMaskClientInstanceManager } from '../metaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager';\n\nexport type ConnectWithMetaMaskUriParams = {\n  /** Whether to add the connected wallet account to the Dynamic client. Defaults to `true`. */\n  addToDynamicWalletAccounts?: boolean;\n  /** Chain being connected; used to scope the extension-installed lookup. */\n  chain: Chain;\n  /**\n   * Builds the chain-specific `WalletProvider` AFTER the pairing has been\n   * approved. Must NOT include a `connect` method — the provider is registered\n   * purely for signing routing and would otherwise leak into the wallet picker.\n   */\n  walletProviderBuilder: (client: DynamicClient) => WalletProvider;\n};\n\n/**\n * Drives a MetaMask SDK pairing for any chain and returns `{ approval, uri }`\n * so consumers can render the QR / hand the URI to a deeplink. Logs an\n * advisory warning when the extension is already announced for the chain —\n * pairing still proceeds, but the consumer is told which announced provider\n * key to route through for the best UX. Builds and registers the chain-\n * specific wallet provider only after pairing is approved; the provider\n * therefore never appears in the wallet picker (no `connect` method).\n *\n * @example\n * ```ts\n * const { uri, approval } = await connectWithMetaMaskUri({\n *   chain: 'EVM',\n *   walletProviderBuilder: (client) => buildEvmWalletProvider(client),\n * });\n * // Render QR code with `uri`, then await approval()\n * ```\n *\n * @param params.chain - Chain being connected; used to scope the extension-installed lookup.\n * @param params.walletProviderBuilder - Builds the chain-specific WalletProvider after pairing approval.\n * @param [params.addToDynamicWalletAccounts] - Whether to add the wallet to the client. Defaults to `true`.\n * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.\n * @returns An object with `uri` (the pairing URI) and `approval` (async function resolving to wallet accounts).\n * @throws {MetaMaskDisplayUriMissingError} If `connect` settles before a display_uri is emitted.\n * @throws {NoAddressFoundError} If no address is returned after pairing approval.\n * @see clearMetaMaskStorage\n * @see getMetaMaskExtensionWalletProviderKey\n * @notInstrumented\n */\nexport const connectWithMetaMaskUri = async (\n  {\n    addToDynamicWalletAccounts = true,\n    chain,\n    walletProviderBuilder,\n  }: ConnectWithMetaMaskUriParams,\n  client: DynamicClient = getDefaultClient()\n): Promise<WalletProviderUriConnectionResult> => {\n  const { logger } = getCore(client);\n  const announcedKey = getMetaMaskExtensionWalletProviderKey({ chain }, client);\n  const uriDeferred = createDeferredPromise<string>();\n  const connectionScopes = getMetaMaskScopes({ chain }, client);\n  const metaMaskClientInstanceManager =\n    getOrCreateMetaMaskClientInstanceManager(client);\n\n  await metaMaskClientInstanceManager.clearMetaMaskStorageAndInstance();\n\n  const metaMaskClient =\n    await metaMaskClientInstanceManager.getMetaMaskClient();\n\n  if (announcedKey !== undefined) {\n    logger.warn(\n      `[MetaMask:Connect] Extension is announced for ${chain} as wallet provider \"${announcedKey}\"; proceeding with URI pairing anyway. Consider connectWithWalletProvider({ walletProviderKey: \"${announcedKey}\" }) for the best user experience.`\n    );\n  }\n\n  // eslint-disable-next-line custom-rules/require-single-object-param -- signature dictated by the SDK's `display_uri` event\n  const onDisplayUri = (displayUri: string) => {\n    logger.debug('[MetaMask:Connect] Received display_uri event', {\n      displayUri,\n    });\n\n    uriDeferred.resolve(displayUri);\n  };\n\n  metaMaskClientInstanceManager.events.on('display_uri', onDisplayUri);\n\n  logger.debug('[MetaMask:Connect] Requesting URI pairing', {\n    chain,\n    connectionScopes,\n  });\n\n  const connectPromise = metaMaskClient.connect(connectionScopes, []);\n\n  connectPromise\n    .then(() => {\n      uriDeferred.reject(new MetaMaskDisplayUriMissingError());\n    })\n    .catch((error: unknown) => {\n      uriDeferred.reject(error);\n    });\n\n  let uri: string;\n  try {\n    uri = await uriDeferred.promise;\n    logger.debug('[MetaMask:Connect] URI ready for display', { chain });\n  } finally {\n    metaMaskClientInstanceManager.events.off('display_uri', onDisplayUri);\n  }\n\n  const approval = async (): Promise<{ walletAccounts: WalletAccount[] }> => {\n    await connectPromise;\n    logger.debug('[MetaMask:Connect] Pairing approved', { chain });\n\n    const walletProvider = walletProviderBuilder(client);\n\n    // A chain extension (e.g. addMetaMaskEvmExtension) may have already\n    // registered a connect-less SDK placeholder under this same deterministic\n    // key at this same WALLET_SDK priority. register() only overwrites an\n    // existing key on a strictly higher priority, so registering directly\n    // here would silently no-op and leave the placeholder in place -- clear\n    // it first so the now-connected provider always takes its slot.\n    getWalletProviderRegistry(client).unregister(walletProvider.key);\n    getWalletProviderRegistry(client).register({\n      priority: WalletProviderPriority.WALLET_SDK,\n      walletProvider,\n    });\n\n    const { addresses } = await walletProvider.getConnectedAddresses();\n    logger.debug('[MetaMask:Connect] Connected addresses resolved', {\n      addresses,\n      chain,\n    });\n\n    // MetaMask SDK exposes a single active address per pairing (same model as\n    // EIP-1193 `eth_accounts`); we only materialize the first one.\n    const mainAddress = addresses[0];\n\n    if (mainAddress === undefined) {\n      throw new NoAddressFoundError();\n    }\n\n    const walletAccount: WalletAccount = {\n      address: mainAddress,\n      chain: walletProvider.chain,\n      id: formatWalletAccountId({\n        address: mainAddress,\n        chain: walletProvider.chain,\n        walletProviderKey: walletProvider.key,\n      }),\n      lastSelectedAt: null,\n      verifiedCredentialId: null,\n      walletProviderKey: walletProvider.key,\n    };\n\n    const walletAccounts = reconcileWalletAccountsAgainstClient(\n      {\n        addToDynamicWalletAccounts,\n        walletAccounts: [walletAccount],\n        walletProviderKey: walletProvider.key,\n      },\n      client\n    );\n\n    return { walletAccounts };\n  };\n  return { approval, uri };\n};\n","import { assertPackageVersion } from '@dynamic-labs-sdk/assert-package-version';\n\nimport { name, version } from '../../package.json';\n\nassertPackageVersion(name, version);\n\nexport { clearMetaMaskSessionStorage } from '../clearMetaMaskSessionStorage';\nexport { connectWithMetaMaskUri } from '../connectWithMetaMaskUri';\nexport type { ConnectWithMetaMaskUriParams } from '../connectWithMetaMaskUri';\nexport { MetaMaskDisplayUriMissingError } from '../errors/MetaMaskDisplayUriMissingError';\nexport { MetaMaskUnscopedNetworkError } from '../errors/MetaMaskUnscopedNetworkError';\nexport { getMetaMaskExtensionWalletProviderKey } from '../getMetaMaskExtensionWalletProviderKey';\nexport type { DisplayUriListener } from '../metamask.types';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,+BAEX,WACkB,qBAAqB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;ACJhD,IAAa,iCAAb,cAAoD,UAAU;CAC5D,cAAc;AACZ,QAAM;GACJ,OAAO;GACP,MAAM;GACN,SAAS;GACT,MAAM;GACN,cACE;GACH,CAAC;;;;;;ACzBN,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;AA+B7B,MAAa,yCACX,EAAE,SACF,SAAwB,kBAAkB,KACnB;AAYvB,QAXkB,0BAA0B,OAAO,CAAC,eAAe,CAE3C,MACrB,aACC,SAAS,UAAU,SACnB,SAAS,uBAAuB,mBAAmB,oBACnD,SAAS,SAAS,aACd,aAAa,CACd,SAAS,qBAAqB,CACpC,EAEa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACYhB,MAAa,yBAAyB,OACpC,EACE,6BAA6B,MAC7B,OACA,yBAEF,SAAwB,kBAAkB,KACK;CAC/C,MAAM,EAAE,WAAW,QAAQ,OAAO;CAClC,MAAM,eAAe,sCAAsC,EAAE,OAAO,EAAE,OAAO;CAC7E,MAAM,cAAc,uBAA+B;CACnD,MAAM,mBAAmB,kBAAkB,EAAE,OAAO,EAAE,OAAO;CAC7D,MAAM,gCACJ,yCAAyC,OAAO;AAElD,OAAM,8BAA8B,iCAAiC;CAErE,MAAM,iBACJ,MAAM,8BAA8B,mBAAmB;AAEzD,KAAI,iBAAiB,OACnB,QAAO,KACL,iDAAiD,MAAM,uBAAuB,aAAa,kGAAkG,aAAa,oCAC3M;CAIH,MAAM,gBAAgB,eAAuB;AAC3C,SAAO,MAAM,iDAAiD,EAC5D,YACD,CAAC;AAEF,cAAY,QAAQ,WAAW;;AAGjC,+BAA8B,OAAO,GAAG,eAAe,aAAa;AAEpE,QAAO,MAAM,6CAA6C;EACxD;EACA;EACD,CAAC;CAEF,MAAM,iBAAiB,eAAe,QAAQ,kBAAkB,EAAE,CAAC;AAEnE,gBACG,WAAW;AACV,cAAY,OAAO,IAAI,gCAAgC,CAAC;GACxD,CACD,OAAO,UAAmB;AACzB,cAAY,OAAO,MAAM;GACzB;CAEJ,IAAIA;AACJ,KAAI;AACF,QAAM,MAAM,YAAY;AACxB,SAAO,MAAM,4CAA4C,EAAE,OAAO,CAAC;WAC3D;AACR,gCAA8B,OAAO,IAAI,eAAe,aAAa;;CAGvE,MAAM,WAAW,YAA0D;AACzE,QAAM;AACN,SAAO,MAAM,uCAAuC,EAAE,OAAO,CAAC;EAE9D,MAAM,iBAAiB,sBAAsB,OAAO;AAQpD,4BAA0B,OAAO,CAAC,WAAW,eAAe,IAAI;AAChE,4BAA0B,OAAO,CAAC,SAAS;GACzC,UAAU,uBAAuB;GACjC;GACD,CAAC;EAEF,MAAM,EAAE,cAAc,MAAM,eAAe,uBAAuB;AAClE,SAAO,MAAM,mDAAmD;GAC9D;GACA;GACD,CAAC;EAIF,MAAM,cAAc,UAAU;AAE9B,MAAI,gBAAgB,OAClB,OAAM,IAAI,qBAAqB;AAyBjC,SAAO,EAAE,gBATc,qCACrB;GACE;GACA,gBAAgB,CAhBiB;IACnC,SAAS;IACT,OAAO,eAAe;IACtB,IAAI,sBAAsB;KACxB,SAAS;KACT,OAAO,eAAe;KACtB,mBAAmB,eAAe;KACnC,CAAC;IACF,gBAAgB;IAChB,sBAAsB;IACtB,mBAAmB,eAAe;IACnC,CAKkC;GAC/B,mBAAmB,eAAe;GACnC,EACD,OACD,EAEwB;;AAE3B,QAAO;EAAE;EAAU;EAAK;;;;;ACjL1B,qBAAqB,MAAM,QAAQ"}

package/dist/metaMaskClientInstanceManager/createMetaMaskClientInstanceManager/createMetaMaskClientInstanceManager.d.ts

@@ -0,0 +1,45 @@
+import type { DynamicClient } from '@dynamic-labs-sdk/client';
+import { type EventEmitter } from '@dynamic-labs-sdk/client/core';
+import type { MultichainCore } from '@metamask/connect-multichain';
+/**
+ * Events a `MetaMaskClientInstanceManager` forwards from the underlying
+ * `@metamask/connect-multichain` client, for callers that don't hold a
+ * reference to the raw SDK client.
+ */
+export type MetaMaskClientEvents = {
+    display_uri: (evt: string) => void;
+};
+/**
+ * The per-client handle returned by `createMetaMaskClientInstanceManager`.
+ */
+export type MetaMaskClientInstanceManager = {
+    /** Wipes persisted MetaMask storage and forces the next build to start fresh. */
+    clearMetaMaskStorageAndInstance: () => Promise<void>;
+    /** Emits `MetaMaskClientEvents` forwarded from the underlying SDK client. */
+    events: EventEmitter<MetaMaskClientEvents>;
+    /** Resolves the shared `MultichainCore` client, building it on first access. */
+    getMetaMaskClient(): Promise<MultichainCore>;
+};
+/**
+ * Creates the per-client manager that lazily builds, tears down, and rebuilds
+ * the shared `@metamask/connect-multichain` client instance, and forwards its
+ * `display_uri` event to callers that don't hold a reference to the raw SDK
+ * client.
+ *
+ * @example
+ * ```ts
+ * const manager = createMetaMaskClientInstanceManager(client);
+ * const metaMaskClient = await manager.getMetaMaskClient();
+ * ```
+ *
+ * @returns A `MetaMaskClientInstanceManager` scoped to `client`.
+ * @throws {MetaMaskClientNotInitializedError} From `getMetaMaskClient` if a
+ * build was never started -- a defensive guard, since `refreshMetaMaskClient`
+ * always starts one. A build that starts but fails instead rejects
+ * `getMetaMaskClient()` with its original error.
+ * @see createMetaMaskStorageClient
+ * @see clearMetaMaskStorage
+ * @notInstrumented
+ */
+export declare const createMetaMaskClientInstanceManager: (client: DynamicClient) => MetaMaskClientInstanceManager;
+//# sourceMappingURL=createMetaMaskClientInstanceManager.d.ts.map

package/dist/metaMaskClientInstanceManager/createMetaMaskClientInstanceManager/createMetaMaskClientInstanceManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMetaMaskClientInstanceManager.d.ts","sourceRoot":"","sources":["../../../src/metaMaskClientInstanceManager/createMetaMaskClientInstanceManager/createMetaMaskClientInstanceManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EACL,KAAK,YAAY,EAKlB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAUnE;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,6BAA6B,GAAG;IAC1C,iFAAiF;IACjF,+BAA+B,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,6EAA6E;IAC7E,MAAM,EAAE,YAAY,CAAC,oBAAoB,CAAC,CAAC;IAC3C,gFAAgF;IAChF,iBAAiB,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC;CAC9C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,mCAAmC,WACtC,aAAa,KACpB,6BA+HF,CAAC"}

package/dist/metaMaskClientInstanceManager/createMetaMaskClientInstanceManager/index.d.ts

@@ -0,0 +1,2 @@
+export { createMetaMaskClientInstanceManager } from './createMetaMaskClientInstanceManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/metaMaskClientInstanceManager/createMetaMaskClientInstanceManager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/metaMaskClientInstanceManager/createMetaMaskClientInstanceManager/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mCAAmC,EAAE,MAAM,uCAAuC,CAAC"}

package/dist/metaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns this client's `MetaMaskClientInstanceManager`, creating it on first
+ * access. Every chain's MetaMask wallet provider (EVM, Solana, ...) calls
+ * this to reach the SAME manager -- and therefore the same shared multichain
+ * session -- rather than each building its own.
+ *
+ * @example
+ * ```ts
+ * const manager = getOrCreateMetaMaskClientInstanceManager(client);
+ * const metaMaskClient = await manager.getMetaMaskClient();
+ * ```
+ * @param client - The Dynamic client instance.
+ * @returns The client's `MetaMaskClientInstanceManager`.
+ * @see createMetaMaskClientInstanceManager
+ * @see disconnectMetaMaskWalletProvider
+ */
+export declare const getOrCreateMetaMaskClientInstanceManager: (client: import("@dynamic-labs-sdk/client").DynamicClient) => import("../createMetaMaskClientInstanceManager/createMetaMaskClientInstanceManager").MetaMaskClientInstanceManager;
+//# sourceMappingURL=getOrCreateMetaMaskClientInstanceManager.d.ts.map

package/dist/metaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOrCreateMetaMaskClientInstanceManager.d.ts","sourceRoot":"","sources":["../../../src/metaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wCAAwC,kLAIlD,CAAC"}

package/dist/metaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager/index.d.ts

@@ -0,0 +1,2 @@
+export { getOrCreateMetaMaskClientInstanceManager } from './getOrCreateMetaMaskClientInstanceManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/metaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/metaMaskClientInstanceManager/getOrCreateMetaMaskClientInstanceManager/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wCAAwC,EAAE,MAAM,4CAA4C,CAAC"}

package/dist/metaMaskStorage/clearMetaMaskStorage/clearMetaMaskStorage.d.ts

@@ -0,0 +1,23 @@
+import type { DynamicClient } from '@dynamic-labs-sdk/client';
+/**
+ * Resets the MetaMask SDK's persisted store blob back to its initial
+ * (empty) value, so the next connect call starts a fresh pairing and emits a
+ * `display_uri` instead of silently resuming a session that no longer works.
+ *
+ * @example
+ * ```ts
+ * await clearMetaMaskStorage(client);
+ * // Next connectWithMetaMaskUri call will emit a fresh URI immediately.
+ * ```
+ *
+ * @param client - The Dynamic client instance. Required (rather than
+ * defaulting to the last-initialized client) so a storage-clear failure is
+ * always logged against the client that actually requested it.
+ * @returns A promise that resolves once the blob is reset. Never rejects -- a
+ * storage failure must not take down the connect flow that depends on it.
+ * @see connectWithMetaMaskUri
+ * @see createMetaMaskStorageClient
+ * @notInstrumented
+ */
+export declare const clearMetaMaskStorage: (client: DynamicClient) => Promise<void>;
+//# sourceMappingURL=clearMetaMaskStorage.d.ts.map

package/dist/metaMaskStorage/clearMetaMaskStorage/clearMetaMaskStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clearMetaMaskStorage.d.ts","sourceRoot":"","sources":["../../../src/metaMaskStorage/clearMetaMaskStorage/clearMetaMaskStorage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAS9D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB,WACvB,aAAa,KACpB,OAAO,CAAC,IAAI,CAiBd,CAAC"}

package/dist/metaMaskStorage/clearMetaMaskStorage/index.d.ts

@@ -0,0 +1,2 @@
+export { clearMetaMaskStorage } from './clearMetaMaskStorage';
+//# sourceMappingURL=index.d.ts.map

package/dist/metaMaskStorage/clearMetaMaskStorage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/metaMaskStorage/clearMetaMaskStorage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/metaMaskStorage/createInitialMetaMaskStoreValue/createInitialMetaMaskStoreValue.d.ts

@@ -0,0 +1,19 @@
+import type { MetaMaskStoreValue } from '../metaMaskStorage.schema';
+/**
+ * Builds the persisted store blob's value for when there is nothing stored
+ * yet, or after a clear. A function rather than a shared constant, so every
+ * caller gets its own object and can't mutate a value other callers rely on.
+ *
+ * @example
+ * ```ts
+ * const initial = createInitialMetaMaskStoreValue();
+ * // { entries: {}, schemaVersion: 1 }
+ * ```
+ *
+ * @returns A fresh, empty `MetaMaskStoreValue`.
+ * @see createMetaMaskStorageClient
+ * @see clearMetaMaskStorage
+ * @notInstrumented
+ */
+export declare const createInitialMetaMaskStoreValue: () => MetaMaskStoreValue;
+//# sourceMappingURL=createInitialMetaMaskStoreValue.d.ts.map

package/dist/metaMaskStorage/createInitialMetaMaskStoreValue/createInitialMetaMaskStoreValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createInitialMetaMaskStoreValue.d.ts","sourceRoot":"","sources":["../../../src/metaMaskStorage/createInitialMetaMaskStoreValue/createInitialMetaMaskStoreValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,QAAO,kBAGjD,CAAC"}

package/dist/metaMaskStorage/createMetaMaskStorageClient/createMetaMaskStorageClient.d.ts

@@ -0,0 +1,30 @@
+import type { StoreClient } from '@metamask/connect-multichain';
+import type { DynamicClient } from '@dynamic-labs-sdk/client';
+/**
+ * Builds a storage-service-backed store for the MetaMask multichain client,
+ * in place of its own default web adapter (IndexedDB) and React Native
+ * adapter (raw `AsyncStorage`), so every platform persists through the same
+ * core `Storage` service and `clearMetaMaskStorage` can reliably wipe it.
+ *
+ * The SDK controls every key name it reads/writes through `adapter`,
+ * including ones that embed an unpredictable id (`session:<id>`), so every
+ * key it uses is folded into a single stored blob (`metaMaskStoreStorageKeySchema`)
+ * rather than one storage key per SDK key. `DEBUG` is never persisted at all,
+ * answered live from the client's own logger.
+ *
+ * @example
+ * ```ts
+ * const storeClient = createMetaMaskStorageClient(client);
+ * const multichainClient = createMultichainClient({ storage: storeClient });
+ * ```
+ *
+ * @returns A `StoreClient` backed by the client's core `Storage` service.
+ * @throws {MetaMaskStorageError} If the underlying `Storage` service's
+ * `getItem`/`setItem` calls fail for any of the adapter's read/write/delete
+ * operations.
+ * @see createInitialMetaMaskStoreValue
+ * @see clearMetaMaskStorage
+ * @notInstrumented
+ */
+export declare const createMetaMaskStorageClient: (client: DynamicClient) => StoreClient;
+//# sourceMappingURL=createMetaMaskStorageClient.d.ts.map

package/dist/metaMaskStorage/createMetaMaskStorageClient/createMetaMaskStorageClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMetaMaskStorageClient.d.ts","sourceRoot":"","sources":["../../../src/metaMaskStorage/createMetaMaskStorageClient/createMetaMaskStorageClient.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAgB,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAE9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAe9D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,2BAA2B,WAAY,aAAa,KAAG,WA6GnE,CAAC"}

package/dist/metaMaskStorage/createMetaMaskStorageClient/index.d.ts

@@ -0,0 +1,2 @@
+export { createMetaMaskStorageClient } from './createMetaMaskStorageClient';
+//# sourceMappingURL=index.d.ts.map

package/dist/metaMaskStorage/createMetaMaskStorageClient/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/metaMaskStorage/createMetaMaskStorageClient/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/metaMaskStorage/metaMaskStorage.schema.d.ts

@@ -0,0 +1,30 @@
+import * as z from 'zod/mini';
+/**
+ * Single storage key holding every value the MetaMask multichain SDK writes
+ * through our `StoreAdapter` (sessions, nonces, cached accounts/chain,
+ * pending pairing requests, transport ids, ...), keyed by whatever key string
+ * the SDK itself hands us -- the SDK controls every key name, including ones
+ * that embed an unpredictable id (`session:<id>`), so this can't be split
+ * into one storage key per SDK key.
+ *
+ * `entries[ANON_ID_ENTRY_KEY]` also lives in here, alongside `extensionId`
+ * and the other transport keys.
+ *
+ * `clearMetaMaskStorage` resets this key back to its initial value; nothing
+ * else needs to know the individual key names the SDK is using.
+ */
+export declare const metaMaskStoreStorageKeySchema: import("@dynamic-labs-sdk/client/core").StorageKeySchema<{
+    entries: Record<string, string>;
+    schemaVersion: 1;
+}>;
+/**
+ * The persisted store blob's shape. Exported here because it is shared by
+ * every function operating on this storage key.
+ */
+export type MetaMaskStoreValue = z.infer<typeof metaMaskStoreStorageKeySchema.schema>;
+/**
+ * Reserved `entries` key the MetaMask SDK itself never writes to, used to
+ * carry the SDK's anonymous analytics id inside the same store blob.
+ */
+export declare const ANON_ID_ENTRY_KEY = "anonId";
+//# sourceMappingURL=metaMaskStorage.schema.d.ts.map

package/dist/metaMaskStorage/metaMaskStorage.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metaMaskStorage.schema.d.ts","sourceRoot":"","sources":["../../src/metaMaskStorage/metaMaskStorage.schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAG9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,6BAA6B;;;EAMxC,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,MAAM,CAAC,CAAC;AAEtF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,WAAW,CAAC"}

package/dist/metaMaskStorage/queueMetaMaskStorageWrite/queueMetaMaskStorageWrite.d.ts

@@ -0,0 +1,20 @@
+import type { SequenceQueue } from '@dynamic-labs-sdk/client/core';
+/**
+ * Single shared queue serializing every read-modify-write against
+ * `metaMaskStoreStorageKeySchema` -- `createMetaMaskStorageClient`'s adapter
+ * reads/writes/anonId operations and `clearMetaMaskStorage`'s reset all go
+ * through this same instance, so a write that started before a clear can't
+ * land after it and resurrect the data the clear was meant to erase.
+ *
+ * @example
+ * ```ts
+ * await queueMetaMaskStorageWrite(() => storage.setItem(key, value), client);
+ * ```
+ *
+ * @returns A `SequenceQueue` that runs one queued task at a time, in order.
+ * @see createMetaMaskStorageClient
+ * @see clearMetaMaskStorage
+ * @notInstrumented
+ */
+export declare const queueMetaMaskStorageWrite: SequenceQueue;
+//# sourceMappingURL=queueMetaMaskStorageWrite.d.ts.map