@solana-mobile/wallet-adapter-mobile 2.2.6 → 2.2.8

package/lib/cjs/index.native.js

@@ -1,433 +1,380 @@
-'use strict';
-
-var walletAdapterBase = require('@solana/wallet-adapter-base');
-var web3_js = require('@solana/web3.js');
-var walletStandardFeatures = require('@solana/wallet-standard-features');
-var core = require('@wallet-standard/core');
-var walletStandardMobile = require('@solana-mobile/wallet-standard-mobile');
-var jsBase64 = require('js-base64');
-var reactNative = require('react-native');
-var AsyncStorage = require('@react-native-async-storage/async-storage');
-
+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 reactNative.Platform.OS === 'android';
+	return react_native.Platform.OS === "android";
 }
-
-const SolanaMobileWalletAdapterWalletName = walletStandardMobile.SolanaMobileWalletAdapterWalletName;
-const SolanaMobileWalletAdapterRemoteWalletName = walletStandardMobile.SolanaMobileWalletAdapterRemoteWalletName;
+//#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;
+	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;
-    }
-}
-class BaseSolanaMobileWalletAdapter extends walletAdapterBase.BaseSignInMessageSignerWalletAdapter {
-    supportedTransactionVersions = new Set(
-    // FIXME(#244): We can't actually know what versions are supported until we know which wallet we're talking to.
-    ['legacy', 0]);
-    name;
-    icon;
-    url;
-    #wallet;
-    #connecting = false;
-    #readyState = getIsSupported() ? walletAdapterBase.WalletReadyState.Loadable : walletAdapterBase.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 = undefined;
-                this.emit('connect', 
-                // Having just set `this.#selectedAccount`, `this.publicKey` is definitely non-null
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                this.publicKey);
-            }
-        }
-    };
-    constructor(wallet, config) {
-        super();
-        // this.#chain = chainOrClusterToChainId(config.chain);
-        this.#accountSelector = async (accounts) => {
-            const selectedBase64EncodedAddress = await config.addressSelector.select(accounts.map(({ publicKey }) => jsBase64.fromUint8Array(new Uint8Array(publicKey))));
-            return accounts.find(({ publicKey }) => jsBase64.fromUint8Array(new Uint8Array(publicKey)) === selectedBase64EncodedAddress) ?? accounts[0];
-        };
-        this.#wallet = wallet;
-        this.#wallet.features[core.StandardEvents].on('change', this.#handleChangeEvent);
-        this.name = this.#wallet.name;
-        this.icon = this.#wallet.icon;
-        this.url = this.#wallet.url;
-        // TODO: evaluate if this logic should be kept - it seems to create a nasty bug where 
-        //  the wallet tries to auto connect on page load and gets blocked by the popup blocker
-        // if (this.#readyState !== WalletReadyState.Unsupported) {
-        //     config.authorizationResultCache.get().then((authorizationResult) => {
-        //         if (authorizationResult) {
-        //             // Having a prior authorization result is, right now, the best
-        //             // indication that a mobile wallet is installed. There is no API
-        //             // we can use to test for whether the association URI is supported.
-        //             this.#declareWalletAsInstalled();
-        //         }
-        //     });
-        // }
-    }
-    get publicKey() {
-        if (!this.#publicKey && this.#selectedAccount) {
-            try {
-                this.#publicKey = new web3_js.PublicKey(this.#selectedAccount.publicKey);
-            }
-            catch (e) {
-                throw new walletAdapterBase.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 !== walletAdapterBase.WalletReadyState.Installed && this.#readyState !== walletAdapterBase.WalletReadyState.Loadable) {
-                throw new walletAdapterBase.WalletNotReadyError();
-            }
-            this.#connecting = true;
-            try {
-                await this.#wallet.features[core.StandardConnect].connect({ silent: autoConnect });
-            }
-            catch (e) {
-                throw new walletAdapterBase.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[core.StandardConnect].connect({ silent: true });
-                return cachedAuthorizationResult;
-            }
-            if (signInPayload) {
-                await this.#wallet.features[walletStandardFeatures.SolanaSignIn].signIn(signInPayload);
-            }
-            else
-                await this.#wallet.features[core.StandardConnect].connect();
-            const authorizationResult = await await this.#wallet.cachedAuthorizationResult;
-            return authorizationResult;
-        }
-        catch (e) {
-            throw new walletAdapterBase.WalletConnectionError((e instanceof Error && e.message) || 'Unknown error', e);
-        }
-    }
-    async disconnect() {
-        // return await this.#runWithGuard(this.#wallet.features[StandardDisconnect].disconnect);
-        return await this.#runWithGuard(async () => {
-            this.#connecting = false;
-            this.#publicKey = undefined;
-            this.#selectedAccount = undefined;
-            await this.#wallet.features[core.StandardDisconnect].disconnect();
-            this.emit('disconnect');
-        });
-    }
-    async signIn(input) {
-        return this.#runWithGuard(async () => {
-            if (this.#readyState !== walletAdapterBase.WalletReadyState.Installed && this.#readyState !== walletAdapterBase.WalletReadyState.Loadable) {
-                throw new walletAdapterBase.WalletNotReadyError();
-            }
-            this.#connecting = true;
-            try {
-                const outputs = await this.#wallet.features[walletStandardFeatures.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 walletAdapterBase.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 {
-                const outputs = await this.#wallet.features[walletStandardFeatures.SolanaSignMessage].signMessage({
-                    account, message: message
-                });
-                return outputs[0].signature;
-            }
-            catch (error) {
-                throw new walletAdapterBase.WalletSignMessageError(error?.message, 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 undefined:
-                            targetPreflightCommitment = targetCommitment;
-                            break;
-                        default:
-                            targetPreflightCommitment = 'finalized';
-                    }
-                    const preflightCommitmentScore = targetPreflightCommitment === 'finalized'
-                        ? 2
-                        : targetPreflightCommitment === 'confirmed'
-                            ? 1
-                            : 0;
-                    const targetCommitmentScore = targetCommitment === 'finalized' ? 2 : targetCommitment === 'confirmed' ? 1 : 0;
-                    return preflightCommitmentScore < targetCommitmentScore
-                        ? targetPreflightCommitment
-                        : targetCommitment;
-                }
-                if (walletStandardFeatures.SolanaSignAndSendTransaction in this.#wallet.features) {
-                    const chain = chainOrClusterToChainId(this.#wallet.currentAuthorization.chain);
-                    const [signature] = (await this.#wallet.features[walletStandardFeatures.SolanaSignAndSendTransaction].signAndSendTransaction({
-                        account,
-                        transaction: transaction.serialize(),
-                        chain: chain,
-                        options: options ? {
-                            skipPreflight: options.skipPreflight,
-                            maxRetries: options.maxRetries
-                        } : undefined
-                    })).map(((output) => {
-                        return jsBase64.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 walletAdapterBase.WalletSendTransactionError(error?.message, 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 () => {
-            const signedTransactions = await this.#performSignTransactions(transactions);
-            return signedTransactions;
-        });
-    }
-    #declareWalletAsInstalled() {
-        if (this.#readyState !== walletAdapterBase.WalletReadyState.Installed) {
-            this.emit('readyStateChange', (this.#readyState = walletAdapterBase.WalletReadyState.Installed));
-        }
-    }
-    #assertIsAuthorized() {
-        if (!this.#wallet.isAuthorized || !this.#selectedAccount)
-            throw new walletAdapterBase.WalletNotConnectedError();
-        return this.#selectedAccount;
-    }
-    async #performSignTransactions(transactions) {
-        const account = this.#assertIsAuthorized();
-        try {
-            if (walletStandardFeatures.SolanaSignTransaction in this.#wallet.features) {
-                return this.#wallet.features[walletStandardFeatures.SolanaSignTransaction].signTransaction(...transactions.map((value) => {
-                    return { account, transaction: value.serialize() };
-                })).then((outputs) => {
-                    return outputs.map((output) => {
-                        const byteArray = output.signedTransaction;
-                        const numSignatures = byteArray[0];
-                        const messageOffset = numSignatures * SIGNATURE_LENGTH_IN_BYTES + 1;
-                        const version = web3_js.VersionedMessage.deserializeMessageVersion(byteArray.slice(messageOffset, byteArray.length));
-                        if (version === 'legacy') {
-                            return web3_js.Transaction.from(byteArray);
-                        }
-                        else {
-                            return web3_js.VersionedTransaction.deserialize(byteArray);
-                        }
-                    });
-                });
-            }
-            else {
-                throw new Error('Connected wallet does not support signing transactions');
-            }
-        }
-        catch (error) {
-            throw new walletAdapterBase.WalletSignTransactionError(error?.message, error);
-        }
-    }
-    async #runWithGuard(callback) {
-        try {
-            return await callback();
-        }
-        catch (e) {
-            this.emit('error', e);
-            throw e;
-        }
-    }
-}
-class LocalSolanaMobileWalletAdapter extends BaseSolanaMobileWalletAdapter {
-    constructor(config) {
-        const chain = chainOrClusterToChainId(config.chain ?? config.cluster);
-        super(new walletStandardMobile.LocalSolanaMobileWalletAdapterWallet({
-            appIdentity: config.appIdentity,
-            authorizationCache: {
-                set: config.authorizationResultCache.set,
-                get: async () => {
-                    return await config.authorizationResultCache.get();
-                },
-                clear: config.authorizationResultCache.clear,
-            },
-            chains: [chain],
-            chainSelector: walletStandardMobile.createDefaultChainSelector(),
-            onWalletNotFound: async () => {
-                config.onWalletNotFound(this);
-            },
-        }), {
-            addressSelector: config.addressSelector,
-            chain: chain,
-        });
-    }
-}
-class RemoteSolanaMobileWalletAdapter extends BaseSolanaMobileWalletAdapter {
-    constructor(config) {
-        const chain = chainOrClusterToChainId(config.chain);
-        super(new walletStandardMobile.RemoteSolanaMobileWalletAdapterWallet({
-            appIdentity: config.appIdentity,
-            authorizationCache: {
-                set: config.authorizationResultCache.set,
-                get: async () => {
-                    return await config.authorizationResultCache.get();
-                },
-                clear: config.authorizationResultCache.clear,
-            },
-            chains: [chain],
-            chainSelector: walletStandardMobile.createDefaultChainSelector(),
-            remoteHostAuthority: config.remoteHostAuthority,
-            onWalletNotFound: async () => {
-                config.onWalletNotFound(this);
-            },
-        }), {
-            addressSelector: config.addressSelector,
-            chain: chain,
-        });
-    }
+	switch (chain) {
+		case "mainnet-beta": return "solana:mainnet";
+		case "testnet": return "solana:testnet";
+		case "devnet": return "solana:devnet";
+		default: return chain;
+	}
 }
-class SolanaMobileWalletAdapter extends LocalSolanaMobileWalletAdapter {
+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];
-        },
-    };
+	return { async select(addresses) {
+		return addresses[0];
+	} };
 }
-
-const CACHE_KEY = 'SolanaMobileWalletAdapterDefaultAuthorizationCache';
+//#endregion
+//#region src/__forks__/react-native/createDefaultAuthorizationResultCache.ts
+const CACHE_KEY = "SolanaMobileWalletAdapterDefaultAuthorizationCache";
 function createDefaultAuthorizationResultCache() {
-    return {
-        async clear() {
-            try {
-                await AsyncStorage.removeItem(CACHE_KEY);
-                // eslint-disable-next-line no-empty
-            }
-            catch { }
-        },
-        async get() {
-            try {
-                return (JSON.parse((await AsyncStorage.getItem(CACHE_KEY))) || undefined);
-                // eslint-disable-next-line no-empty
-            }
-            catch { }
-        },
-        async set(authorizationResult) {
-            try {
-                await AsyncStorage.setItem(CACHE_KEY, JSON.stringify(authorizationResult));
-                // eslint-disable-next-line no-empty
-            }
-            catch { }
-        },
-    };
+	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 {}
+		}
+	};
 }
-
-async function defaultWalletNotFoundHandler(mobileWalletAdapter) {
-    return walletStandardMobile.defaultErrorModalWalletNotFoundHandler();
+//#endregion
+//#region src/createDefaultWalletNotFoundHandler.ts
+async function defaultWalletNotFoundHandler(_mobileWalletAdapter) {
+	return (0, _solana_mobile_wallet_standard_mobile.defaultErrorModalWalletNotFoundHandler)();
 }
 function createDefaultWalletNotFoundHandler() {
-    return defaultWalletNotFoundHandler;
+	return defaultWalletNotFoundHandler;
 }
-
+//#endregion
 exports.LocalSolanaMobileWalletAdapter = LocalSolanaMobileWalletAdapter;
 exports.RemoteSolanaMobileWalletAdapter = RemoteSolanaMobileWalletAdapter;
 exports.SolanaMobileWalletAdapter = SolanaMobileWalletAdapter;
@@ -436,3 +383,5 @@ exports.SolanaMobileWalletAdapterWalletName = SolanaMobileWalletAdapterWalletNam
 exports.createDefaultAddressSelector = createDefaultAddressSelector;
 exports.createDefaultAuthorizationResultCache = createDefaultAuthorizationResultCache;
 exports.createDefaultWalletNotFoundHandler = createDefaultWalletNotFoundHandler;
+
+//# sourceMappingURL=index.native.js.map