@dynamic-labs-sdk/metamask 1.31.0 → 1.31.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"queueMetaMaskStorageWrite.d.ts","sourceRoot":"","sources":["../../../src/metaMaskStorage/queueMetaMaskStorageWrite/queueMetaMaskStorageWrite.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,yBAAyB,EAAE,aAAqC,CAAC"}

package/dist/metamask.types.d.ts

@@ -1,23 +1,3 @@
 /** Listener invoked with each MetaMask SDK pairing `display_uri` emission. */
 export type DisplayUriListener = (uri: string) => void;
-/**
- * Chain-agnostic surface chain-specific packages adapt their MetaMask SDK
- * instance to (e.g. `@metamask/connect-evm`, `@metamask/connect-solana`).
- * Owns the SDK pairing drive (`connect`) and the cached-`display_uri`
- * bookkeeping (`onDisplayUri` / `getLatestDisplayUri` / `clearCachedDisplayUri`).
- */
-export type MetaMaskController = {
-    /** Drops the cached `display_uri` value without touching the SDK. */
-    clearCachedDisplayUri: () => void;
-    /**
-     * Drives the SDK pairing. Implementations should clear any stale
-     * "connecting" state on the underlying SDK first. Resolves once the
-     * pairing is approved by the wallet; rejects on rejection / timeout.
-     */
-    connect: () => Promise<void>;
-    /** Returns the latest URI captured by the SDK's `displayUri` handler, or `undefined`. */
-    getLatestDisplayUri: () => string | undefined;
-    /** Subscribes to `display_uri` emissions and replays the latest cached URI. Returns an unsubscribe. */
-    onDisplayUri: (listener: DisplayUriListener) => () => void;
-};
 //# sourceMappingURL=metamask.types.d.ts.map

package/dist/metamask.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metamask.types.d.ts","sourceRoot":"","sources":["../src/metamask.types.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,MAAM,MAAM,kBAAkB,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,qEAAqE;IACrE,qBAAqB,EAAE,MAAM,IAAI,CAAC;IAClC;;;;OAIG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,yFAAyF;IACzF,mBAAmB,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAC9C,uGAAuG;IACvG,YAAY,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,MAAM,IAAI,CAAC;CAC5D,CAAC"}
+{"version":3,"file":"metamask.types.d.ts","sourceRoot":"","sources":["../src/metamask.types.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,MAAM,MAAM,kBAAkB,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC"}

package/dist/reconcileMetaMaskWalletProvider/index.d.ts

@@ -0,0 +1,3 @@
+export { reconcileMetaMaskWalletProvider } from './reconcileMetaMaskWalletProvider';
+export type { ReconcileMetaMaskWalletProviderParams } from './reconcileMetaMaskWalletProvider';
+//# sourceMappingURL=index.d.ts.map

package/dist/reconcileMetaMaskWalletProvider/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reconcileMetaMaskWalletProvider/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AACpF,YAAY,EAAE,qCAAqC,EAAE,MAAM,mCAAmC,CAAC"}

package/dist/reconcileMetaMaskWalletProvider/reconcileMetaMaskWalletProvider.d.ts

@@ -0,0 +1,60 @@
+import type { DynamicClient } from '@dynamic-labs-sdk/client';
+import type { WalletProvider } from '@dynamic-labs-sdk/client/core';
+/**
+ * Params for {@link reconcileMetaMaskWalletProvider}.
+ *
+ * @example
+ * ```ts
+ * const params: ReconcileMetaMaskWalletProviderParams = {
+ *   walletProviderBuilder: createMetaMaskEvmWalletProvider,
+ *   walletProviderKey: getMetaMaskEvmSdkWalletProviderKey(),
+ * };
+ * ```
+ * @see reconcileMetaMaskWalletProvider
+ * @see WalletProvider
+ */
+export type ReconcileMetaMaskWalletProviderParams = {
+    /**
+     * Builds the connect-less SDK placeholder wallet provider (e.g.
+     * `createMetaMaskEvmWalletProvider`). Only invoked once reconciliation
+     * determines the placeholder must actually be registered, so a chain
+     * extension never builds it just for being added.
+     */
+    walletProviderBuilder: (client: DynamicClient) => WalletProvider;
+    /**
+     * The placeholder's deterministic wallet provider key, computed without
+     * building it (e.g. `getMetaMaskEvmSdkWalletProviderKey`).
+     */
+    walletProviderKey: string;
+};
+/**
+ * Keeps a chain's MetaMask SDK wallet provider registered for as
+ * long as the user has a wallet account under its exact key, and
+ * unregisters it once that wallet account disappears (e.g. on disconnect).
+ * This is needed because always adding the MetaMask SDK wallet provider
+ * would conflict with the browser extension wallet provider, so we only add
+ * it once the user has a wallet account that was connected via QR code.
+ * The placeholder is only built (via `walletProviderBuilder`) the first time
+ * it must be registered, mirroring how WalletConnect only builds a wallet
+ * provider for a session that actually exists.
+ *
+ * @example
+ * ```ts
+ * reconcileMetaMaskWalletProvider(
+ *   {
+ *     walletProviderBuilder: createMetaMaskEvmWalletProvider,
+ *     walletProviderKey: getMetaMaskEvmSdkWalletProviderKey(),
+ *   },
+ *   client
+ * );
+ * ```
+ * @param params.walletProviderBuilder - Builds the SDK placeholder wallet provider once it must be registered.
+ * @param params.walletProviderKey - The placeholder's deterministic wallet provider key.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns void
+ * @see connectWithMetaMaskUri
+ * @see WalletProviderPriority
+ * @notInstrumented
+ */
+export declare const reconcileMetaMaskWalletProvider: ({ walletProviderBuilder, walletProviderKey }: ReconcileMetaMaskWalletProviderParams, client?: DynamicClient) => void;
+//# sourceMappingURL=reconcileMetaMaskWalletProvider.d.ts.map

package/dist/reconcileMetaMaskWalletProvider/reconcileMetaMaskWalletProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcileMetaMaskWalletProvider.d.ts","sourceRoot":"","sources":["../../src/reconcileMetaMaskWalletProvider/reconcileMetaMaskWalletProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAOpE;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,qCAAqC,GAAG;IAClD;;;;;OAKG;IACH,qBAAqB,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,cAAc,CAAC;IACjE;;;OAGG;IACH,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,+BAA+B,iDACI,qCAAqC,WAC3E,aAAa,KACpB,IA6BF,CAAC"}

package/dist/resolveActiveMetaMaskScope/index.d.ts

@@ -0,0 +1,3 @@
+export { resolveActiveMetaMaskScope } from './resolveActiveMetaMaskScope';
+export type { ResolveActiveMetaMaskScopeResult } from './resolveActiveMetaMaskScope';
+//# sourceMappingURL=index.d.ts.map

package/dist/resolveActiveMetaMaskScope/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolveActiveMetaMaskScope/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC1E,YAAY,EAAE,gCAAgC,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/resolveActiveMetaMaskScope/resolveActiveMetaMaskScope.d.ts

@@ -0,0 +1,67 @@
+import type { Chain, DynamicClient } from '@dynamic-labs-sdk/client';
+import type { MultichainCore } from '@metamask/connect-multichain';
+export type ResolveActiveMetaMaskScopeParams = {
+    chain: Chain;
+    metaMaskClient: MultichainCore;
+    walletProviderKey: string;
+};
+/**
+ * The network resolved as active for a MetaMask wallet provider, and the
+ * CAIP-10 accounts MetaMask granted for it -- returned by
+ * `resolveActiveMetaMaskScope` so callers don't need to re-derive the scope
+ * or re-read the session themselves.
+ *
+ * @example
+ * ```ts
+ * const { accounts, networkId } = await resolveActiveMetaMaskScope(
+ *   { chain: 'SOL', metaMaskClient, walletProviderKey },
+ *   client
+ * );
+ * ```
+ * @see resolveActiveMetaMaskScope
+ * @see getGrantedMetaMaskScopes
+ */
+export type ResolveActiveMetaMaskScopeResult = {
+    /** CAIP-10 account ids -- same shape as `metaMaskClient.getScopeAccounts` returns. */
+    accounts: string[];
+    networkId: string;
+    scope: string | undefined;
+};
+/**
+ * Resolves the network a MetaMask wallet provider should treat as active,
+ * self-healing when the last-known-active network (see
+ * `getActiveNetworkIdFromLastKnownRegistry`) turns out to have no granted
+ * account.
+ *
+ * Every configured network is requested as an *optional* CAIP-25 scope (see
+ * `getMetaMaskScopes`), so MetaMask is free to grant an account for only a
+ * subset -- and the registry's own default (the first configured network for
+ * the chain) has no awareness of which subset that was. If the active
+ * network's scope is empty, this scans every OTHER scope this chain
+ * requested, restricted to the ones MetaMask actually granted, and adopts
+ * whichever is found (preferring a non-testnet network) as the new active
+ * network -- persisting the correction so future calls don't repeat the
+ * scan. If nothing was granted for this chain at all, the original
+ * (accounts: []) result is returned unchanged, preserving the existing
+ * "no address found" behavior when there's truly nothing to fall back to.
+ *
+ * @example
+ * ```ts
+ * const { accounts } = await resolveActiveMetaMaskScope(
+ *   { chain: 'SOL', metaMaskClient, walletProviderKey },
+ *   client
+ * );
+ * // accounts is non-empty even if the registry's default network wasn't
+ * // the one MetaMask actually granted.
+ * ```
+ *
+ * @param [client] - The Dynamic client instance whose logger this reports
+ * against. Required (rather than defaulting to the last-initialized client)
+ * so a fallback decision is always traceable to the client that requested it.
+ * @returns The resolved active network's id, CAIP-2 scope, and granted accounts.
+ * @see assertMetaMaskNetworkIsGranted
+ * @see getGrantedMetaMaskScopes
+ * @notInstrumented
+ */
+export declare const resolveActiveMetaMaskScope: ({ chain, metaMaskClient, walletProviderKey, }: ResolveActiveMetaMaskScopeParams, client?: DynamicClient) => Promise<ResolveActiveMetaMaskScopeResult>;
+//# sourceMappingURL=resolveActiveMetaMaskScope.d.ts.map

package/dist/resolveActiveMetaMaskScope/resolveActiveMetaMaskScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveActiveMetaMaskScope.d.ts","sourceRoot":"","sources":["../../src/resolveActiveMetaMaskScope/resolveActiveMetaMaskScope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAQrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAQnE,MAAM,MAAM,gCAAgC,GAAG;IAC7C,KAAK,EAAE,KAAK,CAAC;IACb,cAAc,EAAE,cAAc,CAAC;IAC/B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,gCAAgC,GAAG;IAC7C,sFAAsF;IACtF,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,0BAA0B,kDAKlC,gCAAgC,WAC3B,aAAa,KACpB,OAAO,CAAC,gCAAgC,CAgH1C,CAAC"}