FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/@solana-mobile/wallet-adapter-mobile/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2022 Solana Mobile Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

node_modules/@solana-mobile/wallet-adapter-mobile/README.md

@@ -0,0 +1,118 @@
+# `@solana-mobile/wallet-adapter-mobile`
+
+This is a plugin for use with [`@solana/wallet-adapter`](https://github.com/solana-labs/wallet-adapter). It enables apps to use a native wallet app on a mobile device to sign messages and transactions, and to send transactions if the wallet offers support for sending transactions.
+
+## Usage
+
+Users of these libraries do not need to take any extra steps:
+
+- `@solana/wallet-adapter-react@">=0.15.21"`
+
+Those libraries automatically bundle the Mobile Wallet Adapter plugin, and enable it when running in a compatible mobile environment.
+
+## Advanced usage
+
+Developers might wish to customize the behavior of this plugin for their app. Specifying the app's name and icon, deciding which address to select in the event the wallet authorizes the app to use more than one, specifying which network cluster to communicate with, and more are made possible by creating an instance of the mobile wallet adapter like this.
+
+```typescript
+new SolanaMobileWalletAdapter({
+    addressSelector: createDefaultAddressSelector(),
+    appIdentity: {
+        name: 'My app',
+        uri: 'https://myapp.io',
+        icon: 'relative/path/to/icon.png',
+    },
+    authorizationResultCache: createDefaultAuthorizationResultCache(),
+    cluster: WalletAdapterNetwork.Devnet,
+    onWalletNotFound: createDefaultWalletNotFoundHandler(),
+});
+```
+
+Developers who use `@solana/wallet-adapter-react@">=0.15.21"` can supply this custom instance to `WalletProvider` which will use it to override the default one.
+
+```typescript
+const wallets = useMemo(
+    () => [
+        new SolanaMobileWalletAdapter({
+            addressSelector: createDefaultAddressSelector(),
+            appIdentity: {
+                name: 'My app',
+                uri: 'https://myapp.io',
+                icon: 'relative/path/to/icon.png',
+            },
+            authorizationResultCache: createDefaultAuthorizationResultCache(),
+            cluster: WalletAdapterNetwork.Devnet,
+            onWalletNotFound: createDefaultWalletNotFoundHandler(),
+        }),
+    ],
+    [],
+);
+
+return (
+    <ConnectionProvider endpoint={clusterApiUrl(WalletAdapterNetwork.Devnet)}>
+        <WalletProvider wallets={wallets}>
+            <MyApp />
+        </WalletProvider>
+    </ConnectionProvider>
+)
+```
+
+For more information about how to use wallet adapter plugins, visit https://github.com/solana-labs/wallet-adapter
+
+## Configuration
+
+### App identity
+
+The `AppIdentity` config identifies your app to a native mobile wallet. When someone connects to a wallet for the first time, the wallet may present this information in the on-screen prompt where the ask if the visitor would like to authorize your app for use with their account.
+
+- `name` &ndash; The plain-language name of your application.
+- `uri` &ndash; The uri of your application. This uri may be required to participate in [dApp identity verification](https://github.com/solana-mobile/mobile-wallet-adapter/blob/main/spec/spec.md#dapp-identity-verification) as part of the mobile wallet adapter protocol specification.
+- `icon` &ndash; An icon file path, relative to the `uri`.
+
+### Address selector
+
+The Mobile Wallet Adapter specification allows a wallet to authorize a dApp to use one or more addresses. dApps must supply code to select a single address for use in the adapter. That code must conform to the `AddressSelector` interface.
+
+```typescript
+export interface AddressSelector {
+    select(addresses: Base64EncodedAddress[]): Promise<Base64EncodedAddress>;
+}
+```
+
+Alternatively, you can use the included `createDefaultAddressSelector()` method to create a selector that always chooses the first address in the list.
+
+### Authorization result cache
+
+The first time that someone authorizes a native wallet app for use with your application, you should cache that authorization for future use. You can supply your own implementation that conforms to the `AuthorizationResultCache` interface.
+
+```typescript
+export interface AuthorizationResultCache {
+    clear(): Promise<void>;
+    get(): Promise<AuthorizationResult | undefined>;
+    set(authorizationResult: AuthorizationResult): Promise<void>;
+}
+```
+
+Alternatively, you can use the included `createDefaultAuthorizationResultCache()` method to create a cache that reads and writes the adapter's last-obtained `AuthorizationResult` to your browser's local storage, if available.
+
+### Cluster
+
+Each authorization a dApp makes with a wallet is tied to a particular Solana cluster. If a dApp wants to change the cluster on which to transact, it must seek an authorization for that cluster.
+
+### Wallet-not-found handler
+
+When you call `connect()` but no wallet responds within a reasonable amount of time, it is presumed that no compatible wallet is installed. You must supply an `onWalletNotFound` function to handle this case.
+
+Alternatively, you can use the included `createDefaultWalletNotFoundHandler()` method to create a function that opens the Solana Mobile ecosystem wallets webpage.
+
+## Android Chrome Browser Issues
+
+Chrome on Android has a policy of blocking all navigation that does not come from explicit user gestures (click, tap, swipe, keypress). As a result, MWA Intent navigation to a wallet app will be blocked if it does not come from a user gesture.
+
+You will see an error like:
+
+```
+Navigation is blocked: solana-wallet:/v1/associate...
+```
+
+There isn't a way around this on the Android Chrome Browser, but you can write a mobile app if you need this behavior.

node_modules/@solana-mobile/wallet-adapter-mobile/lib/cjs/index.browser.js

@@ -0,0 +1,349 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _solana_wallet_adapter_base = require("@solana/wallet-adapter-base");
+let _solana_wallet_standard_features = require("@solana/wallet-standard-features");
+let _solana_web3_js = require("@solana/web3.js");
+let _solana_mobile_wallet_standard_mobile = require("@solana-mobile/wallet-standard-mobile");
+let _wallet_standard_core = require("@wallet-standard/core");
+//#region src/base64Utils.ts
+function fromUint8Array(byteArray) {
+	return window.btoa(String.fromCharCode.call(null, ...byteArray));
+}
+//#endregion
+//#region src/getIsSupported.ts
+function getIsSupported() {
+	return typeof window !== "undefined" && window.isSecureContext && typeof document !== "undefined" && /android/i.test(navigator.userAgent);
+}
+//#endregion
+//#region src/adapter.ts
+const SolanaMobileWalletAdapterWalletName = _solana_mobile_wallet_standard_mobile.SolanaMobileWalletAdapterWalletName;
+const SolanaMobileWalletAdapterRemoteWalletName = _solana_mobile_wallet_standard_mobile.SolanaMobileWalletAdapterRemoteWalletName;
+const SIGNATURE_LENGTH_IN_BYTES = 64;
+function isVersionedTransaction(transaction) {
+	return "version" in transaction;
+}
+function chainOrClusterToChainId(chain) {
+	switch (chain) {
+		case "mainnet-beta": return "solana:mainnet";
+		case "testnet": return "solana:testnet";
+		case "devnet": return "solana:devnet";
+		default: return chain;
+	}
+}
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : "Unknown error";
+}
+var BaseSolanaMobileWalletAdapter = class extends _solana_wallet_adapter_base.BaseSignInMessageSignerWalletAdapter {
+	supportedTransactionVersions = new Set(["legacy", 0]);
+	name;
+	icon;
+	url;
+	#wallet;
+	#connecting = false;
+	#readyState = getIsSupported() ? _solana_wallet_adapter_base.WalletReadyState.Loadable : _solana_wallet_adapter_base.WalletReadyState.Unsupported;
+	#accountSelector;
+	#selectedAccount;
+	#publicKey;
+	#handleChangeEvent = async (properties) => {
+		if (properties.accounts && properties.accounts.length > 0) {
+			this.#declareWalletAsInstalled();
+			const nextSelectedAccount = await this.#accountSelector(properties.accounts);
+			if (nextSelectedAccount !== this.#selectedAccount) {
+				this.#selectedAccount = nextSelectedAccount;
+				this.#publicKey = void 0;
+				this.emit("connect", this.publicKey);
+			}
+		}
+	};
+	constructor(wallet, config) {
+		super();
+		this.#accountSelector = async (accounts) => {
+			const selectedBase64EncodedAddress = await config.addressSelector.select(accounts.map(({ publicKey }) => fromUint8Array(new Uint8Array(publicKey))));
+			return accounts.find(({ publicKey }) => fromUint8Array(new Uint8Array(publicKey)) === selectedBase64EncodedAddress) ?? accounts[0];
+		};
+		this.#wallet = wallet;
+		this.#wallet.features[_wallet_standard_core.StandardEvents].on("change", this.#handleChangeEvent);
+		this.name = this.#wallet.name;
+		this.icon = this.#wallet.icon;
+		this.url = this.#wallet.url;
+	}
+	get publicKey() {
+		if (!this.#publicKey && this.#selectedAccount) try {
+			this.#publicKey = new _solana_web3_js.PublicKey(this.#selectedAccount.publicKey);
+		} catch (e) {
+			throw new _solana_wallet_adapter_base.WalletPublicKeyError(e instanceof Error && e?.message || "Unknown error", e);
+		}
+		return this.#publicKey ?? null;
+	}
+	get connected() {
+		return this.#wallet.connected;
+	}
+	get connecting() {
+		return this.#connecting;
+	}
+	get readyState() {
+		return this.#readyState;
+	}
+	/** @deprecated Use `autoConnect()` instead. */
+	async autoConnect_DO_NOT_USE_OR_YOU_WILL_BE_FIRED() {
+		return await this.autoConnect();
+	}
+	async autoConnect() {
+		this.#connect(true);
+	}
+	async connect() {
+		this.#connect();
+	}
+	async #connect(autoConnect = false) {
+		if (this.connecting || this.connected) return;
+		return await this.#runWithGuard(async () => {
+			if (this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Installed && this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Loadable) throw new _solana_wallet_adapter_base.WalletNotReadyError();
+			this.#connecting = true;
+			try {
+				await this.#wallet.features[_wallet_standard_core.StandardConnect].connect({ silent: autoConnect });
+			} catch (e) {
+				throw new _solana_wallet_adapter_base.WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+			} finally {
+				this.#connecting = false;
+			}
+		});
+	}
+	/** @deprecated Use `connect()` or `autoConnect()` instead. */
+	async performAuthorization(signInPayload) {
+		try {
+			const cachedAuthorizationResult = await this.#wallet.cachedAuthorizationResult;
+			if (cachedAuthorizationResult) {
+				await this.#wallet.features[_wallet_standard_core.StandardConnect].connect({ silent: true });
+				return cachedAuthorizationResult;
+			}
+			if (signInPayload) await this.#wallet.features[_solana_wallet_standard_features.SolanaSignIn].signIn(signInPayload);
+			else await this.#wallet.features[_wallet_standard_core.StandardConnect].connect();
+			return await await this.#wallet.cachedAuthorizationResult;
+		} catch (e) {
+			throw new _solana_wallet_adapter_base.WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+		}
+	}
+	async disconnect() {
+		return await this.#runWithGuard(async () => {
+			this.#connecting = false;
+			this.#publicKey = void 0;
+			this.#selectedAccount = void 0;
+			await this.#wallet.features[_wallet_standard_core.StandardDisconnect].disconnect();
+			this.emit("disconnect");
+		});
+	}
+	async signIn(input) {
+		return this.#runWithGuard(async () => {
+			if (this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Installed && this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Loadable) throw new _solana_wallet_adapter_base.WalletNotReadyError();
+			this.#connecting = true;
+			try {
+				const outputs = await this.#wallet.features[_solana_wallet_standard_features.SolanaSignIn].signIn({
+					...input,
+					domain: input?.domain ?? window.location.host
+				});
+				if (outputs.length > 0) return outputs[0];
+				else throw new Error("Sign in failed, no sign in result returned by wallet");
+			} catch (e) {
+				throw new _solana_wallet_adapter_base.WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+			} finally {
+				this.#connecting = false;
+			}
+		});
+	}
+	async signMessage(message) {
+		return await this.#runWithGuard(async () => {
+			const account = this.#assertIsAuthorized();
+			try {
+				return (await this.#wallet.features[_solana_wallet_standard_features.SolanaSignMessage].signMessage({
+					account,
+					message
+				}))[0].signature;
+			} catch (error) {
+				throw new _solana_wallet_adapter_base.WalletSignMessageError(getErrorMessage(error), error);
+			}
+		});
+	}
+	async sendTransaction(transaction, connection, options) {
+		return await this.#runWithGuard(async () => {
+			const account = this.#assertIsAuthorized();
+			try {
+				function getTargetCommitment() {
+					let targetCommitment;
+					switch (connection.commitment) {
+						case "confirmed":
+						case "finalized":
+						case "processed":
+							targetCommitment = connection.commitment;
+							break;
+						default: targetCommitment = "finalized";
+					}
+					let targetPreflightCommitment;
+					switch (options?.preflightCommitment) {
+						case "confirmed":
+						case "finalized":
+						case "processed":
+							targetPreflightCommitment = options.preflightCommitment;
+							break;
+						case void 0:
+							targetPreflightCommitment = targetCommitment;
+							break;
+						default: targetPreflightCommitment = "finalized";
+					}
+					return (targetPreflightCommitment === "finalized" ? 2 : targetPreflightCommitment === "confirmed" ? 1 : 0) < (targetCommitment === "finalized" ? 2 : targetCommitment === "confirmed" ? 1 : 0) ? targetPreflightCommitment : targetCommitment;
+				}
+				if (_solana_wallet_standard_features.SolanaSignAndSendTransaction in this.#wallet.features) {
+					const chain = chainOrClusterToChainId(this.#wallet.currentAuthorization.chain);
+					const [signature] = (await this.#wallet.features[_solana_wallet_standard_features.SolanaSignAndSendTransaction].signAndSendTransaction({
+						account,
+						transaction: transaction.serialize(),
+						chain,
+						options: options ? {
+							skipPreflight: options.skipPreflight,
+							maxRetries: options.maxRetries
+						} : void 0
+					})).map((output) => {
+						return fromUint8Array(output.signature);
+					});
+					return signature;
+				} else {
+					const [signedTransaction] = await this.#performSignTransactions([transaction]);
+					if (isVersionedTransaction(signedTransaction)) return await connection.sendTransaction(signedTransaction);
+					else {
+						const serializedTransaction = signedTransaction.serialize();
+						return await connection.sendRawTransaction(serializedTransaction, {
+							...options,
+							preflightCommitment: getTargetCommitment()
+						});
+					}
+				}
+			} catch (error) {
+				throw new _solana_wallet_adapter_base.WalletSendTransactionError(getErrorMessage(error), error);
+			}
+		});
+	}
+	async signTransaction(transaction) {
+		return await this.#runWithGuard(async () => {
+			const [signedTransaction] = await this.#performSignTransactions([transaction]);
+			return signedTransaction;
+		});
+	}
+	async signAllTransactions(transactions) {
+		return await this.#runWithGuard(async () => {
+			return await this.#performSignTransactions(transactions);
+		});
+	}
+	#declareWalletAsInstalled() {
+		if (this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Installed) this.emit("readyStateChange", this.#readyState = _solana_wallet_adapter_base.WalletReadyState.Installed);
+	}
+	#assertIsAuthorized() {
+		if (!this.#wallet.isAuthorized || !this.#selectedAccount) throw new _solana_wallet_adapter_base.WalletNotConnectedError();
+		return this.#selectedAccount;
+	}
+	async #performSignTransactions(transactions) {
+		const account = this.#assertIsAuthorized();
+		try {
+			if (_solana_wallet_standard_features.SolanaSignTransaction in this.#wallet.features) return this.#wallet.features[_solana_wallet_standard_features.SolanaSignTransaction].signTransaction(...transactions.map((value) => {
+				return {
+					account,
+					transaction: value.serialize()
+				};
+			})).then((outputs) => {
+				return outputs.map((output) => {
+					const byteArray = output.signedTransaction;
+					const messageOffset = byteArray[0] * SIGNATURE_LENGTH_IN_BYTES + 1;
+					if (_solana_web3_js.VersionedMessage.deserializeMessageVersion(byteArray.slice(messageOffset, byteArray.length)) === "legacy") return _solana_web3_js.Transaction.from(byteArray);
+					else return _solana_web3_js.VersionedTransaction.deserialize(byteArray);
+				});
+			});
+			else throw new Error("Connected wallet does not support signing transactions");
+		} catch (error) {
+			throw new _solana_wallet_adapter_base.WalletSignTransactionError(getErrorMessage(error), error);
+		}
+	}
+	async #runWithGuard(callback) {
+		try {
+			return await callback();
+		} catch (e) {
+			this.emit("error", e instanceof _solana_wallet_adapter_base.WalletError ? e : new _solana_wallet_adapter_base.WalletError(getErrorMessage(e), e));
+			throw e;
+		}
+	}
+};
+var LocalSolanaMobileWalletAdapter = class extends BaseSolanaMobileWalletAdapter {
+	constructor(config) {
+		const chain = chainOrClusterToChainId(config.chain ?? config.cluster);
+		super(new _solana_mobile_wallet_standard_mobile.LocalSolanaMobileWalletAdapterWallet({
+			appIdentity: config.appIdentity,
+			authorizationCache: {
+				set: config.authorizationResultCache.set,
+				get: async () => {
+					return await config.authorizationResultCache.get();
+				},
+				clear: config.authorizationResultCache.clear
+			},
+			chains: [chain],
+			chainSelector: (0, _solana_mobile_wallet_standard_mobile.createDefaultChainSelector)(),
+			onWalletNotFound: async () => {
+				config.onWalletNotFound(this);
+			}
+		}), {
+			addressSelector: config.addressSelector,
+			chain
+		});
+	}
+};
+var RemoteSolanaMobileWalletAdapter = class extends BaseSolanaMobileWalletAdapter {
+	constructor(config) {
+		const chain = chainOrClusterToChainId(config.chain);
+		super(new _solana_mobile_wallet_standard_mobile.RemoteSolanaMobileWalletAdapterWallet({
+			appIdentity: config.appIdentity,
+			authorizationCache: {
+				set: config.authorizationResultCache.set,
+				get: async () => {
+					return await config.authorizationResultCache.get();
+				},
+				clear: config.authorizationResultCache.clear
+			},
+			chains: [chain],
+			chainSelector: (0, _solana_mobile_wallet_standard_mobile.createDefaultChainSelector)(),
+			remoteHostAuthority: config.remoteHostAuthority,
+			onWalletNotFound: async () => {
+				config.onWalletNotFound(this);
+			}
+		}), {
+			addressSelector: config.addressSelector,
+			chain
+		});
+	}
+};
+var SolanaMobileWalletAdapter = class extends LocalSolanaMobileWalletAdapter {};
+//#endregion
+//#region src/createDefaultAddressSelector.ts
+function createDefaultAddressSelector() {
+	return { async select(addresses) {
+		return addresses[0];
+	} };
+}
+//#endregion
+//#region src/createDefaultAuthorizationResultCache.ts
+function createDefaultAuthorizationResultCache() {
+	return (0, _solana_mobile_wallet_standard_mobile.createDefaultAuthorizationCache)();
+}
+//#endregion
+//#region src/createDefaultWalletNotFoundHandler.ts
+async function defaultWalletNotFoundHandler(_mobileWalletAdapter) {
+	return (0, _solana_mobile_wallet_standard_mobile.defaultErrorModalWalletNotFoundHandler)();
+}
+function createDefaultWalletNotFoundHandler() {
+	return defaultWalletNotFoundHandler;
+}
+//#endregion
+exports.LocalSolanaMobileWalletAdapter = LocalSolanaMobileWalletAdapter;
+exports.RemoteSolanaMobileWalletAdapter = RemoteSolanaMobileWalletAdapter;
+exports.SolanaMobileWalletAdapter = SolanaMobileWalletAdapter;
+exports.SolanaMobileWalletAdapterRemoteWalletName = SolanaMobileWalletAdapterRemoteWalletName;
+exports.SolanaMobileWalletAdapterWalletName = SolanaMobileWalletAdapterWalletName;
+exports.createDefaultAddressSelector = createDefaultAddressSelector;
+exports.createDefaultAuthorizationResultCache = createDefaultAuthorizationResultCache;
+exports.createDefaultWalletNotFoundHandler = createDefaultWalletNotFoundHandler;
+
+//# sourceMappingURL=index.browser.js.map

node_modules/@solana-mobile/wallet-adapter-mobile/lib/cjs/index.js

@@ -0,0 +1,349 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _solana_wallet_adapter_base = require("@solana/wallet-adapter-base");
+let _solana_wallet_standard_features = require("@solana/wallet-standard-features");
+let _solana_web3_js = require("@solana/web3.js");
+let _solana_mobile_wallet_standard_mobile = require("@solana-mobile/wallet-standard-mobile");
+let _wallet_standard_core = require("@wallet-standard/core");
+//#region src/base64Utils.ts
+function fromUint8Array(byteArray) {
+	return window.btoa(String.fromCharCode.call(null, ...byteArray));
+}
+//#endregion
+//#region src/getIsSupported.ts
+function getIsSupported() {
+	return typeof window !== "undefined" && window.isSecureContext && typeof document !== "undefined" && /android/i.test(navigator.userAgent);
+}
+//#endregion
+//#region src/adapter.ts
+const SolanaMobileWalletAdapterWalletName = _solana_mobile_wallet_standard_mobile.SolanaMobileWalletAdapterWalletName;
+const SolanaMobileWalletAdapterRemoteWalletName = _solana_mobile_wallet_standard_mobile.SolanaMobileWalletAdapterRemoteWalletName;
+const SIGNATURE_LENGTH_IN_BYTES = 64;
+function isVersionedTransaction(transaction) {
+	return "version" in transaction;
+}
+function chainOrClusterToChainId(chain) {
+	switch (chain) {
+		case "mainnet-beta": return "solana:mainnet";
+		case "testnet": return "solana:testnet";
+		case "devnet": return "solana:devnet";
+		default: return chain;
+	}
+}
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : "Unknown error";
+}
+var BaseSolanaMobileWalletAdapter = class extends _solana_wallet_adapter_base.BaseSignInMessageSignerWalletAdapter {
+	supportedTransactionVersions = new Set(["legacy", 0]);
+	name;
+	icon;
+	url;
+	#wallet;
+	#connecting = false;
+	#readyState = getIsSupported() ? _solana_wallet_adapter_base.WalletReadyState.Loadable : _solana_wallet_adapter_base.WalletReadyState.Unsupported;
+	#accountSelector;
+	#selectedAccount;
+	#publicKey;
+	#handleChangeEvent = async (properties) => {
+		if (properties.accounts && properties.accounts.length > 0) {
+			this.#declareWalletAsInstalled();
+			const nextSelectedAccount = await this.#accountSelector(properties.accounts);
+			if (nextSelectedAccount !== this.#selectedAccount) {
+				this.#selectedAccount = nextSelectedAccount;
+				this.#publicKey = void 0;
+				this.emit("connect", this.publicKey);
+			}
+		}
+	};
+	constructor(wallet, config) {
+		super();
+		this.#accountSelector = async (accounts) => {
+			const selectedBase64EncodedAddress = await config.addressSelector.select(accounts.map(({ publicKey }) => fromUint8Array(new Uint8Array(publicKey))));
+			return accounts.find(({ publicKey }) => fromUint8Array(new Uint8Array(publicKey)) === selectedBase64EncodedAddress) ?? accounts[0];
+		};
+		this.#wallet = wallet;
+		this.#wallet.features[_wallet_standard_core.StandardEvents].on("change", this.#handleChangeEvent);
+		this.name = this.#wallet.name;
+		this.icon = this.#wallet.icon;
+		this.url = this.#wallet.url;
+	}
+	get publicKey() {
+		if (!this.#publicKey && this.#selectedAccount) try {
+			this.#publicKey = new _solana_web3_js.PublicKey(this.#selectedAccount.publicKey);
+		} catch (e) {
+			throw new _solana_wallet_adapter_base.WalletPublicKeyError(e instanceof Error && e?.message || "Unknown error", e);
+		}
+		return this.#publicKey ?? null;
+	}
+	get connected() {
+		return this.#wallet.connected;
+	}
+	get connecting() {
+		return this.#connecting;
+	}
+	get readyState() {
+		return this.#readyState;
+	}
+	/** @deprecated Use `autoConnect()` instead. */
+	async autoConnect_DO_NOT_USE_OR_YOU_WILL_BE_FIRED() {
+		return await this.autoConnect();
+	}
+	async autoConnect() {
+		this.#connect(true);
+	}
+	async connect() {
+		this.#connect();
+	}
+	async #connect(autoConnect = false) {
+		if (this.connecting || this.connected) return;
+		return await this.#runWithGuard(async () => {
+			if (this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Installed && this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Loadable) throw new _solana_wallet_adapter_base.WalletNotReadyError();
+			this.#connecting = true;
+			try {
+				await this.#wallet.features[_wallet_standard_core.StandardConnect].connect({ silent: autoConnect });
+			} catch (e) {
+				throw new _solana_wallet_adapter_base.WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+			} finally {
+				this.#connecting = false;
+			}
+		});
+	}
+	/** @deprecated Use `connect()` or `autoConnect()` instead. */
+	async performAuthorization(signInPayload) {
+		try {
+			const cachedAuthorizationResult = await this.#wallet.cachedAuthorizationResult;
+			if (cachedAuthorizationResult) {
+				await this.#wallet.features[_wallet_standard_core.StandardConnect].connect({ silent: true });
+				return cachedAuthorizationResult;
+			}
+			if (signInPayload) await this.#wallet.features[_solana_wallet_standard_features.SolanaSignIn].signIn(signInPayload);
+			else await this.#wallet.features[_wallet_standard_core.StandardConnect].connect();
+			return await await this.#wallet.cachedAuthorizationResult;
+		} catch (e) {
+			throw new _solana_wallet_adapter_base.WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+		}
+	}
+	async disconnect() {
+		return await this.#runWithGuard(async () => {
+			this.#connecting = false;
+			this.#publicKey = void 0;
+			this.#selectedAccount = void 0;
+			await this.#wallet.features[_wallet_standard_core.StandardDisconnect].disconnect();
+			this.emit("disconnect");
+		});
+	}
+	async signIn(input) {
+		return this.#runWithGuard(async () => {
+			if (this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Installed && this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Loadable) throw new _solana_wallet_adapter_base.WalletNotReadyError();
+			this.#connecting = true;
+			try {
+				const outputs = await this.#wallet.features[_solana_wallet_standard_features.SolanaSignIn].signIn({
+					...input,
+					domain: input?.domain ?? window.location.host
+				});
+				if (outputs.length > 0) return outputs[0];
+				else throw new Error("Sign in failed, no sign in result returned by wallet");
+			} catch (e) {
+				throw new _solana_wallet_adapter_base.WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+			} finally {
+				this.#connecting = false;
+			}
+		});
+	}
+	async signMessage(message) {
+		return await this.#runWithGuard(async () => {
+			const account = this.#assertIsAuthorized();
+			try {
+				return (await this.#wallet.features[_solana_wallet_standard_features.SolanaSignMessage].signMessage({
+					account,
+					message
+				}))[0].signature;
+			} catch (error) {
+				throw new _solana_wallet_adapter_base.WalletSignMessageError(getErrorMessage(error), error);
+			}
+		});
+	}
+	async sendTransaction(transaction, connection, options) {
+		return await this.#runWithGuard(async () => {
+			const account = this.#assertIsAuthorized();
+			try {
+				function getTargetCommitment() {
+					let targetCommitment;
+					switch (connection.commitment) {
+						case "confirmed":
+						case "finalized":
+						case "processed":
+							targetCommitment = connection.commitment;
+							break;
+						default: targetCommitment = "finalized";
+					}
+					let targetPreflightCommitment;
+					switch (options?.preflightCommitment) {
+						case "confirmed":
+						case "finalized":
+						case "processed":
+							targetPreflightCommitment = options.preflightCommitment;
+							break;
+						case void 0:
+							targetPreflightCommitment = targetCommitment;
+							break;
+						default: targetPreflightCommitment = "finalized";
+					}
+					return (targetPreflightCommitment === "finalized" ? 2 : targetPreflightCommitment === "confirmed" ? 1 : 0) < (targetCommitment === "finalized" ? 2 : targetCommitment === "confirmed" ? 1 : 0) ? targetPreflightCommitment : targetCommitment;
+				}
+				if (_solana_wallet_standard_features.SolanaSignAndSendTransaction in this.#wallet.features) {
+					const chain = chainOrClusterToChainId(this.#wallet.currentAuthorization.chain);
+					const [signature] = (await this.#wallet.features[_solana_wallet_standard_features.SolanaSignAndSendTransaction].signAndSendTransaction({
+						account,
+						transaction: transaction.serialize(),
+						chain,
+						options: options ? {
+							skipPreflight: options.skipPreflight,
+							maxRetries: options.maxRetries
+						} : void 0
+					})).map((output) => {
+						return fromUint8Array(output.signature);
+					});
+					return signature;
+				} else {
+					const [signedTransaction] = await this.#performSignTransactions([transaction]);
+					if (isVersionedTransaction(signedTransaction)) return await connection.sendTransaction(signedTransaction);
+					else {
+						const serializedTransaction = signedTransaction.serialize();
+						return await connection.sendRawTransaction(serializedTransaction, {
+							...options,
+							preflightCommitment: getTargetCommitment()
+						});
+					}
+				}
+			} catch (error) {
+				throw new _solana_wallet_adapter_base.WalletSendTransactionError(getErrorMessage(error), error);
+			}
+		});
+	}
+	async signTransaction(transaction) {
+		return await this.#runWithGuard(async () => {
+			const [signedTransaction] = await this.#performSignTransactions([transaction]);
+			return signedTransaction;
+		});
+	}
+	async signAllTransactions(transactions) {
+		return await this.#runWithGuard(async () => {
+			return await this.#performSignTransactions(transactions);
+		});
+	}
+	#declareWalletAsInstalled() {
+		if (this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Installed) this.emit("readyStateChange", this.#readyState = _solana_wallet_adapter_base.WalletReadyState.Installed);
+	}
+	#assertIsAuthorized() {
+		if (!this.#wallet.isAuthorized || !this.#selectedAccount) throw new _solana_wallet_adapter_base.WalletNotConnectedError();
+		return this.#selectedAccount;
+	}
+	async #performSignTransactions(transactions) {
+		const account = this.#assertIsAuthorized();
+		try {
+			if (_solana_wallet_standard_features.SolanaSignTransaction in this.#wallet.features) return this.#wallet.features[_solana_wallet_standard_features.SolanaSignTransaction].signTransaction(...transactions.map((value) => {
+				return {
+					account,
+					transaction: value.serialize()
+				};
+			})).then((outputs) => {
+				return outputs.map((output) => {
+					const byteArray = output.signedTransaction;
+					const messageOffset = byteArray[0] * SIGNATURE_LENGTH_IN_BYTES + 1;
+					if (_solana_web3_js.VersionedMessage.deserializeMessageVersion(byteArray.slice(messageOffset, byteArray.length)) === "legacy") return _solana_web3_js.Transaction.from(byteArray);
+					else return _solana_web3_js.VersionedTransaction.deserialize(byteArray);
+				});
+			});
+			else throw new Error("Connected wallet does not support signing transactions");
+		} catch (error) {
+			throw new _solana_wallet_adapter_base.WalletSignTransactionError(getErrorMessage(error), error);
+		}
+	}
+	async #runWithGuard(callback) {
+		try {
+			return await callback();
+		} catch (e) {
+			this.emit("error", e instanceof _solana_wallet_adapter_base.WalletError ? e : new _solana_wallet_adapter_base.WalletError(getErrorMessage(e), e));
+			throw e;
+		}
+	}
+};
+var LocalSolanaMobileWalletAdapter = class extends BaseSolanaMobileWalletAdapter {
+	constructor(config) {
+		const chain = chainOrClusterToChainId(config.chain ?? config.cluster);
+		super(new _solana_mobile_wallet_standard_mobile.LocalSolanaMobileWalletAdapterWallet({
+			appIdentity: config.appIdentity,
+			authorizationCache: {
+				set: config.authorizationResultCache.set,
+				get: async () => {
+					return await config.authorizationResultCache.get();
+				},
+				clear: config.authorizationResultCache.clear
+			},
+			chains: [chain],
+			chainSelector: (0, _solana_mobile_wallet_standard_mobile.createDefaultChainSelector)(),
+			onWalletNotFound: async () => {
+				config.onWalletNotFound(this);
+			}
+		}), {
+			addressSelector: config.addressSelector,
+			chain
+		});
+	}
+};
+var RemoteSolanaMobileWalletAdapter = class extends BaseSolanaMobileWalletAdapter {
+	constructor(config) {
+		const chain = chainOrClusterToChainId(config.chain);
+		super(new _solana_mobile_wallet_standard_mobile.RemoteSolanaMobileWalletAdapterWallet({
+			appIdentity: config.appIdentity,
+			authorizationCache: {
+				set: config.authorizationResultCache.set,
+				get: async () => {
+					return await config.authorizationResultCache.get();
+				},
+				clear: config.authorizationResultCache.clear
+			},
+			chains: [chain],
+			chainSelector: (0, _solana_mobile_wallet_standard_mobile.createDefaultChainSelector)(),
+			remoteHostAuthority: config.remoteHostAuthority,
+			onWalletNotFound: async () => {
+				config.onWalletNotFound(this);
+			}
+		}), {
+			addressSelector: config.addressSelector,
+			chain
+		});
+	}
+};
+var SolanaMobileWalletAdapter = class extends LocalSolanaMobileWalletAdapter {};
+//#endregion
+//#region src/createDefaultAddressSelector.ts
+function createDefaultAddressSelector() {
+	return { async select(addresses) {
+		return addresses[0];
+	} };
+}
+//#endregion
+//#region src/createDefaultAuthorizationResultCache.ts
+function createDefaultAuthorizationResultCache() {
+	return (0, _solana_mobile_wallet_standard_mobile.createDefaultAuthorizationCache)();
+}
+//#endregion
+//#region src/createDefaultWalletNotFoundHandler.ts
+async function defaultWalletNotFoundHandler(_mobileWalletAdapter) {
+	return (0, _solana_mobile_wallet_standard_mobile.defaultErrorModalWalletNotFoundHandler)();
+}
+function createDefaultWalletNotFoundHandler() {
+	return defaultWalletNotFoundHandler;
+}
+//#endregion
+exports.LocalSolanaMobileWalletAdapter = LocalSolanaMobileWalletAdapter;
+exports.RemoteSolanaMobileWalletAdapter = RemoteSolanaMobileWalletAdapter;
+exports.SolanaMobileWalletAdapter = SolanaMobileWalletAdapter;
+exports.SolanaMobileWalletAdapterRemoteWalletName = SolanaMobileWalletAdapterRemoteWalletName;
+exports.SolanaMobileWalletAdapterWalletName = SolanaMobileWalletAdapterWalletName;
+exports.createDefaultAddressSelector = createDefaultAddressSelector;
+exports.createDefaultAuthorizationResultCache = createDefaultAuthorizationResultCache;
+exports.createDefaultWalletNotFoundHandler = createDefaultWalletNotFoundHandler;
+
+//# sourceMappingURL=index.js.map

node_modules/@solana-mobile/wallet-adapter-mobile/lib/cjs/index.native.js

@@ -0,0 +1,387 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _solana_wallet_adapter_base = require("@solana/wallet-adapter-base");
+let _solana_wallet_standard_features = require("@solana/wallet-standard-features");
+let _solana_web3_js = require("@solana/web3.js");
+let _solana_mobile_wallet_standard_mobile = require("@solana-mobile/wallet-standard-mobile");
+let _wallet_standard_core = require("@wallet-standard/core");
+let js_base64 = require("js-base64");
+let react_native = require("react-native");
+let _react_native_async_storage_async_storage = require("@react-native-async-storage/async-storage");
+_react_native_async_storage_async_storage = __toESM(_react_native_async_storage_async_storage);
+//#region src/__forks__/react-native/getIsSupported.ts
+function getIsSupported() {
+	return react_native.Platform.OS === "android";
+}
+//#endregion
+//#region src/adapter.ts
+const SolanaMobileWalletAdapterWalletName = _solana_mobile_wallet_standard_mobile.SolanaMobileWalletAdapterWalletName;
+const SolanaMobileWalletAdapterRemoteWalletName = _solana_mobile_wallet_standard_mobile.SolanaMobileWalletAdapterRemoteWalletName;
+const SIGNATURE_LENGTH_IN_BYTES = 64;
+function isVersionedTransaction(transaction) {
+	return "version" in transaction;
+}
+function chainOrClusterToChainId(chain) {
+	switch (chain) {
+		case "mainnet-beta": return "solana:mainnet";
+		case "testnet": return "solana:testnet";
+		case "devnet": return "solana:devnet";
+		default: return chain;
+	}
+}
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : "Unknown error";
+}
+var BaseSolanaMobileWalletAdapter = class extends _solana_wallet_adapter_base.BaseSignInMessageSignerWalletAdapter {
+	supportedTransactionVersions = new Set(["legacy", 0]);
+	name;
+	icon;
+	url;
+	#wallet;
+	#connecting = false;
+	#readyState = getIsSupported() ? _solana_wallet_adapter_base.WalletReadyState.Loadable : _solana_wallet_adapter_base.WalletReadyState.Unsupported;
+	#accountSelector;
+	#selectedAccount;
+	#publicKey;
+	#handleChangeEvent = async (properties) => {
+		if (properties.accounts && properties.accounts.length > 0) {
+			this.#declareWalletAsInstalled();
+			const nextSelectedAccount = await this.#accountSelector(properties.accounts);
+			if (nextSelectedAccount !== this.#selectedAccount) {
+				this.#selectedAccount = nextSelectedAccount;
+				this.#publicKey = void 0;
+				this.emit("connect", this.publicKey);
+			}
+		}
+	};
+	constructor(wallet, config) {
+		super();
+		this.#accountSelector = async (accounts) => {
+			const selectedBase64EncodedAddress = await config.addressSelector.select(accounts.map(({ publicKey }) => (0, js_base64.fromUint8Array)(new Uint8Array(publicKey))));
+			return accounts.find(({ publicKey }) => (0, js_base64.fromUint8Array)(new Uint8Array(publicKey)) === selectedBase64EncodedAddress) ?? accounts[0];
+		};
+		this.#wallet = wallet;
+		this.#wallet.features[_wallet_standard_core.StandardEvents].on("change", this.#handleChangeEvent);
+		this.name = this.#wallet.name;
+		this.icon = this.#wallet.icon;
+		this.url = this.#wallet.url;
+	}
+	get publicKey() {
+		if (!this.#publicKey && this.#selectedAccount) try {
+			this.#publicKey = new _solana_web3_js.PublicKey(this.#selectedAccount.publicKey);
+		} catch (e) {
+			throw new _solana_wallet_adapter_base.WalletPublicKeyError(e instanceof Error && e?.message || "Unknown error", e);
+		}
+		return this.#publicKey ?? null;
+	}
+	get connected() {
+		return this.#wallet.connected;
+	}
+	get connecting() {
+		return this.#connecting;
+	}
+	get readyState() {
+		return this.#readyState;
+	}
+	/** @deprecated Use `autoConnect()` instead. */
+	async autoConnect_DO_NOT_USE_OR_YOU_WILL_BE_FIRED() {
+		return await this.autoConnect();
+	}
+	async autoConnect() {
+		this.#connect(true);
+	}
+	async connect() {
+		this.#connect();
+	}
+	async #connect(autoConnect = false) {
+		if (this.connecting || this.connected) return;
+		return await this.#runWithGuard(async () => {
+			if (this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Installed && this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Loadable) throw new _solana_wallet_adapter_base.WalletNotReadyError();
+			this.#connecting = true;
+			try {
+				await this.#wallet.features[_wallet_standard_core.StandardConnect].connect({ silent: autoConnect });
+			} catch (e) {
+				throw new _solana_wallet_adapter_base.WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+			} finally {
+				this.#connecting = false;
+			}
+		});
+	}
+	/** @deprecated Use `connect()` or `autoConnect()` instead. */
+	async performAuthorization(signInPayload) {
+		try {
+			const cachedAuthorizationResult = await this.#wallet.cachedAuthorizationResult;
+			if (cachedAuthorizationResult) {
+				await this.#wallet.features[_wallet_standard_core.StandardConnect].connect({ silent: true });
+				return cachedAuthorizationResult;
+			}
+			if (signInPayload) await this.#wallet.features[_solana_wallet_standard_features.SolanaSignIn].signIn(signInPayload);
+			else await this.#wallet.features[_wallet_standard_core.StandardConnect].connect();
+			return await await this.#wallet.cachedAuthorizationResult;
+		} catch (e) {
+			throw new _solana_wallet_adapter_base.WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+		}
+	}
+	async disconnect() {
+		return await this.#runWithGuard(async () => {
+			this.#connecting = false;
+			this.#publicKey = void 0;
+			this.#selectedAccount = void 0;
+			await this.#wallet.features[_wallet_standard_core.StandardDisconnect].disconnect();
+			this.emit("disconnect");
+		});
+	}
+	async signIn(input) {
+		return this.#runWithGuard(async () => {
+			if (this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Installed && this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Loadable) throw new _solana_wallet_adapter_base.WalletNotReadyError();
+			this.#connecting = true;
+			try {
+				const outputs = await this.#wallet.features[_solana_wallet_standard_features.SolanaSignIn].signIn({
+					...input,
+					domain: input?.domain ?? window.location.host
+				});
+				if (outputs.length > 0) return outputs[0];
+				else throw new Error("Sign in failed, no sign in result returned by wallet");
+			} catch (e) {
+				throw new _solana_wallet_adapter_base.WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+			} finally {
+				this.#connecting = false;
+			}
+		});
+	}
+	async signMessage(message) {
+		return await this.#runWithGuard(async () => {
+			const account = this.#assertIsAuthorized();
+			try {
+				return (await this.#wallet.features[_solana_wallet_standard_features.SolanaSignMessage].signMessage({
+					account,
+					message
+				}))[0].signature;
+			} catch (error) {
+				throw new _solana_wallet_adapter_base.WalletSignMessageError(getErrorMessage(error), error);
+			}
+		});
+	}
+	async sendTransaction(transaction, connection, options) {
+		return await this.#runWithGuard(async () => {
+			const account = this.#assertIsAuthorized();
+			try {
+				function getTargetCommitment() {
+					let targetCommitment;
+					switch (connection.commitment) {
+						case "confirmed":
+						case "finalized":
+						case "processed":
+							targetCommitment = connection.commitment;
+							break;
+						default: targetCommitment = "finalized";
+					}
+					let targetPreflightCommitment;
+					switch (options?.preflightCommitment) {
+						case "confirmed":
+						case "finalized":
+						case "processed":
+							targetPreflightCommitment = options.preflightCommitment;
+							break;
+						case void 0:
+							targetPreflightCommitment = targetCommitment;
+							break;
+						default: targetPreflightCommitment = "finalized";
+					}
+					return (targetPreflightCommitment === "finalized" ? 2 : targetPreflightCommitment === "confirmed" ? 1 : 0) < (targetCommitment === "finalized" ? 2 : targetCommitment === "confirmed" ? 1 : 0) ? targetPreflightCommitment : targetCommitment;
+				}
+				if (_solana_wallet_standard_features.SolanaSignAndSendTransaction in this.#wallet.features) {
+					const chain = chainOrClusterToChainId(this.#wallet.currentAuthorization.chain);
+					const [signature] = (await this.#wallet.features[_solana_wallet_standard_features.SolanaSignAndSendTransaction].signAndSendTransaction({
+						account,
+						transaction: transaction.serialize(),
+						chain,
+						options: options ? {
+							skipPreflight: options.skipPreflight,
+							maxRetries: options.maxRetries
+						} : void 0
+					})).map((output) => {
+						return (0, js_base64.fromUint8Array)(output.signature);
+					});
+					return signature;
+				} else {
+					const [signedTransaction] = await this.#performSignTransactions([transaction]);
+					if (isVersionedTransaction(signedTransaction)) return await connection.sendTransaction(signedTransaction);
+					else {
+						const serializedTransaction = signedTransaction.serialize();
+						return await connection.sendRawTransaction(serializedTransaction, {
+							...options,
+							preflightCommitment: getTargetCommitment()
+						});
+					}
+				}
+			} catch (error) {
+				throw new _solana_wallet_adapter_base.WalletSendTransactionError(getErrorMessage(error), error);
+			}
+		});
+	}
+	async signTransaction(transaction) {
+		return await this.#runWithGuard(async () => {
+			const [signedTransaction] = await this.#performSignTransactions([transaction]);
+			return signedTransaction;
+		});
+	}
+	async signAllTransactions(transactions) {
+		return await this.#runWithGuard(async () => {
+			return await this.#performSignTransactions(transactions);
+		});
+	}
+	#declareWalletAsInstalled() {
+		if (this.#readyState !== _solana_wallet_adapter_base.WalletReadyState.Installed) this.emit("readyStateChange", this.#readyState = _solana_wallet_adapter_base.WalletReadyState.Installed);
+	}
+	#assertIsAuthorized() {
+		if (!this.#wallet.isAuthorized || !this.#selectedAccount) throw new _solana_wallet_adapter_base.WalletNotConnectedError();
+		return this.#selectedAccount;
+	}
+	async #performSignTransactions(transactions) {
+		const account = this.#assertIsAuthorized();
+		try {
+			if (_solana_wallet_standard_features.SolanaSignTransaction in this.#wallet.features) return this.#wallet.features[_solana_wallet_standard_features.SolanaSignTransaction].signTransaction(...transactions.map((value) => {
+				return {
+					account,
+					transaction: value.serialize()
+				};
+			})).then((outputs) => {
+				return outputs.map((output) => {
+					const byteArray = output.signedTransaction;
+					const messageOffset = byteArray[0] * SIGNATURE_LENGTH_IN_BYTES + 1;
+					if (_solana_web3_js.VersionedMessage.deserializeMessageVersion(byteArray.slice(messageOffset, byteArray.length)) === "legacy") return _solana_web3_js.Transaction.from(byteArray);
+					else return _solana_web3_js.VersionedTransaction.deserialize(byteArray);
+				});
+			});
+			else throw new Error("Connected wallet does not support signing transactions");
+		} catch (error) {
+			throw new _solana_wallet_adapter_base.WalletSignTransactionError(getErrorMessage(error), error);
+		}
+	}
+	async #runWithGuard(callback) {
+		try {
+			return await callback();
+		} catch (e) {
+			this.emit("error", e instanceof _solana_wallet_adapter_base.WalletError ? e : new _solana_wallet_adapter_base.WalletError(getErrorMessage(e), e));
+			throw e;
+		}
+	}
+};
+var LocalSolanaMobileWalletAdapter = class extends BaseSolanaMobileWalletAdapter {
+	constructor(config) {
+		const chain = chainOrClusterToChainId(config.chain ?? config.cluster);
+		super(new _solana_mobile_wallet_standard_mobile.LocalSolanaMobileWalletAdapterWallet({
+			appIdentity: config.appIdentity,
+			authorizationCache: {
+				set: config.authorizationResultCache.set,
+				get: async () => {
+					return await config.authorizationResultCache.get();
+				},
+				clear: config.authorizationResultCache.clear
+			},
+			chains: [chain],
+			chainSelector: (0, _solana_mobile_wallet_standard_mobile.createDefaultChainSelector)(),
+			onWalletNotFound: async () => {
+				config.onWalletNotFound(this);
+			}
+		}), {
+			addressSelector: config.addressSelector,
+			chain
+		});
+	}
+};
+var RemoteSolanaMobileWalletAdapter = class extends BaseSolanaMobileWalletAdapter {
+	constructor(config) {
+		const chain = chainOrClusterToChainId(config.chain);
+		super(new _solana_mobile_wallet_standard_mobile.RemoteSolanaMobileWalletAdapterWallet({
+			appIdentity: config.appIdentity,
+			authorizationCache: {
+				set: config.authorizationResultCache.set,
+				get: async () => {
+					return await config.authorizationResultCache.get();
+				},
+				clear: config.authorizationResultCache.clear
+			},
+			chains: [chain],
+			chainSelector: (0, _solana_mobile_wallet_standard_mobile.createDefaultChainSelector)(),
+			remoteHostAuthority: config.remoteHostAuthority,
+			onWalletNotFound: async () => {
+				config.onWalletNotFound(this);
+			}
+		}), {
+			addressSelector: config.addressSelector,
+			chain
+		});
+	}
+};
+var SolanaMobileWalletAdapter = class extends LocalSolanaMobileWalletAdapter {};
+//#endregion
+//#region src/createDefaultAddressSelector.ts
+function createDefaultAddressSelector() {
+	return { async select(addresses) {
+		return addresses[0];
+	} };
+}
+//#endregion
+//#region src/__forks__/react-native/createDefaultAuthorizationResultCache.ts
+const CACHE_KEY = "SolanaMobileWalletAdapterDefaultAuthorizationCache";
+function createDefaultAuthorizationResultCache() {
+	return {
+		async clear() {
+			try {
+				await _react_native_async_storage_async_storage.default.removeItem(CACHE_KEY);
+			} catch {}
+		},
+		async get() {
+			try {
+				return JSON.parse(await _react_native_async_storage_async_storage.default.getItem(CACHE_KEY)) || void 0;
+			} catch {}
+		},
+		async set(authorizationResult) {
+			try {
+				await _react_native_async_storage_async_storage.default.setItem(CACHE_KEY, JSON.stringify(authorizationResult));
+			} catch {}
+		}
+	};
+}
+//#endregion
+//#region src/createDefaultWalletNotFoundHandler.ts
+async function defaultWalletNotFoundHandler(_mobileWalletAdapter) {
+	return (0, _solana_mobile_wallet_standard_mobile.defaultErrorModalWalletNotFoundHandler)();
+}
+function createDefaultWalletNotFoundHandler() {
+	return defaultWalletNotFoundHandler;
+}
+//#endregion
+exports.LocalSolanaMobileWalletAdapter = LocalSolanaMobileWalletAdapter;
+exports.RemoteSolanaMobileWalletAdapter = RemoteSolanaMobileWalletAdapter;
+exports.SolanaMobileWalletAdapter = SolanaMobileWalletAdapter;
+exports.SolanaMobileWalletAdapterRemoteWalletName = SolanaMobileWalletAdapterRemoteWalletName;
+exports.SolanaMobileWalletAdapterWalletName = SolanaMobileWalletAdapterWalletName;
+exports.createDefaultAddressSelector = createDefaultAddressSelector;
+exports.createDefaultAuthorizationResultCache = createDefaultAuthorizationResultCache;
+exports.createDefaultWalletNotFoundHandler = createDefaultWalletNotFoundHandler;
+
+//# sourceMappingURL=index.native.js.map

node_modules/@solana-mobile/wallet-adapter-mobile/lib/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

node_modules/@solana-mobile/wallet-adapter-mobile/lib/esm/index.browser.js

@@ -0,0 +1,341 @@
+import { BaseSignInMessageSignerWalletAdapter, WalletConnectionError, WalletError, WalletNotConnectedError, WalletNotReadyError, WalletPublicKeyError, WalletReadyState, WalletSendTransactionError, WalletSignMessageError, WalletSignTransactionError } from "@solana/wallet-adapter-base";
+import { SolanaSignAndSendTransaction, SolanaSignIn, SolanaSignMessage, SolanaSignTransaction } from "@solana/wallet-standard-features";
+import { PublicKey, Transaction, VersionedMessage, VersionedTransaction } from "@solana/web3.js";
+import { LocalSolanaMobileWalletAdapterWallet, RemoteSolanaMobileWalletAdapterWallet, SolanaMobileWalletAdapterRemoteWalletName as SolanaMobileWalletAdapterRemoteWalletName$1, SolanaMobileWalletAdapterWalletName as SolanaMobileWalletAdapterWalletName$1, createDefaultAuthorizationCache, createDefaultChainSelector, defaultErrorModalWalletNotFoundHandler } from "@solana-mobile/wallet-standard-mobile";
+import { StandardConnect, StandardDisconnect, StandardEvents } from "@wallet-standard/core";
+//#region src/base64Utils.ts
+function fromUint8Array(byteArray) {
+	return window.btoa(String.fromCharCode.call(null, ...byteArray));
+}
+//#endregion
+//#region src/getIsSupported.ts
+function getIsSupported() {
+	return typeof window !== "undefined" && window.isSecureContext && typeof document !== "undefined" && /android/i.test(navigator.userAgent);
+}
+//#endregion
+//#region src/adapter.ts
+const SolanaMobileWalletAdapterWalletName = SolanaMobileWalletAdapterWalletName$1;
+const SolanaMobileWalletAdapterRemoteWalletName = SolanaMobileWalletAdapterRemoteWalletName$1;
+const SIGNATURE_LENGTH_IN_BYTES = 64;
+function isVersionedTransaction(transaction) {
+	return "version" in transaction;
+}
+function chainOrClusterToChainId(chain) {
+	switch (chain) {
+		case "mainnet-beta": return "solana:mainnet";
+		case "testnet": return "solana:testnet";
+		case "devnet": return "solana:devnet";
+		default: return chain;
+	}
+}
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : "Unknown error";
+}
+var BaseSolanaMobileWalletAdapter = class extends BaseSignInMessageSignerWalletAdapter {
+	supportedTransactionVersions = new Set(["legacy", 0]);
+	name;
+	icon;
+	url;
+	#wallet;
+	#connecting = false;
+	#readyState = getIsSupported() ? WalletReadyState.Loadable : WalletReadyState.Unsupported;
+	#accountSelector;
+	#selectedAccount;
+	#publicKey;
+	#handleChangeEvent = async (properties) => {
+		if (properties.accounts && properties.accounts.length > 0) {
+			this.#declareWalletAsInstalled();
+			const nextSelectedAccount = await this.#accountSelector(properties.accounts);
+			if (nextSelectedAccount !== this.#selectedAccount) {
+				this.#selectedAccount = nextSelectedAccount;
+				this.#publicKey = void 0;
+				this.emit("connect", this.publicKey);
+			}
+		}
+	};
+	constructor(wallet, config) {
+		super();
+		this.#accountSelector = async (accounts) => {
+			const selectedBase64EncodedAddress = await config.addressSelector.select(accounts.map(({ publicKey }) => fromUint8Array(new Uint8Array(publicKey))));
+			return accounts.find(({ publicKey }) => fromUint8Array(new Uint8Array(publicKey)) === selectedBase64EncodedAddress) ?? accounts[0];
+		};
+		this.#wallet = wallet;
+		this.#wallet.features[StandardEvents].on("change", this.#handleChangeEvent);
+		this.name = this.#wallet.name;
+		this.icon = this.#wallet.icon;
+		this.url = this.#wallet.url;
+	}
+	get publicKey() {
+		if (!this.#publicKey && this.#selectedAccount) try {
+			this.#publicKey = new PublicKey(this.#selectedAccount.publicKey);
+		} catch (e) {
+			throw new WalletPublicKeyError(e instanceof Error && e?.message || "Unknown error", e);
+		}
+		return this.#publicKey ?? null;
+	}
+	get connected() {
+		return this.#wallet.connected;
+	}
+	get connecting() {
+		return this.#connecting;
+	}
+	get readyState() {
+		return this.#readyState;
+	}
+	/** @deprecated Use `autoConnect()` instead. */
+	async autoConnect_DO_NOT_USE_OR_YOU_WILL_BE_FIRED() {
+		return await this.autoConnect();
+	}
+	async autoConnect() {
+		this.#connect(true);
+	}
+	async connect() {
+		this.#connect();
+	}
+	async #connect(autoConnect = false) {
+		if (this.connecting || this.connected) return;
+		return await this.#runWithGuard(async () => {
+			if (this.#readyState !== WalletReadyState.Installed && this.#readyState !== WalletReadyState.Loadable) throw new WalletNotReadyError();
+			this.#connecting = true;
+			try {
+				await this.#wallet.features[StandardConnect].connect({ silent: autoConnect });
+			} catch (e) {
+				throw new WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+			} finally {
+				this.#connecting = false;
+			}
+		});
+	}
+	/** @deprecated Use `connect()` or `autoConnect()` instead. */
+	async performAuthorization(signInPayload) {
+		try {
+			const cachedAuthorizationResult = await this.#wallet.cachedAuthorizationResult;
+			if (cachedAuthorizationResult) {
+				await this.#wallet.features[StandardConnect].connect({ silent: true });
+				return cachedAuthorizationResult;
+			}
+			if (signInPayload) await this.#wallet.features[SolanaSignIn].signIn(signInPayload);
+			else await this.#wallet.features[StandardConnect].connect();
+			return await await this.#wallet.cachedAuthorizationResult;
+		} catch (e) {
+			throw new WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+		}
+	}
+	async disconnect() {
+		return await this.#runWithGuard(async () => {
+			this.#connecting = false;
+			this.#publicKey = void 0;
+			this.#selectedAccount = void 0;
+			await this.#wallet.features[StandardDisconnect].disconnect();
+			this.emit("disconnect");
+		});
+	}
+	async signIn(input) {
+		return this.#runWithGuard(async () => {
+			if (this.#readyState !== WalletReadyState.Installed && this.#readyState !== WalletReadyState.Loadable) throw new WalletNotReadyError();
+			this.#connecting = true;
+			try {
+				const outputs = await this.#wallet.features[SolanaSignIn].signIn({
+					...input,
+					domain: input?.domain ?? window.location.host
+				});
+				if (outputs.length > 0) return outputs[0];
+				else throw new Error("Sign in failed, no sign in result returned by wallet");
+			} catch (e) {
+				throw new WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+			} finally {
+				this.#connecting = false;
+			}
+		});
+	}
+	async signMessage(message) {
+		return await this.#runWithGuard(async () => {
+			const account = this.#assertIsAuthorized();
+			try {
+				return (await this.#wallet.features[SolanaSignMessage].signMessage({
+					account,
+					message
+				}))[0].signature;
+			} catch (error) {
+				throw new WalletSignMessageError(getErrorMessage(error), error);
+			}
+		});
+	}
+	async sendTransaction(transaction, connection, options) {
+		return await this.#runWithGuard(async () => {
+			const account = this.#assertIsAuthorized();
+			try {
+				function getTargetCommitment() {
+					let targetCommitment;
+					switch (connection.commitment) {
+						case "confirmed":
+						case "finalized":
+						case "processed":
+							targetCommitment = connection.commitment;
+							break;
+						default: targetCommitment = "finalized";
+					}
+					let targetPreflightCommitment;
+					switch (options?.preflightCommitment) {
+						case "confirmed":
+						case "finalized":
+						case "processed":
+							targetPreflightCommitment = options.preflightCommitment;
+							break;
+						case void 0:
+							targetPreflightCommitment = targetCommitment;
+							break;
+						default: targetPreflightCommitment = "finalized";
+					}
+					return (targetPreflightCommitment === "finalized" ? 2 : targetPreflightCommitment === "confirmed" ? 1 : 0) < (targetCommitment === "finalized" ? 2 : targetCommitment === "confirmed" ? 1 : 0) ? targetPreflightCommitment : targetCommitment;
+				}
+				if (SolanaSignAndSendTransaction in this.#wallet.features) {
+					const chain = chainOrClusterToChainId(this.#wallet.currentAuthorization.chain);
+					const [signature] = (await this.#wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction({
+						account,
+						transaction: transaction.serialize(),
+						chain,
+						options: options ? {
+							skipPreflight: options.skipPreflight,
+							maxRetries: options.maxRetries
+						} : void 0
+					})).map((output) => {
+						return fromUint8Array(output.signature);
+					});
+					return signature;
+				} else {
+					const [signedTransaction] = await this.#performSignTransactions([transaction]);
+					if (isVersionedTransaction(signedTransaction)) return await connection.sendTransaction(signedTransaction);
+					else {
+						const serializedTransaction = signedTransaction.serialize();
+						return await connection.sendRawTransaction(serializedTransaction, {
+							...options,
+							preflightCommitment: getTargetCommitment()
+						});
+					}
+				}
+			} catch (error) {
+				throw new WalletSendTransactionError(getErrorMessage(error), error);
+			}
+		});
+	}
+	async signTransaction(transaction) {
+		return await this.#runWithGuard(async () => {
+			const [signedTransaction] = await this.#performSignTransactions([transaction]);
+			return signedTransaction;
+		});
+	}
+	async signAllTransactions(transactions) {
+		return await this.#runWithGuard(async () => {
+			return await this.#performSignTransactions(transactions);
+		});
+	}
+	#declareWalletAsInstalled() {
+		if (this.#readyState !== WalletReadyState.Installed) this.emit("readyStateChange", this.#readyState = WalletReadyState.Installed);
+	}
+	#assertIsAuthorized() {
+		if (!this.#wallet.isAuthorized || !this.#selectedAccount) throw new WalletNotConnectedError();
+		return this.#selectedAccount;
+	}
+	async #performSignTransactions(transactions) {
+		const account = this.#assertIsAuthorized();
+		try {
+			if (SolanaSignTransaction in this.#wallet.features) return this.#wallet.features[SolanaSignTransaction].signTransaction(...transactions.map((value) => {
+				return {
+					account,
+					transaction: value.serialize()
+				};
+			})).then((outputs) => {
+				return outputs.map((output) => {
+					const byteArray = output.signedTransaction;
+					const messageOffset = byteArray[0] * SIGNATURE_LENGTH_IN_BYTES + 1;
+					if (VersionedMessage.deserializeMessageVersion(byteArray.slice(messageOffset, byteArray.length)) === "legacy") return Transaction.from(byteArray);
+					else return VersionedTransaction.deserialize(byteArray);
+				});
+			});
+			else throw new Error("Connected wallet does not support signing transactions");
+		} catch (error) {
+			throw new WalletSignTransactionError(getErrorMessage(error), error);
+		}
+	}
+	async #runWithGuard(callback) {
+		try {
+			return await callback();
+		} catch (e) {
+			this.emit("error", e instanceof WalletError ? e : new WalletError(getErrorMessage(e), e));
+			throw e;
+		}
+	}
+};
+var LocalSolanaMobileWalletAdapter = class extends BaseSolanaMobileWalletAdapter {
+	constructor(config) {
+		const chain = chainOrClusterToChainId(config.chain ?? config.cluster);
+		super(new LocalSolanaMobileWalletAdapterWallet({
+			appIdentity: config.appIdentity,
+			authorizationCache: {
+				set: config.authorizationResultCache.set,
+				get: async () => {
+					return await config.authorizationResultCache.get();
+				},
+				clear: config.authorizationResultCache.clear
+			},
+			chains: [chain],
+			chainSelector: createDefaultChainSelector(),
+			onWalletNotFound: async () => {
+				config.onWalletNotFound(this);
+			}
+		}), {
+			addressSelector: config.addressSelector,
+			chain
+		});
+	}
+};
+var RemoteSolanaMobileWalletAdapter = class extends BaseSolanaMobileWalletAdapter {
+	constructor(config) {
+		const chain = chainOrClusterToChainId(config.chain);
+		super(new RemoteSolanaMobileWalletAdapterWallet({
+			appIdentity: config.appIdentity,
+			authorizationCache: {
+				set: config.authorizationResultCache.set,
+				get: async () => {
+					return await config.authorizationResultCache.get();
+				},
+				clear: config.authorizationResultCache.clear
+			},
+			chains: [chain],
+			chainSelector: createDefaultChainSelector(),
+			remoteHostAuthority: config.remoteHostAuthority,
+			onWalletNotFound: async () => {
+				config.onWalletNotFound(this);
+			}
+		}), {
+			addressSelector: config.addressSelector,
+			chain
+		});
+	}
+};
+var SolanaMobileWalletAdapter = class extends LocalSolanaMobileWalletAdapter {};
+//#endregion
+//#region src/createDefaultAddressSelector.ts
+function createDefaultAddressSelector() {
+	return { async select(addresses) {
+		return addresses[0];
+	} };
+}
+//#endregion
+//#region src/createDefaultAuthorizationResultCache.ts
+function createDefaultAuthorizationResultCache() {
+	return createDefaultAuthorizationCache();
+}
+//#endregion
+//#region src/createDefaultWalletNotFoundHandler.ts
+async function defaultWalletNotFoundHandler(_mobileWalletAdapter) {
+	return defaultErrorModalWalletNotFoundHandler();
+}
+function createDefaultWalletNotFoundHandler() {
+	return defaultWalletNotFoundHandler;
+}
+//#endregion
+export { LocalSolanaMobileWalletAdapter, RemoteSolanaMobileWalletAdapter, SolanaMobileWalletAdapter, SolanaMobileWalletAdapterRemoteWalletName, SolanaMobileWalletAdapterWalletName, createDefaultAddressSelector, createDefaultAuthorizationResultCache, createDefaultWalletNotFoundHandler };
+
+//# sourceMappingURL=index.browser.js.map

node_modules/@solana-mobile/wallet-adapter-mobile/lib/esm/index.js

@@ -0,0 +1,341 @@
+import { BaseSignInMessageSignerWalletAdapter, WalletConnectionError, WalletError, WalletNotConnectedError, WalletNotReadyError, WalletPublicKeyError, WalletReadyState, WalletSendTransactionError, WalletSignMessageError, WalletSignTransactionError } from "@solana/wallet-adapter-base";
+import { SolanaSignAndSendTransaction, SolanaSignIn, SolanaSignMessage, SolanaSignTransaction } from "@solana/wallet-standard-features";
+import { PublicKey, Transaction, VersionedMessage, VersionedTransaction } from "@solana/web3.js";
+import { LocalSolanaMobileWalletAdapterWallet, RemoteSolanaMobileWalletAdapterWallet, SolanaMobileWalletAdapterRemoteWalletName as SolanaMobileWalletAdapterRemoteWalletName$1, SolanaMobileWalletAdapterWalletName as SolanaMobileWalletAdapterWalletName$1, createDefaultAuthorizationCache, createDefaultChainSelector, defaultErrorModalWalletNotFoundHandler } from "@solana-mobile/wallet-standard-mobile";
+import { StandardConnect, StandardDisconnect, StandardEvents } from "@wallet-standard/core";
+//#region src/base64Utils.ts
+function fromUint8Array(byteArray) {
+	return window.btoa(String.fromCharCode.call(null, ...byteArray));
+}
+//#endregion
+//#region src/getIsSupported.ts
+function getIsSupported() {
+	return typeof window !== "undefined" && window.isSecureContext && typeof document !== "undefined" && /android/i.test(navigator.userAgent);
+}
+//#endregion
+//#region src/adapter.ts
+const SolanaMobileWalletAdapterWalletName = SolanaMobileWalletAdapterWalletName$1;
+const SolanaMobileWalletAdapterRemoteWalletName = SolanaMobileWalletAdapterRemoteWalletName$1;
+const SIGNATURE_LENGTH_IN_BYTES = 64;
+function isVersionedTransaction(transaction) {
+	return "version" in transaction;
+}
+function chainOrClusterToChainId(chain) {
+	switch (chain) {
+		case "mainnet-beta": return "solana:mainnet";
+		case "testnet": return "solana:testnet";
+		case "devnet": return "solana:devnet";
+		default: return chain;
+	}
+}
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : "Unknown error";
+}
+var BaseSolanaMobileWalletAdapter = class extends BaseSignInMessageSignerWalletAdapter {
+	supportedTransactionVersions = new Set(["legacy", 0]);
+	name;
+	icon;
+	url;
+	#wallet;
+	#connecting = false;
+	#readyState = getIsSupported() ? WalletReadyState.Loadable : WalletReadyState.Unsupported;
+	#accountSelector;
+	#selectedAccount;
+	#publicKey;
+	#handleChangeEvent = async (properties) => {
+		if (properties.accounts && properties.accounts.length > 0) {
+			this.#declareWalletAsInstalled();
+			const nextSelectedAccount = await this.#accountSelector(properties.accounts);
+			if (nextSelectedAccount !== this.#selectedAccount) {
+				this.#selectedAccount = nextSelectedAccount;
+				this.#publicKey = void 0;
+				this.emit("connect", this.publicKey);
+			}
+		}
+	};
+	constructor(wallet, config) {
+		super();
+		this.#accountSelector = async (accounts) => {
+			const selectedBase64EncodedAddress = await config.addressSelector.select(accounts.map(({ publicKey }) => fromUint8Array(new Uint8Array(publicKey))));
+			return accounts.find(({ publicKey }) => fromUint8Array(new Uint8Array(publicKey)) === selectedBase64EncodedAddress) ?? accounts[0];
+		};
+		this.#wallet = wallet;
+		this.#wallet.features[StandardEvents].on("change", this.#handleChangeEvent);
+		this.name = this.#wallet.name;
+		this.icon = this.#wallet.icon;
+		this.url = this.#wallet.url;
+	}
+	get publicKey() {
+		if (!this.#publicKey && this.#selectedAccount) try {
+			this.#publicKey = new PublicKey(this.#selectedAccount.publicKey);
+		} catch (e) {
+			throw new WalletPublicKeyError(e instanceof Error && e?.message || "Unknown error", e);
+		}
+		return this.#publicKey ?? null;
+	}
+	get connected() {
+		return this.#wallet.connected;
+	}
+	get connecting() {
+		return this.#connecting;
+	}
+	get readyState() {
+		return this.#readyState;
+	}
+	/** @deprecated Use `autoConnect()` instead. */
+	async autoConnect_DO_NOT_USE_OR_YOU_WILL_BE_FIRED() {
+		return await this.autoConnect();
+	}
+	async autoConnect() {
+		this.#connect(true);
+	}
+	async connect() {
+		this.#connect();
+	}
+	async #connect(autoConnect = false) {
+		if (this.connecting || this.connected) return;
+		return await this.#runWithGuard(async () => {
+			if (this.#readyState !== WalletReadyState.Installed && this.#readyState !== WalletReadyState.Loadable) throw new WalletNotReadyError();
+			this.#connecting = true;
+			try {
+				await this.#wallet.features[StandardConnect].connect({ silent: autoConnect });
+			} catch (e) {
+				throw new WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+			} finally {
+				this.#connecting = false;
+			}
+		});
+	}
+	/** @deprecated Use `connect()` or `autoConnect()` instead. */
+	async performAuthorization(signInPayload) {
+		try {
+			const cachedAuthorizationResult = await this.#wallet.cachedAuthorizationResult;
+			if (cachedAuthorizationResult) {
+				await this.#wallet.features[StandardConnect].connect({ silent: true });
+				return cachedAuthorizationResult;
+			}
+			if (signInPayload) await this.#wallet.features[SolanaSignIn].signIn(signInPayload);
+			else await this.#wallet.features[StandardConnect].connect();
+			return await await this.#wallet.cachedAuthorizationResult;
+		} catch (e) {
+			throw new WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+		}
+	}
+	async disconnect() {
+		return await this.#runWithGuard(async () => {
+			this.#connecting = false;
+			this.#publicKey = void 0;
+			this.#selectedAccount = void 0;
+			await this.#wallet.features[StandardDisconnect].disconnect();
+			this.emit("disconnect");
+		});
+	}
+	async signIn(input) {
+		return this.#runWithGuard(async () => {
+			if (this.#readyState !== WalletReadyState.Installed && this.#readyState !== WalletReadyState.Loadable) throw new WalletNotReadyError();
+			this.#connecting = true;
+			try {
+				const outputs = await this.#wallet.features[SolanaSignIn].signIn({
+					...input,
+					domain: input?.domain ?? window.location.host
+				});
+				if (outputs.length > 0) return outputs[0];
+				else throw new Error("Sign in failed, no sign in result returned by wallet");
+			} catch (e) {
+				throw new WalletConnectionError(e instanceof Error && e.message || "Unknown error", e);
+			} finally {
+				this.#connecting = false;
+			}
+		});
+	}
+	async signMessage(message) {
+		return await this.#runWithGuard(async () => {
+			const account = this.#assertIsAuthorized();
+			try {
+				return (await this.#wallet.features[SolanaSignMessage].signMessage({
+					account,
+					message
+				}))[0].signature;
+			} catch (error) {
+				throw new WalletSignMessageError(getErrorMessage(error), error);
+			}
+		});
+	}
+	async sendTransaction(transaction, connection, options) {
+		return await this.#runWithGuard(async () => {
+			const account = this.#assertIsAuthorized();
+			try {
+				function getTargetCommitment() {
+					let targetCommitment;
+					switch (connection.commitment) {
+						case "confirmed":
+						case "finalized":
+						case "processed":
+							targetCommitment = connection.commitment;
+							break;
+						default: targetCommitment = "finalized";
+					}
+					let targetPreflightCommitment;
+					switch (options?.preflightCommitment) {
+						case "confirmed":
+						case "finalized":
+						case "processed":
+							targetPreflightCommitment = options.preflightCommitment;
+							break;
+						case void 0:
+							targetPreflightCommitment = targetCommitment;
+							break;
+						default: targetPreflightCommitment = "finalized";
+					}
+					return (targetPreflightCommitment === "finalized" ? 2 : targetPreflightCommitment === "confirmed" ? 1 : 0) < (targetCommitment === "finalized" ? 2 : targetCommitment === "confirmed" ? 1 : 0) ? targetPreflightCommitment : targetCommitment;
+				}
+				if (SolanaSignAndSendTransaction in this.#wallet.features) {
+					const chain = chainOrClusterToChainId(this.#wallet.currentAuthorization.chain);
+					const [signature] = (await this.#wallet.features[SolanaSignAndSendTransaction].signAndSendTransaction({
+						account,
+						transaction: transaction.serialize(),
+						chain,
+						options: options ? {
+							skipPreflight: options.skipPreflight,
+							maxRetries: options.maxRetries
+						} : void 0
+					})).map((output) => {
+						return fromUint8Array(output.signature);
+					});
+					return signature;
+				} else {
+					const [signedTransaction] = await this.#performSignTransactions([transaction]);
+					if (isVersionedTransaction(signedTransaction)) return await connection.sendTransaction(signedTransaction);
+					else {
+						const serializedTransaction = signedTransaction.serialize();
+						return await connection.sendRawTransaction(serializedTransaction, {
+							...options,
+							preflightCommitment: getTargetCommitment()
+						});
+					}
+				}
+			} catch (error) {
+				throw new WalletSendTransactionError(getErrorMessage(error), error);
+			}
+		});
+	}
+	async signTransaction(transaction) {
+		return await this.#runWithGuard(async () => {
+			const [signedTransaction] = await this.#performSignTransactions([transaction]);
+			return signedTransaction;
+		});
+	}
+	async signAllTransactions(transactions) {
+		return await this.#runWithGuard(async () => {
+			return await this.#performSignTransactions(transactions);
+		});
+	}
+	#declareWalletAsInstalled() {
+		if (this.#readyState !== WalletReadyState.Installed) this.emit("readyStateChange", this.#readyState = WalletReadyState.Installed);
+	}
+	#assertIsAuthorized() {
+		if (!this.#wallet.isAuthorized || !this.#selectedAccount) throw new WalletNotConnectedError();
+		return this.#selectedAccount;
+	}
+	async #performSignTransactions(transactions) {
+		const account = this.#assertIsAuthorized();
+		try {
+			if (SolanaSignTransaction in this.#wallet.features) return this.#wallet.features[SolanaSignTransaction].signTransaction(...transactions.map((value) => {
+				return {
+					account,
+					transaction: value.serialize()
+				};
+			})).then((outputs) => {
+				return outputs.map((output) => {
+					const byteArray = output.signedTransaction;
+					const messageOffset = byteArray[0] * SIGNATURE_LENGTH_IN_BYTES + 1;
+					if (VersionedMessage.deserializeMessageVersion(byteArray.slice(messageOffset, byteArray.length)) === "legacy") return Transaction.from(byteArray);
+					else return VersionedTransaction.deserialize(byteArray);
+				});
+			});
+			else throw new Error("Connected wallet does not support signing transactions");
+		} catch (error) {
+			throw new WalletSignTransactionError(getErrorMessage(error), error);
+		}
+	}
+	async #runWithGuard(callback) {
+		try {
+			return await callback();
+		} catch (e) {
+			this.emit("error", e instanceof WalletError ? e : new WalletError(getErrorMessage(e), e));
+			throw e;
+		}
+	}
+};
+var LocalSolanaMobileWalletAdapter = class extends BaseSolanaMobileWalletAdapter {
+	constructor(config) {
+		const chain = chainOrClusterToChainId(config.chain ?? config.cluster);
+		super(new LocalSolanaMobileWalletAdapterWallet({
+			appIdentity: config.appIdentity,
+			authorizationCache: {
+				set: config.authorizationResultCache.set,
+				get: async () => {
+					return await config.authorizationResultCache.get();
+				},
+				clear: config.authorizationResultCache.clear
+			},
+			chains: [chain],
+			chainSelector: createDefaultChainSelector(),
+			onWalletNotFound: async () => {
+				config.onWalletNotFound(this);
+			}
+		}), {
+			addressSelector: config.addressSelector,
+			chain
+		});
+	}
+};
+var RemoteSolanaMobileWalletAdapter = class extends BaseSolanaMobileWalletAdapter {
+	constructor(config) {
+		const chain = chainOrClusterToChainId(config.chain);
+		super(new RemoteSolanaMobileWalletAdapterWallet({
+			appIdentity: config.appIdentity,
+			authorizationCache: {
+				set: config.authorizationResultCache.set,
+				get: async () => {
+					return await config.authorizationResultCache.get();
+				},
+				clear: config.authorizationResultCache.clear
+			},
+			chains: [chain],
+			chainSelector: createDefaultChainSelector(),
+			remoteHostAuthority: config.remoteHostAuthority,
+			onWalletNotFound: async () => {
+				config.onWalletNotFound(this);
+			}
+		}), {
+			addressSelector: config.addressSelector,
+			chain
+		});
+	}
+};
+var SolanaMobileWalletAdapter = class extends LocalSolanaMobileWalletAdapter {};
+//#endregion
+//#region src/createDefaultAddressSelector.ts
+function createDefaultAddressSelector() {
+	return { async select(addresses) {
+		return addresses[0];
+	} };
+}
+//#endregion
+//#region src/createDefaultAuthorizationResultCache.ts
+function createDefaultAuthorizationResultCache() {
+	return createDefaultAuthorizationCache();
+}
+//#endregion
+//#region src/createDefaultWalletNotFoundHandler.ts
+async function defaultWalletNotFoundHandler(_mobileWalletAdapter) {
+	return defaultErrorModalWalletNotFoundHandler();
+}
+function createDefaultWalletNotFoundHandler() {
+	return defaultWalletNotFoundHandler;
+}
+//#endregion
+export { LocalSolanaMobileWalletAdapter, RemoteSolanaMobileWalletAdapter, SolanaMobileWalletAdapter, SolanaMobileWalletAdapterRemoteWalletName, SolanaMobileWalletAdapterWalletName, createDefaultAddressSelector, createDefaultAuthorizationResultCache, createDefaultWalletNotFoundHandler };
+
+//# sourceMappingURL=index.js.map

node_modules/@solana-mobile/wallet-adapter-mobile/lib/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

node_modules/@solana-mobile/wallet-adapter-mobile/lib/types/index.d.ts

@@ -0,0 +1,86 @@
+import { BaseSignInMessageSignerWalletAdapter, WalletName, WalletReadyState } from "@solana/wallet-adapter-base";
+import { SolanaSignInInput, SolanaSignInOutput } from "@solana/wallet-standard-features";
+import { Connection, PublicKey, SendOptions, Transaction, TransactionSignature, TransactionVersion, VersionedTransaction } from "@solana/web3.js";
+import { AppIdentity, AuthorizationResult, Base64EncodedAddress, Chain, Cluster, SignInPayload } from "@solana-mobile/mobile-wallet-adapter-protocol";
+import { Authorization, LocalSolanaMobileWalletAdapterWallet, RemoteSolanaMobileWalletAdapterWallet } from "@solana-mobile/wallet-standard-mobile";
+
+//#region src/adapter.d.ts
+interface AuthorizationResultCache {
+  clear(): Promise<void>;
+  get(): Promise<AuthorizationResult | Authorization | undefined>;
+  set(authorizationResult: AuthorizationResult | Authorization): Promise<void>;
+}
+interface AddressSelector {
+  select(addresses: Base64EncodedAddress[]): Promise<Base64EncodedAddress>;
+}
+declare const SolanaMobileWalletAdapterWalletName: WalletName;
+declare const SolanaMobileWalletAdapterRemoteWalletName: WalletName;
+declare abstract class BaseSolanaMobileWalletAdapter extends BaseSignInMessageSignerWalletAdapter {
+  #private;
+  readonly supportedTransactionVersions: Set<TransactionVersion>;
+  name: WalletName;
+  icon: `data:image/svg+xml;base64,${string}` | `data:image/webp;base64,${string}` | `data:image/png;base64,${string}` | `data:image/gif;base64,${string}`;
+  url: string;
+  protected constructor(wallet: LocalSolanaMobileWalletAdapterWallet | RemoteSolanaMobileWalletAdapterWallet, config: {
+    addressSelector: AddressSelector;
+    chain: Chain;
+  });
+  get publicKey(): PublicKey | null;
+  get connected(): boolean;
+  get connecting(): boolean;
+  get readyState(): WalletReadyState;
+  /** @deprecated Use `autoConnect()` instead. */
+  autoConnect_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(): Promise<void>;
+  autoConnect(): Promise<void>;
+  connect(): Promise<void>;
+  /** @deprecated Use `connect()` or `autoConnect()` instead. */
+  performAuthorization(signInPayload?: SignInPayload): Promise<AuthorizationResult>;
+  disconnect(): Promise<void>;
+  signIn(input?: SolanaSignInInput): Promise<SolanaSignInOutput>;
+  signMessage(message: Uint8Array): Promise<Uint8Array>;
+  sendTransaction<T extends Transaction | VersionedTransaction>(transaction: T, connection: Connection, options?: SendOptions): Promise<TransactionSignature>;
+  signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
+  signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]>;
+}
+declare class LocalSolanaMobileWalletAdapter extends BaseSolanaMobileWalletAdapter {
+  /**
+   * @deprecated @param cluster config paramter is deprecated, use @param chain instead
+   */
+  constructor(config: {
+    addressSelector: AddressSelector;
+    appIdentity: AppIdentity;
+    authorizationResultCache: AuthorizationResultCache;
+    cluster: Cluster;
+    onWalletNotFound: (mobileWalletAdapter: LocalSolanaMobileWalletAdapter) => Promise<void>;
+  });
+  constructor(config: {
+    addressSelector: AddressSelector;
+    appIdentity: AppIdentity;
+    authorizationResultCache: AuthorizationResultCache;
+    chain: Chain;
+    onWalletNotFound: (mobileWalletAdapter: LocalSolanaMobileWalletAdapter) => Promise<void>;
+  });
+}
+declare class RemoteSolanaMobileWalletAdapter extends BaseSolanaMobileWalletAdapter {
+  constructor(config: {
+    addressSelector: AddressSelector;
+    appIdentity: AppIdentity;
+    authorizationResultCache: AuthorizationResultCache;
+    chain: Chain;
+    remoteHostAuthority: string;
+    onWalletNotFound: (mobileWalletAdapter: RemoteSolanaMobileWalletAdapter) => Promise<void>;
+  });
+}
+declare class SolanaMobileWalletAdapter extends LocalSolanaMobileWalletAdapter {}
+//#endregion
+//#region src/createDefaultAddressSelector.d.ts
+declare function createDefaultAddressSelector(): AddressSelector;
+//#endregion
+//#region src/createDefaultAuthorizationResultCache.d.ts
+declare function createDefaultAuthorizationResultCache(): AuthorizationResultCache;
+//#endregion
+//#region src/createDefaultWalletNotFoundHandler.d.ts
+declare function createDefaultWalletNotFoundHandler(): (mobileWalletAdapter: SolanaMobileWalletAdapter) => Promise<void>;
+//#endregion
+export { AddressSelector, AuthorizationResultCache, LocalSolanaMobileWalletAdapter, RemoteSolanaMobileWalletAdapter, SolanaMobileWalletAdapter, SolanaMobileWalletAdapterRemoteWalletName, SolanaMobileWalletAdapterWalletName, createDefaultAddressSelector, createDefaultAuthorizationResultCache, createDefaultWalletNotFoundHandler };
+//# sourceMappingURL=index.d.ts.map

node_modules/@solana-mobile/wallet-adapter-mobile/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/adapter.ts","../../src/createDefaultAddressSelector.ts","../../src/createDefaultAuthorizationResultCache.ts","../../src/createDefaultWalletNotFoundHandler.ts"],"mappings":";;;;;;;UA8DiB,wBAAA;EACb,KAAA,IAAS,OAAA;EACT,GAAA,IAAO,OAAA,CAAQ,mBAAA,GAAsB,aAAA;EACrC,GAAA,CAAI,mBAAA,EAAqB,mBAAA,GAAsB,aAAA,GAAgB,OAAA;AAAA;AAAA,UAGlD,eAAA;EACb,MAAA,CAAO,SAAA,EAAW,oBAAA,KAAyB,OAAA,CAAQ,oBAAA;AAAA;AAAA,cAG1C,mCAAA,EAAkE,UAAA;AAAA,cAClE,yCAAA,EAA8E,UAAA;AAAA,uBA2B5E,6BAAA,SAAsC,oCAAA;EAAA;WACxC,4BAAA,EAA8B,GAAA,CAAI,kBAAA;EAI3C,IAAA,EAAI,UAAA;EACJ,IAAA;EACA,GAAA;EAAA,UAyBS,WAAA,CACL,MAAA,EAAQ,oCAAA,GAAuC,qCAAA,EAC/C,MAAA;IACI,eAAA,EAAiB,eAAA;IACjB,KAAA,EAAO,KAAA;EAAA;EAAA,IAkCX,SAAA,CAAA,GAAa,SAAA;EAAA,IAWb,SAAA,CAAA;EAAA,IAIA,UAAA,CAAA;EAAA,IAIA,UAAA,CAAA,GAAc,gBAAA;EA5H6C;EAiIzD,2CAAA,CAAA,GAA+C,OAAA;EAI/C,WAAA,CAAA,GAAe,OAAA;EAIf,OAAA,CAAA,GAAW,OAAA;EAtIW;EA8JtB,oBAAA,CAAqB,aAAA,GAAgB,aAAA,GAAgB,OAAA,CAAQ,mBAAA;EAkB7D,UAAA,CAAA,GAAc,OAAA;EAWd,MAAA,CAAO,KAAA,GAAQ,iBAAA,GAAoB,OAAA,CAAQ,kBAAA;EAwB3C,WAAA,CAAY,OAAA,EAAS,UAAA,GAAa,OAAA,CAAQ,UAAA;EAe1C,eAAA,WAA0B,WAAA,GAAoB,oBAAA,CAAA,CAChD,WAAA,EAAa,CAAA,EACb,UAAA,EAAY,UAAA,EACZ,OAAA,GAAU,WAAA,GACX,OAAA,CAAQ,oBAAA;EA6EL,eAAA,WAA0B,WAAA,GAAoB,oBAAA,CAAA,CAAsB,WAAA,EAAa,CAAA,GAAI,OAAA,CAAQ,CAAA;EAO7F,mBAAA,WAA8B,WAAA,GAAoB,oBAAA,CAAA,CAAsB,YAAA,EAAc,CAAA,KAAM,OAAA,CAAQ,CAAA;AAAA;AAAA,cA6DjG,8BAAA,SAAuC,6BAAA;EAtXL;;;cA0X/B,MAAA;IACR,eAAA,EAAiB,eAAA;IACjB,WAAA,EAAa,WAAA;IACb,wBAAA,EAA0B,wBAAA;IAC1B,OAAA,EAAS,OAAA;IACT,gBAAA,GAAmB,mBAAA,EAAqB,8BAAA,KAAmC,OAAA;EAAA;cAGnE,MAAA;IACR,eAAA,EAAiB,eAAA;IACjB,WAAA,EAAa,WAAA;IACb,wBAAA,EAA0B,wBAAA;IAC1B,KAAA,EAAO,KAAA;IACP,gBAAA,GAAmB,mBAAA,EAAqB,8BAAA,KAAmC,OAAA;EAAA;AAAA;AAAA,cAoCtE,+BAAA,SAAwC,6BAAA;cACrC,MAAA;IACR,eAAA,EAAiB,eAAA;IACjB,WAAA,EAAa,WAAA;IACb,wBAAA,EAA0B,wBAAA;IAC1B,KAAA,EAAO,KAAA;IACP,mBAAA;IACA,gBAAA,GAAmB,mBAAA,EAAqB,+BAAA,KAAoC,OAAA;EAAA;AAAA;AAAA,cA4BvE,yBAAA,SAAkC,8BAAA;;;iBCjhBvB,4BAAA,CAAA,GAAgC,eAAA;;;iBCEhC,qCAAA,CAAA,GAAyC,wBAAA;;;iBCIzC,kCAAA,CAAA,IACpB,mBAAA,EAAqB,yBAAA,KACpB,OAAA"}

node_modules/@solana-mobile/wallet-adapter-mobile/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@solana-mobile/wallet-adapter-mobile",
+  "description": "An adapter for mobile wallet apps that conform to the Solana Mobile Wallet Adapter protocol",
+  "version": "2.2.8",
+  "author": "Steven Luscher <steven.luscher@solanamobile.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/solana-mobile/mobile-wallet-adapter.git"
+  },
+  "license": "Apache-2.0",
+  "exports": {
+    "edge-light": {
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js"
+    },
+    "workerd": {
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js"
+    },
+    "browser": {
+      "import": "./lib/esm/index.browser.js",
+      "require": "./lib/cjs/index.browser.js"
+    },
+    "node": {
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js"
+    },
+    "react-native": "./lib/cjs/index.native.js",
+    "types": "./lib/types/index.d.ts"
+  },
+  "browser": {
+    "./lib/cjs/index.js": "./lib/cjs/index.browser.js",
+    "./lib/esm/index.js": "./lib/esm/index.browser.js"
+  },
+  "main": "lib/cjs/index.js",
+  "module": "lib/esm/index.js",
+  "react-native": "lib/cjs/index.native.js",
+  "types": "lib/types/index.d.ts",
+  "type": "module",
+  "files": [
+    "lib",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@solana/web3.js": "^1.98.4",
+    "react-native": ">0.74"
+  },
+  "dependencies": {
+    "@solana/wallet-adapter-base": "^0.9.27",
+    "@solana/wallet-standard-features": "^1.3.0",
+    "@wallet-standard/core": "^1.1.1",
+    "bs58": "^6.0.0",
+    "js-base64": "^3.7.5",
+    "tslib": "^2.8.1",
+    "@solana-mobile/mobile-wallet-adapter-protocol": "^2.2.8",
+    "@solana-mobile/mobile-wallet-adapter-protocol-web3js": "^2.2.8",
+    "@solana-mobile/wallet-standard-mobile": "^0.5.2"
+  },
+  "optionalDependencies": {
+    "@react-native-async-storage/async-storage": "^1.17.7"
+  },
+  "devDependencies": {
+    "@solana/web3.js": "^1.98.4",
+    "@types/react-native": "^0.69.3",
+    "agadoo": "^3.0.0",
+    "cross-env": "^10.1.0",
+    "shx": "^0.4.0"
+  },
+  "scripts": {
+    "clean": "shx rm -rf lib/*",
+    "build": "pnpm clean && tsdown --config ../../tsdown.config.ts",
+    "build:watch": "pnpm clean && tsdown --config ../../tsdown.config.ts --watch",
+    "check-types": "tsc -p tsconfig.json --noEmit",
+    "postbuild": "printf '%s' '{\"type\":\"commonjs\"}' > lib/cjs/package.json && printf '%s' '{\"type\":\"module\"}' > lib/esm/package.json"
+  }
+}