@etherplay/connect 0.0.9 → 0.0.11

package/src/index.ts

@@ -1,7 +1,7 @@
 import type {AlchemyMechanism, OriginAccount} from '@etherplay/alchemy';
 import {writable} from 'svelte/store';
 import {createPopupLauncher, type PopupPromise} from './popup.js';
-import type {EIP1193WindowWalletProvider} from 'eip-1193';
+import type {EIP1193ChainId, EIP1193WindowWalletProvider} from 'eip-1193';
 import {
 	fromEntropyKeyToMnemonic,
 	fromMnemonicToFirstAccount,
@@ -10,6 +10,7 @@ import {
 	originPublicKeyPublicationMessage,
 } from '@etherplay/alchemy';
 import {hashMessage} from './utils.js';
+import {createProvider} from './provider.js';
 
 export {fromEntropyKeyToMnemonic, originPublicKeyPublicationMessage, originKeyMessage};
 export type {OriginAccount};
@@ -40,50 +41,82 @@ export type Connection = {
 	| {
 			step: 'Idle';
 			loading: boolean;
+			wallet: undefined;
 	  }
 	// It can then end up in MechanismToChoose if no specific connection mechanism was chosen upon clicking "connect"
 	| {
 			step: 'MechanismToChoose';
+			wallet: undefined;
 	  }
-	// if a social/email login mechanism was chose, a popup will be launched
+	// if a social/email login mechanism was chosen, a popup will be launched
 	// popupClosed can be true and this means the popup has been closed and the user has to cancel the process to continue further
 	| {
 			step: 'PopupLaunched';
+			wallet: undefined;
 			popupClosed: boolean;
 			mechanism: AlchemyMechanism;
 	  }
 	// If the user has chosen to use web3-wallet there might be multi-choice for it
 	| {
 			step: 'WalletToChoose';
+			wallet: undefined;
 			mechanism: WalletMechanism<undefined, undefined>;
 	  }
 	// Once a user has chosen a wallet, the system will try to connect to it
 	| {
 			step: 'WaitingForWalletConnection';
+			wallet: undefined;
 			mechanism: WalletMechanism<string, undefined>;
 	  }
 	// Once the wallet is connected, the system will need a signature
 	// this state represent the fact and require another user interaction to request the signature
 	| {
-			step: 'NeedWalletSignature';
+			step: 'WalletConnected';
 			mechanism: WalletMechanism<string, `0x${string}`>;
+			wallet: {
+				provider: EIP1193WindowWalletProvider;
+				locked: boolean;
+				accountChanged?: `0x${string}`;
+				chainId: string;
+				invalidChainId: boolean;
+				switchingChain: 'addingChain' | 'switchingChain' | false;
+			};
 	  }
 	// This state is triggered once the signature is requested, the user will have to confirm with its wallet
 	| {
 			step: 'WaitingForSignature';
 			mechanism: WalletMechanism<string, `0x${string}`>;
+			wallet: {
+				provider: EIP1193WindowWalletProvider;
+				locked: boolean;
+				accountChanged?: `0x${string}`;
+				chainId: string;
+				invalidChainId: boolean;
+				switchingChain: 'addingChain' | 'switchingChain' | false;
+			};
 	  }
 	// Finally the user is fully signed in
-	// walletAccountChanged if set, represent the fact that the user has changed its web3-wallet accounnt.
+	// wallet?.accountChanged if set, represent the fact that the user has changed its web3-wallet accounnt.
+	// wallet?.invalidChainId if set, represent the fact that the wallet is connected to a different chain.
+	// wallet?.switchingChain if set, represent the fact that the user is currently switching chain.
 	// a notification could be shown to the user so that he can switch the app to use that other account.
 	| {
 			step: 'SignedIn';
-			mechanism: FullfilledMechanism;
+			mechanism: AlchemyMechanism;
 			account: OriginAccount;
-			wallet?: {
+			wallet: undefined;
+	  }
+	| {
+			step: 'SignedIn';
+			mechanism: WalletMechanism<string, `0x${string}`>;
+			account: OriginAccount;
+			wallet: {
 				provider: EIP1193WindowWalletProvider;
+				locked: boolean;
 				accountChanged?: `0x${string}`;
 				chainId: string;
+				invalidChainId: boolean;
+				switchingChain: 'addingChain' | 'switchingChain' | false;
 			};
 	  }
 );
@@ -106,13 +139,26 @@ export interface EIP6963AnnounceProviderEvent extends CustomEvent {
 }
 
 const storageAccountKey = '__origin_account';
-export function createConnection(settings: {walletHost: string; autoConnect?: boolean}) {
+export function createConnection(settings: {
+	walletHost: string;
+	autoConnect?: boolean;
+	requestSignatureAutomaticallyIfPossible?: boolean;
+	node: {url: string; chainId: string; prioritizeWalletProvider?: boolean; requestsPerSecond?: number};
+}) {
+	const alwaysOnChainId = settings.node.chainId;
+	const alwaysOnProvider = createProvider({
+		endpoint: settings.node.url,
+		chainId: settings.node.chainId,
+		prioritizeWalletProvider: settings.node.prioritizeWalletProvider,
+		requestsPerSecond: settings.node.requestsPerSecond,
+	});
 	let autoConnect = true;
 	if (typeof settings.autoConnect !== 'undefined') {
 		autoConnect = settings.autoConnect;
 	}
+	const requestSignatureAutomaticallyIfPossible = settings.requestSignatureAutomaticallyIfPossible || false;
 
-	let $connection: Connection = {step: 'Idle', loading: true, wallets: []};
+	let $connection: Connection = {step: 'Idle', loading: true, wallet: undefined, wallets: []};
 	const _store = writable<Connection>($connection);
 	function set(connection: Connection) {
 		$connection = connection;
@@ -182,53 +228,60 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 				const existingAccount = getOriginAccount();
 				if (existingAccount) {
 					if (existingAccount.signer) {
-						if (existingAccount.mechanismUsed.type == 'wallet') {
-							const walletMechanism = existingAccount.mechanismUsed as WalletMechanism<string, `0x${string}`>;
+						const mechanismUsed = existingAccount.mechanismUsed as
+							| AlchemyMechanism
+							| WalletMechanism<string, `0x${string}`>;
+						if (mechanismUsed.type == 'wallet') {
+							const walletMechanism = mechanismUsed as WalletMechanism<string, `0x${string}`>;
 							waitForWallet(walletMechanism.name)
 								.then(async (walletDetails: EIP6963ProviderDetail) => {
 									const walletProvider = walletDetails.provider;
 									const chainIdAsHex = await walletProvider.request({method: 'eth_chainId'});
 									const chainId = Number(chainIdAsHex).toString();
 									_wallet = {provider: walletProvider, chainId};
+									alwaysOnProvider.setWalletProvider(walletProvider);
 									watchForChainIdChange(_wallet.provider);
 									set({
 										step: 'SignedIn',
 										account: existingAccount,
-										mechanism: existingAccount.mechanismUsed as FullfilledMechanism,
+										mechanism: walletMechanism,
 										wallets: $connection.wallets,
 										wallet: {
 											provider: walletProvider,
+											locked: false, // TODO should fetch eth_account first
 											accountChanged: undefined,
 											chainId,
+											invalidChainId: alwaysOnChainId != chainId,
+											switchingChain: false,
 										},
 									});
 									walletProvider.request({method: 'eth_accounts'}).then(onAccountChanged);
 									watchForAccountChange(walletProvider);
 								})
 								.catch((err) => {
-									set({step: 'Idle', loading: false, wallets: $connection.wallets});
+									set({step: 'Idle', loading: false, wallet: undefined, wallets: $connection.wallets});
 								});
 						} else {
 							set({
 								step: 'SignedIn',
 								account: existingAccount,
-								mechanism: existingAccount.mechanismUsed as FullfilledMechanism,
+								mechanism: mechanismUsed,
 								wallets: $connection.wallets,
 								wallet: undefined,
 							});
 						}
 					} else {
-						set({step: 'Idle', loading: false, wallets: $connection.wallets});
+						set({step: 'Idle', loading: false, wallet: undefined, wallets: $connection.wallets});
 					}
 				} else {
-					set({step: 'Idle', loading: false, wallets: $connection.wallets});
+					set({step: 'Idle', loading: false, wallet: undefined, wallets: $connection.wallets});
 				}
 			} catch {
-				set({step: 'Idle', loading: false, wallets: $connection.wallets});
+				set({step: 'Idle', loading: false, wallet: undefined, wallets: $connection.wallets});
 			}
 		}
 	} else {
-		set({step: 'Idle', loading: false, wallets: $connection.wallets});
+		set({step: 'Idle', loading: false, wallet: undefined, wallets: $connection.wallets});
 	}
 	fetchWallets();
 
@@ -249,8 +302,8 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 	}
 
 	async function requestSignature() {
-		if ($connection.step !== 'NeedWalletSignature') {
-			throw new Error(`invalid step: ${$connection.step}, needs to be NeedWalletSignature`);
+		if ($connection.step !== 'WalletConnected') {
+			throw new Error(`invalid step: ${$connection.step}, needs to be WalletConnected`);
 		}
 
 		if (!_wallet) {
@@ -278,7 +331,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 			// TODO handle rejection (code: 4001 ?)
 			set({
 				...$connection,
-				step: 'NeedWalletSignature',
+				step: 'WalletConnected',
 				mechanism: {
 					type: 'wallet',
 					name: $connection.mechanism.name,
@@ -318,7 +371,10 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 			wallet: {
 				chainId,
 				provider: provider,
+				locked: false,
 				accountChanged: undefined, // TODO check account list
+				invalidChainId: alwaysOnChainId != chainId,
+				switchingChain: false,
 			},
 		});
 		if (remember) {
@@ -343,12 +399,18 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 		if (_wallet) {
 			_wallet.chainId = chainId;
 		}
-		if ($connection.step === 'SignedIn' && $connection.wallet && $connection.wallet.chainId != chainId) {
+		if (
+			$connection.step === 'SignedIn' &&
+			$connection.mechanism.type === 'wallet' &&
+			$connection.wallet &&
+			$connection.wallet.chainId != chainId
+		) {
 			set({
 				...$connection,
 				wallet: {
 					...$connection.wallet,
 					chainId,
+					invalidChainId: alwaysOnChainId != chainId,
 				},
 			});
 		}
@@ -356,6 +418,25 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 
 	function onAccountChanged(accounts: `0x${string}`[]) {
 		const accountsFormated = accounts.map((a) => a.toLowerCase()) as `0x${string}`[];
+
+		if (accountsFormated.length === 0 && $connection.wallet) {
+			set({
+				...$connection,
+				wallet: {
+					...$connection.wallet,
+					locked: true,
+				},
+			});
+		} else if (accountsFormated.length > 0 && $connection.wallet?.locked) {
+			set({
+				...$connection,
+				wallet: {
+					...$connection.wallet,
+					locked: false,
+				},
+			});
+		}
+
 		if ($connection.step === 'SignedIn' && $connection.mechanism.type === 'wallet') {
 			// TODO if auto-connect and saved-signature ?
 			// connect(
@@ -364,7 +445,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 			// 		address: accounts[0],
 			// 		name: $connection.mechanism.name
 			// 	},
-			// 	{ requireUserConfirmationBeforeSIgnatureRequest: true }
+			// 	{ requireUserConfirmationBeforeSignatureRequest: true }
 			// );
 
 			if ($connection.wallet && accountsFormated.length > 0 && accountsFormated[0] != $connection.account.address) {
@@ -407,7 +488,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 	async function connect(
 		mechanism?: Mechanism,
 		options?: {
-			requireUserConfirmationBeforeSIgnatureRequest?: boolean;
+			requireUserConfirmationBeforeSignatureRequest?: boolean;
 			doNotStoreLocally?: boolean;
 			requestSignatureRightAway?: boolean;
 		},
@@ -420,6 +501,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 					const wallet = $connection.wallets.find((v) => v.info.name == walletName || v.info.uuid == walletName);
 					if (wallet) {
 						if (_wallet) {
+							alwaysOnProvider.setWalletProvider(undefined);
 							stopatchingForAccountChange(_wallet.provider);
 							stopatchingForChainIdChange(_wallet.provider);
 						}
@@ -433,6 +515,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 							step: 'WaitingForWalletConnection', // TODO FetchingAccounts
 							mechanism,
 							wallets: $connection.wallets,
+							wallet: undefined,
 						});
 						const provider = wallet.provider;
 						const chainIdAsHex = await provider.request({method: 'eth_chainId'});
@@ -441,14 +524,16 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 							chainId,
 							provider,
 						};
+						alwaysOnProvider.setWalletProvider(_wallet.provider);
 						watchForChainIdChange(_wallet.provider);
 						let accounts = await provider.request({method: 'eth_accounts'});
 						accounts = accounts.map((v) => v.toLowerCase()) as `0x${string}`[];
 						if (accounts.length === 0) {
 							set({
-								step: 'WaitingForWalletConnection',
+								step: 'WaitingForWalletConnection', // TODO add another step to unlock ?
 								mechanism,
 								wallets: $connection.wallets,
+								wallet: undefined,
 							});
 							accounts = await provider.request({method: 'eth_requestAccounts'});
 							accounts = accounts.map((v) => v.toLowerCase()) as `0x${string}`[];
@@ -456,22 +541,38 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 								if (options?.requestSignatureRightAway) {
 									watchForAccountChange(_wallet.provider);
 									set({
-										step: 'NeedWalletSignature',
+										step: 'WalletConnected',
 										mechanism: {
 											...mechanism,
 											address: accounts[0],
 										},
 										wallets: $connection.wallets,
+										wallet: {
+											provider: _wallet.provider,
+											locked: false,
+											accountChanged: undefined,
+											chainId,
+											invalidChainId: alwaysOnChainId != chainId,
+											switchingChain: false,
+										},
 									});
 									await requestSignature();
 								} else {
 									set({
-										step: 'NeedWalletSignature',
+										step: 'WalletConnected',
 										mechanism: {
 											...mechanism,
 											address: accounts[0],
 										},
 										wallets: $connection.wallets,
+										wallet: {
+											provider: _wallet.provider,
+											locked: false,
+											accountChanged: undefined,
+											chainId,
+											invalidChainId: alwaysOnChainId != chainId,
+											switchingChain: false,
+										},
 									});
 									watchForAccountChange(_wallet.provider);
 								}
@@ -479,29 +580,46 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 								set({
 									step: 'MechanismToChoose',
 									wallets: $connection.wallets,
+									wallet: undefined,
 									error: {message: 'could not get any accounts'},
 								});
 							}
 						} else {
-							if (options?.requireUserConfirmationBeforeSIgnatureRequest) {
+							if (!requestSignatureAutomaticallyIfPossible || options?.requireUserConfirmationBeforeSignatureRequest) {
 								set({
-									step: 'NeedWalletSignature',
+									step: 'WalletConnected',
 									mechanism: {
 										...mechanism,
 										address: accounts[0],
 									},
 									wallets: $connection.wallets,
+									wallet: {
+										provider: _wallet.provider,
+										locked: false,
+										accountChanged: undefined,
+										chainId,
+										invalidChainId: alwaysOnChainId != chainId,
+										switchingChain: false,
+									},
 								});
 								watchForAccountChange(_wallet.provider);
 							} else {
 								watchForAccountChange(_wallet.provider);
 								set({
-									step: 'NeedWalletSignature',
+									step: 'WalletConnected',
 									mechanism: {
 										...mechanism,
 										address: accounts[0],
 									},
 									wallets: $connection.wallets,
+									wallet: {
+										provider: _wallet.provider,
+										locked: false,
+										accountChanged: undefined,
+										chainId,
+										invalidChainId: alwaysOnChainId != chainId,
+										switchingChain: false,
+									},
 								});
 								await requestSignature();
 							}
@@ -511,6 +629,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 						set({
 							step: 'MechanismToChoose',
 							wallets: $connection.wallets,
+							wallet: undefined,
 							error: {message: `failed to get wallet ${walletName}`},
 						});
 					}
@@ -524,6 +643,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 					set({
 						step: 'WalletToChoose',
 						mechanism: {type: 'wallet'},
+						wallet: undefined,
 						wallets: $connection.wallets,
 					});
 				}
@@ -537,6 +657,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 					popupClosed: false,
 					mechanism,
 					wallets: $connection.wallets,
+					wallet: undefined,
 				});
 
 				const unsubscribe = popup.subscribe(($popup) => {
@@ -564,7 +685,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 					}
 				} catch (err) {
 					console.log({error: err});
-					set({step: 'Idle', loading: false, wallets: $connection.wallets});
+					set({step: 'Idle', loading: false, wallet: undefined, wallets: $connection.wallets});
 				} finally {
 					unsubscribe();
 				}
@@ -573,6 +694,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 			set({
 				step: 'MechanismToChoose',
 				wallets: $connection.wallets,
+				wallet: undefined,
 			});
 		}
 	}
@@ -580,6 +702,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 	function disconnect() {
 		deleteOriginAccount();
 		if (_wallet) {
+			alwaysOnProvider.setWalletProvider(undefined);
 			stopatchingForAccountChange(_wallet.provider);
 			stopatchingForChainIdChange(_wallet.provider);
 		}
@@ -587,6 +710,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 		set({
 			step: 'Idle',
 			loading: false,
+			wallet: undefined,
 			wallets: $connection.wallets,
 		});
 	}
@@ -594,11 +718,11 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 	function back(step: 'MechanismToChoose' | 'Idle' | 'WalletToChoose') {
 		popup?.cancel();
 		if (step === 'MechanismToChoose') {
-			set({step, wallets: $connection.wallets});
+			set({step, wallets: $connection.wallets, wallet: undefined});
 		} else if (step === 'Idle') {
-			set({step, loading: false, wallets: $connection.wallets});
+			set({step, loading: false, wallet: undefined, wallets: $connection.wallets});
 		} else if (step === 'WalletToChoose') {
-			set({step, wallets: $connection.wallets, mechanism: {type: 'wallet'}});
+			set({step, wallet: undefined, wallets: $connection.wallets, mechanism: {type: 'wallet'}});
 		}
 	}
 
@@ -664,7 +788,7 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 
 	function cancel() {
 		popup?.cancel();
-		set({step: 'Idle', loading: false, wallets: $connection.wallets});
+		set({step: 'Idle', wallet: undefined, loading: false, wallets: $connection.wallets});
 	}
 
 	function getSignatureForPublicKeyPublication(): Promise<`0x${string}`> {
@@ -693,6 +817,182 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 		throw new Error(`no saved public key publication signature for ${account.address}`);
 	}
 
+	async function unlock() {
+		if (!$connection.wallet) {
+			throw new Error(`invali state`);
+		}
+
+		const wallet = $connection.wallet;
+
+		// TODO unlocking state
+		await wallet.provider.request({method: 'eth_requestAccounts'}).then(onAccountChanged);
+	}
+
+	async function switchWalletChain(
+		chainId: string,
+		config?: {
+			readonly rpcUrls?: readonly string[];
+			readonly blockExplorerUrls?: readonly string[];
+			readonly chainName?: string;
+			readonly iconUrls?: readonly string[];
+			readonly nativeCurrency?: {
+				name: string;
+				symbol: string;
+				decimals: number;
+			};
+		},
+	) {
+		if (!$connection.wallet) {
+			throw new Error(`invali state`);
+		}
+
+		const wallet = $connection.wallet;
+		// if (!wallet) {
+		// 	throw new Error(`no wallet`);
+		// }
+
+		try {
+			// attempt to switch...
+			set({
+				...$connection,
+				wallet: {...$connection.wallet, switchingChain: 'switchingChain'},
+			});
+			const result = await wallet.provider.request({
+				method: 'wallet_switchEthereumChain',
+				params: [
+					{
+						chainId: ('0x' + parseInt(chainId).toString(16)) as EIP1193ChainId,
+					},
+				],
+			});
+			if (!result) {
+				if ($connection.wallet) {
+					set({
+						...$connection,
+						wallet: {...$connection.wallet, switchingChain: false},
+					});
+				}
+
+				// logger.info(`wallet_switchEthereumChain: complete`);
+				// this will be taken care with `chainChanged` (but maybe it should be done there ?)
+				// handleNetwork(chainId);
+			} else {
+				if ($connection.wallet) {
+					set({
+						...$connection,
+						wallet: {...$connection.wallet, switchingChain: false},
+						error: {
+							message: `Failed to switch to ${config?.chainName || `chain with id = ${chainId}`}`,
+							cause: result,
+						},
+					});
+				}
+				throw result;
+			}
+		} catch (err) {
+			if ((err as any).code === 4001) {
+				// logger.info(`wallet_addEthereumChain: failed but error code === 4001, we ignore as user rejected it`, err);
+				if ($connection.wallet) {
+					set({
+						...$connection,
+						wallet: {...$connection.wallet, switchingChain: false},
+					});
+				}
+				return;
+			}
+			// if ((err as any).code === 4902) {
+			else if (config && config.rpcUrls && config.rpcUrls.length > 0) {
+				if ($connection.wallet) {
+					set({
+						...$connection,
+						wallet: {...$connection.wallet, switchingChain: 'addingChain'},
+					});
+				}
+				// logger.info(`wallet_switchEthereumChain: could not switch, try adding the chain via "wallet_addEthereumChain"`);
+				try {
+					const result = await wallet.provider.request({
+						method: 'wallet_addEthereumChain',
+						params: [
+							{
+								chainId: ('0x' + parseInt(chainId).toString(16)) as EIP1193ChainId,
+								rpcUrls: config.rpcUrls,
+								chainName: config.chainName,
+								blockExplorerUrls: config.blockExplorerUrls,
+								iconUrls: config.iconUrls,
+								nativeCurrency: config.nativeCurrency,
+							},
+						],
+					});
+					if (!result) {
+						if ($connection.wallet) {
+							set({
+								...$connection,
+								wallet: {...$connection.wallet, switchingChain: false},
+							});
+						}
+						// this will be taken care with `chainChanged` (but maybe it should be done there ?)
+						// handleNetwork(chainId);
+					} else {
+						if ($connection.wallet) {
+							set({
+								...$connection,
+								wallet: {...$connection.wallet, switchingChain: false},
+								error: {
+									message: `Failed to add new chain: ${config?.chainName || `chain with id = ${chainId}`}`,
+									cause: result,
+								},
+							});
+						}
+						// logger.info(`wallet_addEthereumChain: a non-undefinded result means an error`, result);
+						throw result;
+					}
+				} catch (err) {
+					if ((err as any).code !== 4001) {
+						if ($connection.wallet) {
+							set({
+								...$connection,
+								wallet: {...$connection.wallet, switchingChain: false},
+								error: {
+									message: `Failed to add new chain: ${config?.chainName || `chain with id = ${chainId}`}`,
+									cause: err,
+								},
+							});
+						}
+						// logger.info(`wallet_addEthereumChain: failed`, err);
+						// TODO ?
+						// set({
+						// 	error: {message: `Failed to add new chain`, cause: err},
+						// });
+						// for now:
+						throw err;
+					} else {
+						if ($connection.wallet) {
+							set({
+								...$connection,
+								wallet: {...$connection.wallet, switchingChain: false},
+							});
+						}
+						// logger.info(`wallet_addEthereumChain: failed but error code === 4001, we ignore as user rejected it`, err);
+						return;
+					}
+				}
+			} else {
+				const errorMessage = `Chain "${config?.chainName || `with chainId = ${chainId}`} " is not available on your wallet`;
+				if ($connection.wallet) {
+					set({
+						...$connection,
+						wallet: {...$connection.wallet, switchingChain: false},
+						error: {
+							message: errorMessage,
+						},
+					});
+				}
+
+				throw new Error(errorMessage);
+			}
+		}
+	}
+
 	return {
 		subscribe: _store.subscribe,
 		connect,
@@ -702,5 +1002,10 @@ export function createConnection(settings: {walletHost: string; autoConnect?: bo
 		connectOnCurrentWalletAccount,
 		disconnect,
 		getSignatureForPublicKeyPublication,
+		switchWalletChain,
+		unlock,
+		provider: alwaysOnProvider,
 	};
 }
+
+export type ConnectionStore = ReturnType<typeof createConnection>;