@dynamic-labs-sdk/solana 1.31.0 → 1.31.2

package/dist/metamask.cjs

@@ -1,181 +1,301 @@
 const require_chunk = require('./chunk-CbDLau6x.cjs');
-const require_solanaTransferAmount = require('./solanaTransferAmount-DFbb8Fnf.cjs');
-const require_createWalletProviderFromSolanaStandardWallet = require('./createWalletProviderFromSolanaStandardWallet-CCkxOmSK.cjs');
+const require_solanaTransferAmount = require('./solanaTransferAmount-4hvpXzRi.cjs');
 let _dynamic_labs_sdk_assert_package_version = require("@dynamic-labs-sdk/assert-package-version");
 let _dynamic_labs_sdk_client_core = require("@dynamic-labs-sdk/client/core");
 let _dynamic_labs_sdk_client = require("@dynamic-labs-sdk/client");
+let _solana_web3_js = require("@solana/web3.js");
 let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
+let _dynamic_labs_sdk_metamask_core = require("@dynamic-labs-sdk/metamask/core");
+let _dynamic_labs_sdk_wallet_connect_core = require("@dynamic-labs-sdk/wallet-connect/core");
 let _dynamic_labs_sdk_metamask = require("@dynamic-labs-sdk/metamask");
-let _metamask_connect_solana = require("@metamask/connect-solana");
 
-//#region src/metamask/utils/getSolanaNetworkFromCluster/getSolanaNetworkFromCluster.ts
+//#region src/errors/MetaMaskDirectConnectNotSupportedError/MetaMaskDirectConnectNotSupportedError.ts
 /**
-* Maps a Dynamic network `cluster` (e.g. `mainnet-beta`, `devnet`,
-* `testnet`) to the `mainnet | devnet | testnet` key shape expected by
-* `@metamask/connect-solana`'s `createSolanaClient`. Returns `undefined` for
-* clusters that do not correspond to one of MetaMask's supported Solana
-* networks so callers can skip them. Used by `getSupportedNetworks` to build
-* the SDK's `supportedNetworks` map.
-*
-* @notInstrumented
+* Thrown when `connect()` is called directly on the MetaMask SDK placeholder
+* wallet provider (the entry `addMetaMaskSolanaExtension` registers so
+* MetaMask still shows up in the wallet picker when no browser extension is
+* installed). That placeholder has no generic connect flow of its own --
+* connecting requires the QR / deeplink pairing flow, so callers must drive
+* `connectWithMetaMaskUriSolana` (or `connectAndVerifyWithMetaMaskUriSolana`)
+* instead of the picker's default connect.
 */
-const getSolanaNetworkFromCluster = ({ cluster }) => {
-	if (cluster === void 0) return;
-	if (cluster.includes("mainnet")) return "mainnet";
-	if (cluster.includes("devnet")) return "devnet";
-	if (cluster.includes("testnet")) return "testnet";
+var MetaMaskDirectConnectNotSupportedError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "metamask_direct_connect_not_supported",
+			docsUrl: null,
+			name: "MetaMaskDirectConnectNotSupportedError",
+			shortMessage: "MetaMask cannot be connected directly; call connectWithMetaMaskUriSolana (or connectAndVerifyWithMetaMaskUriSolana) to get a QR/URI pairing flow instead"
+		});
+	}
 };
 
 //#endregion
-//#region src/metamask/utils/getSupportedNetworks/getSupportedNetworks.ts
+//#region src/metamask/getMetaMaskSolanaSdkWalletProviderKey/getMetaMaskSolanaSdkWalletProviderKey.ts
+const METAMASK_SOLANA_SDK_DISPLAY_NAME = "MetaMask";
 /**
-* Builds the `supportedNetworks` map required by
-* `@metamask/connect-solana`'s `createSolanaClient`, keyed by the SDK's
-* `mainnet | devnet | testnet` network names and valued with the first
-* configured RPC URL for each. Sources the configured SOL networks from the
-* Dynamic client's project settings. Throws when no SOL network is
-* configured, mirroring the EVM `getSupportedNetworks` contract.
+* Deterministic wallet provider key for the MetaMask SDK's connect-less
+* Solana placeholder. Computed without building the wallet provider itself,
+* so `addMetaMaskSolanaExtension` can check for a matching wallet account
+* before paying the cost of `createMetaMaskSolanaWalletProvider`.
 *
+* @example
+* ```ts
+* const key = getMetaMaskSolanaSdkWalletProviderKey();
+* ```
+* @returns The deterministic wallet provider key.
+* @see createMetaMaskSolanaWalletProvider
+* @see reconcileMetaMaskWalletProvider
 * @notInstrumented
 */
-const getSupportedNetworks = (client) => {
-	const solanaNetworks = (0, _dynamic_labs_sdk_client.getNetworksData)(client).filter((network) => network.chain === "SOL");
-	(0, _dynamic_labs_sdk_client_core.assertNonEmptyArray)(solanaNetworks, "No SOL networks have been configured. Make sure to add at least one Solana network to your project settings in the Dynamic Dashboard.");
-	const supportedNetworks = {};
-	for (const network of solanaNetworks) {
-		const solanaNetwork = getSolanaNetworkFromCluster({ cluster: network.cluster });
-		if (solanaNetwork !== void 0 && supportedNetworks[solanaNetwork] === void 0) supportedNetworks[solanaNetwork] = network.rpcUrls.http[0];
-	}
-	return supportedNetworks;
-};
+const getMetaMaskSolanaSdkWalletProviderKey = () => (0, _dynamic_labs_sdk_client_core.formatWalletProviderKey)({
+	chain: "SOL",
+	displayName: METAMASK_SOLANA_SDK_DISPLAY_NAME,
+	walletProviderType: _dynamic_labs_sdk_api_core.WalletProviderEnum.QrCode
+});
 
 //#endregion
-//#region src/metamask/utils/createMetaMaskSolanaController/createMetaMaskSolanaController.ts
+//#region src/metamask/createMetaMaskSolanaWalletProvider/createMetaMaskSolanaWalletProvider.ts
+const METAMASK_DISPLAY_NAME = "MetaMask";
+const METAMASK_ICON = `${_dynamic_labs_sdk_client_core.DYNAMIC_ICONIC_SPRITE_URL}#metamask`;
 /**
-* Builds a fully-initialised `MetaMaskSolanaController` for the given Dynamic
-* client. Drives the `@metamask/connect-solana` SDK through its Wallet
-* Standard surface so consumers render their own QR / deep-link UI, and
-* subscribes to the SDK core's `display_uri` event at construction time so
-* the first URI emission cannot be lost to a subscription race. The wallet
-* is created with `skipAutoRegister` so this URI-pairing client does not
-* register itself into the global Wallet Standard registry — an announced
-* MetaMask extension is discovered independently. Dapp metadata is sourced
-* from the client's `getAppMetadata`. Browser-only.
-* The MetaMask SDK's own verbose logging is tied to the Dynamic client's log
-* level, so turning on `debug` logging for the Dynamic SDK also surfaces
-* MetaMask's internal SDK trace output.
+* Builds the `SolanaWalletProvider` registered AFTER a successful MetaMask
+* SDK URI pairing. Unlike the EVM facade, MetaMask does not expose a typed
+* RPC surface for Solana, so this drives `invokeMethod` directly against the
+* documented `signMessage` / `signTransaction` / `signAndSendTransaction`
+* methods (see https://docs.metamask.io/metamask-connect/multichain/guides/sign-transactions/
+* and .../send-transactions/), scoped to `solana:<genesisHash>` per CAIP-2 —
+* MetaMask's multichain session grants every configured network as its own
+* scope up front, so "the active network" is tracked in Dynamic's own
+* last-known-network registry rather than asked of the SDK. Drops `connect`
+* so the provider is filtered out of the wallet picker by
+* `getAvailableWalletProvidersData` — mirroring how WalletConnect URI
+* sessions register a signing-only provider.
+*
+* MetaMask's multichain API does not document a batch-signing method for
+* Solana, so `signAllTransactions` signs each transaction with its own
+* `signTransaction` call (sequential wallet prompts) rather than one batch
+* approval.
+*
+* `getConnectedAddresses` and `switchActiveNetwork` route through
+* `resolveActiveMetaMaskScope`/`assertMetaMaskNetworkIsGranted` rather than
+* the registry directly, since every configured network is requested as an
+* *optional* scope -- MetaMask may grant an account for only a subset (see
+* their JSDoc).
+*
+* `switchActiveNetwork`/`disconnectWalletAccount` are local, Dynamic-side
+* actions with no live wallet event to bridge, so they emit `networkChanged`/
+* `disconnected` themselves via `metaMaskEvents` -- otherwise `events` would
+* never fire for MetaMask at all.
 *
 * @notInstrumented
 */
-const createMetaMaskSolanaController = async (client) => {
-	const supportedNetworks = getSupportedNetworks(client);
-	const { appName, appLogoUrl, appUniversalLink, appNativeLink } = (0, _dynamic_labs_sdk_client_core.getAppMetadata)(client);
-	const { logger } = (0, _dynamic_labs_sdk_client_core.getCore)(client);
-	await (0, _dynamic_labs_sdk_metamask.clearMetaMaskSessionStorage)(client);
-	const listeners = /* @__PURE__ */ new Set();
-	let latestDisplayUri;
-	const sdk = await (0, _metamask_connect_solana.createSolanaClient)({
-		api: { supportedNetworks },
-		dapp: {
-			iconUrl: appLogoUrl,
-			name: appName,
-			nativeScheme: (0, _dynamic_labs_sdk_client_core.getNativeLinkScheme)({ nativeLink: appNativeLink }),
-			url: appUniversalLink ?? ""
-		},
-		debug: logger.isEnabled("debug"),
-		skipAutoRegister: true
-	});
-	sdk.core.on("display_uri", (uri) => {
-		latestDisplayUri = uri;
-		for (const listener of listeners) listener(uri);
-	});
-	sdk.core.on("stateChanged", (status) => {
-		if (status === "connected" || status === "disconnected") latestDisplayUri = void 0;
+const createMetaMaskSolanaWalletProvider = (client) => {
+	const metaMaskClientInstanceManager = (0, _dynamic_labs_sdk_metamask_core.getOrCreateMetaMaskClientInstanceManager)(client);
+	const serializeTransaction = (transaction) => (0, _dynamic_labs_sdk_client_core.getBuffer)().from(transaction.serialize({
+		requireAllSignatures: false,
+		verifySignatures: false
+	})).toString("base64");
+	const deserializeTransaction = ({ base64Transaction, original }) => {
+		const bytes = (0, _dynamic_labs_sdk_client_core.getBuffer)().from(base64Transaction, "base64");
+		return require_solanaTransferAmount.isVersionedTransaction(original) ? _solana_web3_js.VersionedTransaction.deserialize(bytes) : _solana_web3_js.Transaction.from(bytes);
+	};
+	const walletProviderKey = getMetaMaskSolanaSdkWalletProviderKey();
+	const metaMaskEvents = (0, _dynamic_labs_sdk_metamask_core.createMetaMaskWalletProviderEventEmitter)();
+	const getActiveScope = async () => {
+		const { networkId } = await (0, _dynamic_labs_sdk_client_core.getActiveNetworkIdFromLastKnownRegistry)({
+			client,
+			walletProviderKey
+		});
+		const network = (0, _dynamic_labs_sdk_client.getNetworksData)(client).find((candidate) => candidate.chain === "SOL" && candidate.networkId === networkId);
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(network?.genesisHash, `No configured SOL network with a genesis hash matches active network id "${networkId}"`);
+		return `solana:${network.genesisHash}`;
+	};
+	const getConnectedAddresses = async () => {
+		const { accounts } = await (0, _dynamic_labs_sdk_metamask_core.resolveActiveMetaMaskScope)({
+			chain: "SOL",
+			metaMaskClient: await metaMaskClientInstanceManager.getMetaMaskClient(),
+			walletProviderKey
+		}, client);
+		return { addresses: accounts.map((account) => (0, _dynamic_labs_sdk_wallet_connect_core.splitCaip10Token)(account).address) };
+	};
+	const getActiveNetworkId = async () => (0, _dynamic_labs_sdk_client_core.getActiveNetworkIdFromLastKnownRegistry)({
+		client,
+		walletProviderKey
 	});
-	latestDisplayUri = void 0;
-	const onDisplayUri = (listener) => {
-		listeners.add(listener);
-		if (latestDisplayUri !== void 0) listener(latestDisplayUri);
-		return () => {
-			listeners.delete(listener);
-		};
+	const switchActiveNetwork = async ({ networkId }) => {
+		await (0, _dynamic_labs_sdk_metamask_core.assertMetaMaskNetworkIsGranted)({
+			chain: "SOL",
+			metaMaskClient: await metaMaskClientInstanceManager.getMetaMaskClient(),
+			networkId
+		}, client);
+		const { networkId: previousNetworkId } = await (0, _dynamic_labs_sdk_client_core.getActiveNetworkIdFromLastKnownRegistry)({
+			client,
+			walletProviderKey
+		});
+		await (0, _dynamic_labs_sdk_client_core.switchActiveNetworkInLastKnownRegistry)({
+			client,
+			networkId,
+			walletProviderKey
+		});
+		if (networkId !== previousNetworkId) metaMaskEvents.emitNetworkChanged({ networkId });
 	};
-	let inFlightConnect = null;
-	const connect = () => {
-		if (inFlightConnect) return inFlightConnect;
-		inFlightConnect = (async () => {
-			try {
-				if (sdk.core.status === "connecting") try {
-					await sdk.disconnect();
-				} catch (error) {
-					(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.debug("[metamask] pre-connect disconnect rejected (expected when aborting a pairing the wallet never accepted)", error);
+	const signMessage = async ({ message, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account is required");
+		const scope = await getActiveScope();
+		return { signature: (await (await metaMaskClientInstanceManager.getMetaMaskClient()).invokeMethod({
+			request: {
+				method: "signMessage",
+				params: {
+					account: { address: walletAccount.address },
+					message: (0, _dynamic_labs_sdk_client_core.getBuffer)().from(message, "utf-8").toString("base64")
 				}
-				await require_createWalletProviderFromSolanaStandardWallet.getFeaturesForSolanaStandardWallet(sdk.getWallet())["standard:connect"].connect();
-			} finally {
-				inFlightConnect = null;
-			}
-		})();
-		return inFlightConnect;
+			},
+			scope
+		})).signature };
+	};
+	const signTransaction = async ({ transaction, walletAccount }) => {
+		const scope = await getActiveScope();
+		return { signedTransaction: deserializeTransaction({
+			base64Transaction: (await (await metaMaskClientInstanceManager.getMetaMaskClient()).invokeMethod({
+				request: {
+					method: "signTransaction",
+					params: {
+						account: { address: walletAccount.address },
+						scope,
+						transaction: serializeTransaction(transaction)
+					}
+				},
+				scope
+			})).signedTransaction,
+			original: transaction
+		}) };
+	};
+	const signAllTransactions = async ({ transactions, walletAccount }) => {
+		const signedTransactions = [];
+		for (const transaction of transactions) {
+			const { signedTransaction } = await signTransaction({
+				transaction,
+				walletAccount
+			});
+			signedTransactions.push(signedTransaction);
+		}
+		return { signedTransactions };
+	};
+	const signAndSendTransaction = async ({ transaction, walletAccount }) => {
+		const scope = await getActiveScope();
+		return { signature: (await (await metaMaskClientInstanceManager.getMetaMaskClient()).invokeMethod({
+			request: {
+				method: "signAndSendTransaction",
+				params: {
+					account: { address: walletAccount.address },
+					scope,
+					transaction: serializeTransaction(transaction)
+				}
+			},
+			scope
+		})).signature };
+	};
+	const disconnectWalletAccount = async () => {
+		await (0, _dynamic_labs_sdk_metamask_core.disconnectMetaMaskWalletProvider)({
+			chain: "SOL",
+			walletProviderKey
+		}, client);
+		metaMaskEvents.emitDisconnected();
+	};
+	const destroy = async () => {
+		metaMaskEvents.cleanupEventEmitter();
 	};
 	return {
-		clearCachedDisplayUri: () => {
-			latestDisplayUri = void 0;
+		chain: "SOL",
+		confirmTransaction: (args) => require_solanaTransferAmount.solanaConfirmTransaction(args, client),
+		connect: async () => {
+			throw new MetaMaskDirectConnectNotSupportedError();
 		},
-		connect,
-		getLatestDisplayUri: () => latestDisplayUri,
-		onDisplayUri,
-		sdk
+		destroy,
+		disconnectWalletAccount,
+		get events() {
+			return metaMaskEvents.getEventEmitter();
+		},
+		executeSwapTransaction: (args) => require_solanaTransferAmount.solanaExecuteSwapTransaction(args, client),
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: (0, _dynamic_labs_sdk_client_core.formatWalletProviderGroupKey)(METAMASK_DISPLAY_NAME),
+		key: walletProviderKey,
+		metadata: {
+			displayName: METAMASK_DISPLAY_NAME,
+			icon: METAMASK_ICON
+		},
+		signAllTransactions,
+		signAndSendTransaction,
+		signMessage,
+		signTransaction,
+		switchActiveNetwork,
+		transferAmount: (args) => require_solanaTransferAmount.solanaTransferAmount(args, client),
+		walletProviderType: _dynamic_labs_sdk_api_core.WalletProviderEnum.QrCode
 	};
 };
 
 //#endregion
-//#region src/metamask/utils/getOrCreateMetaMaskSolanaController/getOrCreateMetaMaskSolanaController.ts
-const RUNTIME_SERVICE_KEY = "metaMaskSolanaController";
+//#region src/metamask/addMetaMaskSolanaExtension/addMetaMaskSolanaExtension.ts
+const METAMASK_SOLANA_EXTENSION_KEY = "metaMaskSolana";
 /**
-* Per-`DynamicClient` accessor for the lazily-constructed MetaMask Solana
-* controller. Wraps `createMetaMaskSolanaController` with the standard
-* `runtimeServices` cache so every caller — the Wallet Standard
-* wallet-provider builder, the `display_uri` subscription helper, and the
-* `connectWithMetaMaskUriSolana` URI-returning helper — shares the same
-* controller (and therefore the same SDK instance, display-URI cache, and
-* listener registry) per Dynamic client.
+* Integrates MetaMask Connect (MetaMask's multichain SDK) with the Dynamic
+* client for Solana, letting users connect MetaMask on platforms where the
+* browser extension isn't available — e.g. scanning a QR code, or opening
+* the MetaMask mobile app from a website or React Native app. Call this
+* once during setup.
 *
-* The cache is **per-Dynamic-client, not per-SDK-instance**:
-* `@metamask/connect-solana`'s `createSolanaClient` builds on the shared
-* MultichainCore singleton, so when multiple Dynamic clients coexist they
-* end up sharing the same MetaMask session regardless of this cache. The
-* wrapper exists to own the controller's `display_uri` cache and listener
-* registry per Dynamic client, which the SDK itself does not expose.
+* @example
+* ```ts
+* const client = createDynamicClient({ environmentId: '...' });
 *
+* addMetaMaskSolanaExtension(client);
+* ```
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns void
+* @see connectWithMetaMaskUriSolana
+* @see addSolanaWalletStandardExtension
 * @notInstrumented
 */
-const getOrCreateMetaMaskSolanaController = (0, _dynamic_labs_sdk_client_core.createRuntimeServiceAccessKey)(RUNTIME_SERVICE_KEY, (client) => createMetaMaskSolanaController(client));
+const addMetaMaskSolanaExtension = (client = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	if ((0, _dynamic_labs_sdk_client_core.hasExtension)({ extensionKey: METAMASK_SOLANA_EXTENSION_KEY }, client)) return;
+	require_solanaTransferAmount.registerSolanaNetworkProviderBuilder(client);
+	(0, _dynamic_labs_sdk_client_core.registerExtension)({ extensionKey: METAMASK_SOLANA_EXTENSION_KEY }, client);
+	(0, _dynamic_labs_sdk_metamask_core.reconcileMetaMaskWalletProvider)({
+		walletProviderBuilder: createMetaMaskSolanaWalletProvider,
+		walletProviderKey: getMetaMaskSolanaSdkWalletProviderKey()
+	}, client);
+};
 
 //#endregion
-//#region src/metamask/createMetaMaskSolanaWalletProvider/createMetaMaskSolanaWalletProvider.ts
+//#region src/metamask/warnMetaMaskSolanaIntegrationIncomplete/warnMetaMaskSolanaIntegrationIncomplete.ts
 /**
-* Builds the `SolanaWalletProvider` registered AFTER a successful MetaMask
-* SDK URI pairing. Wraps the paired Wallet Standard wallet exposed by
-* `@metamask/connect-solana` behind the Dynamic Solana provider facade and
-* classifies it as `QrCode` so its key does not collide with an announced
-* MetaMask browser-extension provider for the same wallet name. Drops
-* `connect` so the provider is filtered out of the wallet picker by
-* `getAvailableWalletProvidersData` — mirroring how WalletConnect URI
-* sessions register a signing-only provider.
+* Warns when `addMetaMaskSolanaExtension()` hasn't been added, since a
+* wallet connected via `connectWithMetaMaskUriSolana` without it won't be
+* restored after a page reload.
 *
+* @example
+* ```ts
+* warnMetaMaskSolanaIntegrationIncomplete(client);
+* ```
+* @param client - The Dynamic client instance.
+* @returns void
+* @see connectWithMetaMaskUriSolana
+* @see addMetaMaskSolanaExtension
 * @notInstrumented
 */
-const createMetaMaskSolanaWalletProvider = async (client) => {
-	const walletStandardWallet = (await getOrCreateMetaMaskSolanaController(client)).sdk.getWallet();
-	if (walletStandardWallet.accounts.length === 0) throw new _dynamic_labs_sdk_metamask.MetaMaskWalletNotConnectedError();
-	return {
-		...require_createWalletProviderFromSolanaStandardWallet.createWalletProviderFromSolanaStandardWallet({
-			dynamicClient: client,
-			walletProviderType: _dynamic_labs_sdk_api_core.WalletProviderEnum.QrCode,
-			walletStandardWallet
-		}),
-		connect: void 0
-	};
+const warnMetaMaskSolanaIntegrationIncomplete = (client) => {
+	if ((0, _dynamic_labs_sdk_client_core.hasExtension)({ extensionKey: METAMASK_SOLANA_EXTENSION_KEY }, client)) return;
+	(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.warn(`MetaMask integration is incomplete: addMetaMaskSolanaExtension() is missing. Add it during setup:
+
+import { addMetaMaskSolanaExtension } from '@dynamic-labs-sdk/solana/metamask';
+import { createDynamicClient } from '@dynamic-labs-sdk/client';
+
+const client = createDynamicClient({ environmentId: '...' });
+
+addMetaMaskSolanaExtension(client);`);
 };
 
 //#endregion
@@ -190,11 +310,11 @@ const createMetaMaskSolanaWalletProvider = async (client) => {
 * @notInstrumented
 */
 const connectWithMetaMaskUriSolana = ({ addToDynamicWalletAccounts = true } = {}, client = (0, _dynamic_labs_sdk_client.getDefaultClient)()) => {
+	warnMetaMaskSolanaIntegrationIncomplete(client);
 	require_solanaTransferAmount.registerSolanaNetworkProviderBuilder(client);
 	return (0, _dynamic_labs_sdk_metamask.connectWithMetaMaskUri)({
 		addToDynamicWalletAccounts,
 		chain: "SOL",
-		getController: getOrCreateMetaMaskSolanaController,
 		walletProviderBuilder: createMetaMaskSolanaWalletProvider
 	}, client);
 };
@@ -245,18 +365,51 @@ const connectAndVerifyWithMetaMaskUriSolana = async (client = (0, _dynamic_labs_
 */
 const getMetaMaskSolanaExtensionWalletProviderKey = (client = (0, _dynamic_labs_sdk_client.getDefaultClient)()) => (0, _dynamic_labs_sdk_metamask.getMetaMaskExtensionWalletProviderKey)({ chain: "SOL" }, client);
 
+//#endregion
+//#region src/metamask/registerMetaMaskSolanaUriConnectionStarter/registerMetaMaskSolanaUriConnectionStarter.ts
+/**
+* Registers the MetaMask SDK URI pairing for Solana with the client, so higher
+* level connection APIs can mint a MetaMask URI for Solana without depending on
+* this package.
+*
+* Call it during app setup to opt into the MetaMask URI path — it is kept out
+* of the Solana extension so apps that never pair with MetaMask over a URI
+* don't bundle the MetaMask SDK.
+*
+* @example
+* ```ts
+* registerMetaMaskSolanaUriConnectionStarter();
+* ```
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns Nothing.
+* @see connectWithMetaMaskUriSolana
+* @see getUriConnectionStarterRegistry
+* @notInstrumented
+*/
+const registerMetaMaskSolanaUriConnectionStarter = (client = (0, _dynamic_labs_sdk_client.getDefaultClient)()) => {
+	(0, _dynamic_labs_sdk_client_core.getUriConnectionStarterRegistry)(client).register({
+		chain: "SOL",
+		start: ({ addToDynamicWalletAccounts }) => connectWithMetaMaskUriSolana({ addToDynamicWalletAccounts }, client),
+		type: "metamaskSdkUri"
+	});
+};
+
 //#endregion
 //#region src/exports/metamask.ts
 (0, _dynamic_labs_sdk_assert_package_version.assertPackageVersion)(require_solanaTransferAmount.name, require_solanaTransferAmount.version);
 
 //#endregion
+exports.MetaMaskDirectConnectNotSupportedError = MetaMaskDirectConnectNotSupportedError;
 Object.defineProperty(exports, 'MetaMaskDisplayUriMissingError', {
   enumerable: true,
   get: function () {
     return _dynamic_labs_sdk_metamask.MetaMaskDisplayUriMissingError;
   }
 });
+exports.addMetaMaskSolanaExtension = addMetaMaskSolanaExtension;
 exports.connectAndVerifyWithMetaMaskUriSolana = connectAndVerifyWithMetaMaskUriSolana;
 exports.connectWithMetaMaskUriSolana = connectWithMetaMaskUriSolana;
 exports.getMetaMaskSolanaExtensionWalletProviderKey = getMetaMaskSolanaExtensionWalletProviderKey;
+exports.registerMetaMaskSolanaUriConnectionStarter = registerMetaMaskSolanaUriConnectionStarter;
 //# sourceMappingURL=metamask.cjs.map