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

package/lib/esm/index.browser.js

@@ -1,410 +1,338 @@
-import { BaseSignInMessageSignerWalletAdapter, WalletReadyState, WalletPublicKeyError, WalletNotReadyError, WalletConnectionError, WalletSignMessageError, WalletSendTransactionError, WalletNotConnectedError, WalletSignTransactionError } from '@solana/wallet-adapter-base';
-import { PublicKey, VersionedMessage, Transaction, VersionedTransaction } from '@solana/web3.js';
-import { SolanaSignIn, SolanaSignMessage, SolanaSignAndSendTransaction, SolanaSignTransaction } from '@solana/wallet-standard-features';
-import { StandardEvents, StandardConnect, StandardDisconnect } from '@wallet-standard/core';
-import { SolanaMobileWalletAdapterRemoteWalletName as SolanaMobileWalletAdapterRemoteWalletName$1, SolanaMobileWalletAdapterWalletName as SolanaMobileWalletAdapterWalletName$1, LocalSolanaMobileWalletAdapterWallet, createDefaultChainSelector, RemoteSolanaMobileWalletAdapterWallet, createDefaultAuthorizationCache, defaultErrorModalWalletNotFoundHandler } from '@solana-mobile/wallet-standard-mobile';
-
+import { BaseSignInMessageSignerWalletAdapter, WalletConnectionError, WalletNotConnectedError, WalletNotReadyError, WalletPublicKeyError, WalletReadyState, WalletSendTransactionError, WalletSignMessageError, WalletSignTransactionError } from "@solana/wallet-adapter-base";
+import { PublicKey, Transaction, VersionedMessage, VersionedTransaction } from "@solana/web3.js";
+import { SolanaSignAndSendTransaction, SolanaSignIn, SolanaSignMessage, SolanaSignTransaction } from "@solana/wallet-standard-features";
+import { StandardConnect, StandardDisconnect, StandardEvents } from "@wallet-standard/core";
+import { LocalSolanaMobileWalletAdapterWallet, RemoteSolanaMobileWalletAdapterWallet, SolanaMobileWalletAdapterRemoteWalletName as SolanaMobileWalletAdapterRemoteWalletName$1, SolanaMobileWalletAdapterWalletName as SolanaMobileWalletAdapterWalletName$1, createDefaultAuthorizationCache, createDefaultChainSelector, defaultErrorModalWalletNotFoundHandler } from "@solana-mobile/wallet-standard-mobile";
+//#region src/base64Utils.ts
 function fromUint8Array(byteArray) {
-    return window.btoa(String.fromCharCode.call(null, ...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));
+	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;
+	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 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() ? 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 = 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 }) => 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;
-        // 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 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();
-            const authorizationResult = await await this.#wallet.cachedAuthorizationResult;
-            return authorizationResult;
-        }
-        catch (e) {
-            throw new 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[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 {
-                const outputs = await this.#wallet.features[SolanaSignMessage].signMessage({
-                    account, message: message
-                });
-                return outputs[0].signature;
-            }
-            catch (error) {
-                throw new 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 (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: chain,
-                        options: options ? {
-                            skipPreflight: options.skipPreflight,
-                            maxRetries: options.maxRetries
-                        } : undefined
-                    })).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(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 !== 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 numSignatures = byteArray[0];
-                        const messageOffset = numSignatures * SIGNATURE_LENGTH_IN_BYTES + 1;
-                        const version = VersionedMessage.deserializeMessageVersion(byteArray.slice(messageOffset, byteArray.length));
-                        if (version === '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(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 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: chain,
-        });
-    }
-}
-class RemoteSolanaMobileWalletAdapter 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: 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 {
-}
-
+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(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 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(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 () => {
+			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(error?.message, error);
+		}
+	}
+	async #runWithGuard(callback) {
+		try {
+			return await callback();
+		} catch (e) {
+			this.emit("error", 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];
-        },
-    };
+	return { async select(addresses) {
+		return addresses[0];
+	} };
 }
-
+//#endregion
+//#region src/createDefaultAuthorizationResultCache.ts
 function createDefaultAuthorizationResultCache() {
-    return createDefaultAuthorizationCache();
+	return createDefaultAuthorizationCache();
 }
-
+//#endregion
+//#region src/createDefaultWalletNotFoundHandler.ts
 async function defaultWalletNotFoundHandler(mobileWalletAdapter) {
-    return defaultErrorModalWalletNotFoundHandler();
+	return defaultErrorModalWalletNotFoundHandler();
 }
 function createDefaultWalletNotFoundHandler() {
-    return defaultWalletNotFoundHandler;
+	return defaultWalletNotFoundHandler;
 }
-
+//#endregion
 export { LocalSolanaMobileWalletAdapter, RemoteSolanaMobileWalletAdapter, SolanaMobileWalletAdapter, SolanaMobileWalletAdapterRemoteWalletName, SolanaMobileWalletAdapterWalletName, createDefaultAddressSelector, createDefaultAuthorizationResultCache, createDefaultWalletNotFoundHandler };
+
+//# sourceMappingURL=index.browser.js.map