@solana-mobile/wallet-adapter-mobile 0.0.1-alpha.0

package/lib/cjs/index.js

@@ -0,0 +1,344 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var mobileWalletAdapterProtocol = require('@solana-mobile/mobile-wallet-adapter-protocol');
+var walletAdapterBase = require('@solana/wallet-adapter-base');
+var web3_js = require('@solana/web3.js');
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+const SolanaMobileWalletAdapterWalletName = 'Default wallet app';
+const SIGNATURE_LENGTH_IN_BYTES = 64;
+function getBase64StringFromByteArray(byteArray) {
+    return btoa(String.fromCharCode.call(null, ...byteArray));
+}
+function getByteArrayFromBase64String(base64EncodedByteArray) {
+    return new Uint8Array(atob(base64EncodedByteArray)
+        .split('')
+        .map((c) => c.charCodeAt(0)));
+}
+class SolanaMobileWalletAdapter extends walletAdapterBase.BaseMessageSignerWalletAdapter {
+    constructor(config) {
+        super();
+        this.name = SolanaMobileWalletAdapterWalletName;
+        this.url = 'https://solanamobile.com';
+        this.icon = 'data:image/svg+xml;base64,PHN2ZyBmaWxsPSJub25lIiBoZWlnaHQ9IjI4IiB3aWR0aD0iMjgiIHZpZXdCb3g9Ii0zIDAgMjggMjgiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PGcgZmlsbD0iI0RDQjhGRiI+PHBhdGggZD0iTTE3LjQgMTcuNEgxNXYyLjRoMi40di0yLjRabTEuMi05LjZoLTIuNHYyLjRoMi40VjcuOFoiLz48cGF0aCBkPSJNMjEuNiAzVjBoLTIuNHYzaC0zLjZWMGgtMi40djNoLTIuNHY2LjZINC41YTIuMSAyLjEgMCAxIDEgMC00LjJoMi43VjNINC41QTQuNSA0LjUgMCAwIDAgMCA3LjVWMjRoMjEuNnYtNi42aC0yLjR2NC4ySDIuNFYxMS41Yy41LjMgMS4yLjQgMS44LjVoNy41QTYuNiA2LjYgMCAwIDAgMjQgOVYzaC0yLjRabTAgNS43YTQuMiA0LjIgMCAxIDEtOC40IDBWNS40aDguNHYzLjNaIi8+PC9nPjwvc3ZnPg==';
+        this._connecting = false;
+        this._readyState = typeof window === 'undefined' ||
+            typeof document === 'undefined' ||
+            !/android/i.test(navigator.userAgent) ||
+            !window.isSecureContext
+            ? walletAdapterBase.WalletReadyState.Unsupported
+            : walletAdapterBase.WalletReadyState.Loadable;
+        this._authorizationResultCache = config.authorizationResultCache;
+        this._appIdentity = config.appIdentity;
+        if (this._readyState !== walletAdapterBase.WalletReadyState.Unsupported) {
+            this._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.emit('readyStateChange', (this._readyState = walletAdapterBase.WalletReadyState.Installed));
+                }
+            });
+        }
+    }
+    get publicKey() {
+        if (this._publicKey == null && this._authorizationResult != null) {
+            this._publicKey = new web3_js.PublicKey(this._authorizationResult.publicKey);
+        }
+        return this._publicKey ? this._publicKey : null;
+    }
+    get connected() {
+        return !!this._authorizationResult;
+    }
+    get connecting() {
+        return this._connecting;
+    }
+    get readyState() {
+        return this._readyState;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._readyState !== walletAdapterBase.WalletReadyState.Installed && this._readyState !== walletAdapterBase.WalletReadyState.Loadable) {
+                const err = new walletAdapterBase.WalletNotReadyError();
+                this.emit('error', err);
+                throw err;
+            }
+            this._connecting = true;
+            const cachedAuthorizationResult = yield this._authorizationResultCache.get();
+            if (cachedAuthorizationResult) {
+                this._authorizationResult = cachedAuthorizationResult;
+                this._connecting = false;
+                if (this._readyState !== walletAdapterBase.WalletReadyState.Installed) {
+                    this.emit('readyStateChange', (this._readyState = walletAdapterBase.WalletReadyState.Installed));
+                }
+                this.emit('connect', 
+                // Having just set an `authorizationResult`, `this.publicKey` is definitely non-null
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                this.publicKey);
+                return;
+            }
+            try {
+                yield this.withWallet((mobileWallet) => __awaiter(this, void 0, void 0, function* () {
+                    const { auth_token, pub_key: base58PublicKey, wallet_uri_base, } = yield mobileWallet('authorize', { identity: this._appIdentity });
+                    try {
+                        this._publicKey = new web3_js.PublicKey(base58PublicKey);
+                    }
+                    catch (e) {
+                        throw new walletAdapterBase.WalletPublicKeyError((e instanceof Error && (e === null || e === void 0 ? void 0 : e.message)) || 'Unknown error', e);
+                    }
+                    this.handleAuthorizationResult({
+                        authToken: auth_token,
+                        publicKey: base58PublicKey,
+                        walletUriBase: wallet_uri_base,
+                    }); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
+                    this.emit('connect', 
+                    // Having just set an `authorizationResult`, `this.publicKey` is definitely non-null
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    this.publicKey);
+                }));
+            }
+            catch (e) {
+                throw new walletAdapterBase.WalletConnectionError((e instanceof Error && e.message) || 'Unknown error', e);
+            }
+            finally {
+                this._connecting = false;
+            }
+        });
+    }
+    handleAuthorizationResult(authorizationResult) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._authorizationResult = authorizationResult;
+            yield this._authorizationResultCache.set(authorizationResult);
+        });
+    }
+    performReauthorization(mobileWallet, currentAuthorizationResult) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { auth_token } = yield mobileWallet('reauthorize', {
+                    auth_token: currentAuthorizationResult.authToken,
+                });
+                if (currentAuthorizationResult.authToken !== auth_token) {
+                    this.handleAuthorizationResult(Object.assign(Object.assign({}, currentAuthorizationResult), { authToken: auth_token })); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
+                }
+                return auth_token;
+            }
+            catch (e) {
+                this.disconnect();
+                throw new walletAdapterBase.WalletDisconnectedError((e instanceof Error && (e === null || e === void 0 ? void 0 : e.message)) || 'Unknown error', e);
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._authorizationResultCache.clear(); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
+            delete this._authorizationResult;
+            delete this._publicKey;
+            this.emit('disconnect');
+        });
+    }
+    withWallet(callback) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletUriBase = (_a = this._authorizationResult) === null || _a === void 0 ? void 0 : _a.walletUriBase;
+            const config = walletUriBase ? { baseUri: walletUriBase } : undefined;
+            return yield mobileWalletAdapterProtocol.withLocalWallet(callback, config);
+        });
+    }
+    assertIsAuthorized() {
+        const authorizationResult = this._authorizationResult;
+        if (!authorizationResult)
+            throw new walletAdapterBase.WalletNotConnectedError();
+        return authorizationResult;
+    }
+    performSignTransactions(transactions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authorizationResult = this.assertIsAuthorized();
+                try {
+                    const serializedTransactions = transactions.map((transaction) => transaction.serialize({
+                        requireAllSignatures: false,
+                        verifySignatures: false,
+                    }));
+                    const payloads = serializedTransactions.map((serializedTransaction) => serializedTransaction.toString('base64'));
+                    return yield this.withWallet((mobileWallet) => __awaiter(this, void 0, void 0, function* () {
+                        const freshAuthToken = yield this.performReauthorization(mobileWallet, authorizationResult);
+                        const { signed_payloads: base64EncodedCompiledTransactions } = yield mobileWallet('sign_transaction', { auth_token: freshAuthToken, payloads });
+                        const compiledTransactions = base64EncodedCompiledTransactions.map(getByteArrayFromBase64String);
+                        const transactions = compiledTransactions.map(web3_js.Transaction.from);
+                        return transactions;
+                    }));
+                }
+                catch (error) {
+                    throw new walletAdapterBase.WalletSignTransactionError(error === null || error === void 0 ? void 0 : error.message, error);
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+                throw error;
+            }
+        });
+    }
+    sendTransaction(transaction, connection, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authorizationResult = this.assertIsAuthorized();
+                try {
+                    if (transaction.feePayer == null) {
+                        transaction.feePayer = this.publicKey || undefined;
+                    }
+                    if (transaction.recentBlockhash == null) {
+                        const { blockhash } = yield connection.getRecentBlockhash(connection.commitment);
+                        transaction.recentBlockhash = blockhash;
+                    }
+                    const serializedTransaction = transaction.serialize({
+                        requireAllSignatures: false,
+                        verifySignatures: false,
+                    });
+                    const payloads = [serializedTransaction.toString('base64')];
+                    return yield this.withWallet((mobileWallet) => __awaiter(this, void 0, void 0, function* () {
+                        const freshAuthToken = yield this.performReauthorization(mobileWallet, authorizationResult);
+                        let targetCommitment;
+                        switch (connection.commitment) {
+                            case 'confirmed':
+                            case 'finalized':
+                            case 'processed':
+                                targetCommitment = connection.commitment;
+                                break;
+                            default:
+                                targetCommitment = 'finalized';
+                        }
+                        const { signatures } = yield mobileWallet('sign_and_send_transaction', {
+                            auth_token: freshAuthToken,
+                            commitment: targetCommitment,
+                            payloads,
+                        });
+                        return signatures[0];
+                    }));
+                }
+                catch (error) {
+                    throw new walletAdapterBase.WalletSendTransactionError(error === null || error === void 0 ? void 0 : error.message, error);
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+                throw error;
+            }
+        });
+    }
+    signTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [signedTransaction] = yield this.performSignTransactions([transaction]);
+            return signedTransaction;
+        });
+    }
+    signAllTransactions(transactions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signedTransactions = yield this.performSignTransactions(transactions);
+            return signedTransactions;
+        });
+    }
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authorizationResult = this.assertIsAuthorized();
+                try {
+                    return yield this.withWallet((mobileWallet) => __awaiter(this, void 0, void 0, function* () {
+                        const freshAuthToken = yield this.performReauthorization(mobileWallet, authorizationResult);
+                        const { signed_payloads: [base64EncodedSignedMessage], } = yield mobileWallet('sign_message', {
+                            auth_token: freshAuthToken,
+                            payloads: [getBase64StringFromByteArray(message)],
+                        });
+                        const signedMessage = getByteArrayFromBase64String(base64EncodedSignedMessage);
+                        const signature = signedMessage.slice(-SIGNATURE_LENGTH_IN_BYTES);
+                        return signature;
+                    }));
+                }
+                catch (error) {
+                    throw new walletAdapterBase.WalletSignMessageError(error === null || error === void 0 ? void 0 : error.message, error);
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+                throw error;
+            }
+        });
+    }
+}
+
+const CACHE_KEY = 'SolanaMobileWalletAdapterDefaultAuthorizationCache';
+function createDefaultAuthorizationResultCache() {
+    let storage;
+    try {
+        storage = window.localStorage;
+        // eslint-disable-next-line no-empty
+    }
+    catch (_a) { }
+    return {
+        clear() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!storage) {
+                    return;
+                }
+                try {
+                    storage.removeItem(CACHE_KEY);
+                    // eslint-disable-next-line no-empty
+                }
+                catch (_a) { }
+            });
+        },
+        get() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!storage) {
+                    return;
+                }
+                try {
+                    return JSON.parse(storage.getItem(CACHE_KEY)) || undefined;
+                    // eslint-disable-next-line no-empty
+                }
+                catch (_a) { }
+            });
+        },
+        set(authorizationResult) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!storage) {
+                    return;
+                }
+                try {
+                    storage.setItem(CACHE_KEY, JSON.stringify(authorizationResult));
+                    // eslint-disable-next-line no-empty
+                }
+                catch (_a) { }
+            });
+        },
+    };
+}
+
+exports.SolanaMobileWalletAdapter = SolanaMobileWalletAdapter;
+exports.SolanaMobileWalletAdapterWalletName = SolanaMobileWalletAdapterWalletName;
+exports.createDefaultAuthorizationResultCache = createDefaultAuthorizationResultCache;

package/lib/cjs/package.json

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

package/lib/esm/index.browser.mjs

@@ -0,0 +1,338 @@
+import { withLocalWallet } from '@solana-mobile/mobile-wallet-adapter-protocol';
+import { BaseMessageSignerWalletAdapter, WalletReadyState, WalletNotReadyError, WalletPublicKeyError, WalletConnectionError, WalletDisconnectedError, WalletNotConnectedError, WalletSignTransactionError, WalletSendTransactionError, WalletSignMessageError } from '@solana/wallet-adapter-base';
+import { PublicKey, Transaction } from '@solana/web3.js';
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+const SolanaMobileWalletAdapterWalletName = 'Default wallet app';
+const SIGNATURE_LENGTH_IN_BYTES = 64;
+function getBase64StringFromByteArray(byteArray) {
+    return btoa(String.fromCharCode.call(null, ...byteArray));
+}
+function getByteArrayFromBase64String(base64EncodedByteArray) {
+    return new Uint8Array(atob(base64EncodedByteArray)
+        .split('')
+        .map((c) => c.charCodeAt(0)));
+}
+class SolanaMobileWalletAdapter extends BaseMessageSignerWalletAdapter {
+    constructor(config) {
+        super();
+        this.name = SolanaMobileWalletAdapterWalletName;
+        this.url = 'https://solanamobile.com';
+        this.icon = 'data:image/svg+xml;base64,PHN2ZyBmaWxsPSJub25lIiBoZWlnaHQ9IjI4IiB3aWR0aD0iMjgiIHZpZXdCb3g9Ii0zIDAgMjggMjgiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PGcgZmlsbD0iI0RDQjhGRiI+PHBhdGggZD0iTTE3LjQgMTcuNEgxNXYyLjRoMi40di0yLjRabTEuMi05LjZoLTIuNHYyLjRoMi40VjcuOFoiLz48cGF0aCBkPSJNMjEuNiAzVjBoLTIuNHYzaC0zLjZWMGgtMi40djNoLTIuNHY2LjZINC41YTIuMSAyLjEgMCAxIDEgMC00LjJoMi43VjNINC41QTQuNSA0LjUgMCAwIDAgMCA3LjVWMjRoMjEuNnYtNi42aC0yLjR2NC4ySDIuNFYxMS41Yy41LjMgMS4yLjQgMS44LjVoNy41QTYuNiA2LjYgMCAwIDAgMjQgOVYzaC0yLjRabTAgNS43YTQuMiA0LjIgMCAxIDEtOC40IDBWNS40aDguNHYzLjNaIi8+PC9nPjwvc3ZnPg==';
+        this._connecting = false;
+        this._readyState = typeof window === 'undefined' ||
+            typeof document === 'undefined' ||
+            !/android/i.test(navigator.userAgent) ||
+            !window.isSecureContext
+            ? WalletReadyState.Unsupported
+            : WalletReadyState.Loadable;
+        this._authorizationResultCache = config.authorizationResultCache;
+        this._appIdentity = config.appIdentity;
+        if (this._readyState !== WalletReadyState.Unsupported) {
+            this._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.emit('readyStateChange', (this._readyState = WalletReadyState.Installed));
+                }
+            });
+        }
+    }
+    get publicKey() {
+        if (this._publicKey == null && this._authorizationResult != null) {
+            this._publicKey = new PublicKey(this._authorizationResult.publicKey);
+        }
+        return this._publicKey ? this._publicKey : null;
+    }
+    get connected() {
+        return !!this._authorizationResult;
+    }
+    get connecting() {
+        return this._connecting;
+    }
+    get readyState() {
+        return this._readyState;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._readyState !== WalletReadyState.Installed && this._readyState !== WalletReadyState.Loadable) {
+                const err = new WalletNotReadyError();
+                this.emit('error', err);
+                throw err;
+            }
+            this._connecting = true;
+            const cachedAuthorizationResult = yield this._authorizationResultCache.get();
+            if (cachedAuthorizationResult) {
+                this._authorizationResult = cachedAuthorizationResult;
+                this._connecting = false;
+                if (this._readyState !== WalletReadyState.Installed) {
+                    this.emit('readyStateChange', (this._readyState = WalletReadyState.Installed));
+                }
+                this.emit('connect', 
+                // Having just set an `authorizationResult`, `this.publicKey` is definitely non-null
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                this.publicKey);
+                return;
+            }
+            try {
+                yield this.withWallet((mobileWallet) => __awaiter(this, void 0, void 0, function* () {
+                    const { auth_token, pub_key: base58PublicKey, wallet_uri_base, } = yield mobileWallet('authorize', { identity: this._appIdentity });
+                    try {
+                        this._publicKey = new PublicKey(base58PublicKey);
+                    }
+                    catch (e) {
+                        throw new WalletPublicKeyError((e instanceof Error && (e === null || e === void 0 ? void 0 : e.message)) || 'Unknown error', e);
+                    }
+                    this.handleAuthorizationResult({
+                        authToken: auth_token,
+                        publicKey: base58PublicKey,
+                        walletUriBase: wallet_uri_base,
+                    }); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
+                    this.emit('connect', 
+                    // Having just set an `authorizationResult`, `this.publicKey` is definitely non-null
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    this.publicKey);
+                }));
+            }
+            catch (e) {
+                throw new WalletConnectionError((e instanceof Error && e.message) || 'Unknown error', e);
+            }
+            finally {
+                this._connecting = false;
+            }
+        });
+    }
+    handleAuthorizationResult(authorizationResult) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._authorizationResult = authorizationResult;
+            yield this._authorizationResultCache.set(authorizationResult);
+        });
+    }
+    performReauthorization(mobileWallet, currentAuthorizationResult) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { auth_token } = yield mobileWallet('reauthorize', {
+                    auth_token: currentAuthorizationResult.authToken,
+                });
+                if (currentAuthorizationResult.authToken !== auth_token) {
+                    this.handleAuthorizationResult(Object.assign(Object.assign({}, currentAuthorizationResult), { authToken: auth_token })); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
+                }
+                return auth_token;
+            }
+            catch (e) {
+                this.disconnect();
+                throw new WalletDisconnectedError((e instanceof Error && (e === null || e === void 0 ? void 0 : e.message)) || 'Unknown error', e);
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._authorizationResultCache.clear(); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
+            delete this._authorizationResult;
+            delete this._publicKey;
+            this.emit('disconnect');
+        });
+    }
+    withWallet(callback) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletUriBase = (_a = this._authorizationResult) === null || _a === void 0 ? void 0 : _a.walletUriBase;
+            const config = walletUriBase ? { baseUri: walletUriBase } : undefined;
+            return yield withLocalWallet(callback, config);
+        });
+    }
+    assertIsAuthorized() {
+        const authorizationResult = this._authorizationResult;
+        if (!authorizationResult)
+            throw new WalletNotConnectedError();
+        return authorizationResult;
+    }
+    performSignTransactions(transactions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authorizationResult = this.assertIsAuthorized();
+                try {
+                    const serializedTransactions = transactions.map((transaction) => transaction.serialize({
+                        requireAllSignatures: false,
+                        verifySignatures: false,
+                    }));
+                    const payloads = serializedTransactions.map((serializedTransaction) => serializedTransaction.toString('base64'));
+                    return yield this.withWallet((mobileWallet) => __awaiter(this, void 0, void 0, function* () {
+                        const freshAuthToken = yield this.performReauthorization(mobileWallet, authorizationResult);
+                        const { signed_payloads: base64EncodedCompiledTransactions } = yield mobileWallet('sign_transaction', { auth_token: freshAuthToken, payloads });
+                        const compiledTransactions = base64EncodedCompiledTransactions.map(getByteArrayFromBase64String);
+                        const transactions = compiledTransactions.map(Transaction.from);
+                        return transactions;
+                    }));
+                }
+                catch (error) {
+                    throw new WalletSignTransactionError(error === null || error === void 0 ? void 0 : error.message, error);
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+                throw error;
+            }
+        });
+    }
+    sendTransaction(transaction, connection, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authorizationResult = this.assertIsAuthorized();
+                try {
+                    if (transaction.feePayer == null) {
+                        transaction.feePayer = this.publicKey || undefined;
+                    }
+                    if (transaction.recentBlockhash == null) {
+                        const { blockhash } = yield connection.getRecentBlockhash(connection.commitment);
+                        transaction.recentBlockhash = blockhash;
+                    }
+                    const serializedTransaction = transaction.serialize({
+                        requireAllSignatures: false,
+                        verifySignatures: false,
+                    });
+                    const payloads = [serializedTransaction.toString('base64')];
+                    return yield this.withWallet((mobileWallet) => __awaiter(this, void 0, void 0, function* () {
+                        const freshAuthToken = yield this.performReauthorization(mobileWallet, authorizationResult);
+                        let targetCommitment;
+                        switch (connection.commitment) {
+                            case 'confirmed':
+                            case 'finalized':
+                            case 'processed':
+                                targetCommitment = connection.commitment;
+                                break;
+                            default:
+                                targetCommitment = 'finalized';
+                        }
+                        const { signatures } = yield mobileWallet('sign_and_send_transaction', {
+                            auth_token: freshAuthToken,
+                            commitment: targetCommitment,
+                            payloads,
+                        });
+                        return signatures[0];
+                    }));
+                }
+                catch (error) {
+                    throw new WalletSendTransactionError(error === null || error === void 0 ? void 0 : error.message, error);
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+                throw error;
+            }
+        });
+    }
+    signTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [signedTransaction] = yield this.performSignTransactions([transaction]);
+            return signedTransaction;
+        });
+    }
+    signAllTransactions(transactions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signedTransactions = yield this.performSignTransactions(transactions);
+            return signedTransactions;
+        });
+    }
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authorizationResult = this.assertIsAuthorized();
+                try {
+                    return yield this.withWallet((mobileWallet) => __awaiter(this, void 0, void 0, function* () {
+                        const freshAuthToken = yield this.performReauthorization(mobileWallet, authorizationResult);
+                        const { signed_payloads: [base64EncodedSignedMessage], } = yield mobileWallet('sign_message', {
+                            auth_token: freshAuthToken,
+                            payloads: [getBase64StringFromByteArray(message)],
+                        });
+                        const signedMessage = getByteArrayFromBase64String(base64EncodedSignedMessage);
+                        const signature = signedMessage.slice(-SIGNATURE_LENGTH_IN_BYTES);
+                        return signature;
+                    }));
+                }
+                catch (error) {
+                    throw new WalletSignMessageError(error === null || error === void 0 ? void 0 : error.message, error);
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+                throw error;
+            }
+        });
+    }
+}
+
+const CACHE_KEY = 'SolanaMobileWalletAdapterDefaultAuthorizationCache';
+function createDefaultAuthorizationResultCache() {
+    let storage;
+    try {
+        storage = window.localStorage;
+        // eslint-disable-next-line no-empty
+    }
+    catch (_a) { }
+    return {
+        clear() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!storage) {
+                    return;
+                }
+                try {
+                    storage.removeItem(CACHE_KEY);
+                    // eslint-disable-next-line no-empty
+                }
+                catch (_a) { }
+            });
+        },
+        get() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!storage) {
+                    return;
+                }
+                try {
+                    return JSON.parse(storage.getItem(CACHE_KEY)) || undefined;
+                    // eslint-disable-next-line no-empty
+                }
+                catch (_a) { }
+            });
+        },
+        set(authorizationResult) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!storage) {
+                    return;
+                }
+                try {
+                    storage.setItem(CACHE_KEY, JSON.stringify(authorizationResult));
+                    // eslint-disable-next-line no-empty
+                }
+                catch (_a) { }
+            });
+        },
+    };
+}
+
+export { SolanaMobileWalletAdapter, SolanaMobileWalletAdapterWalletName, createDefaultAuthorizationResultCache };