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

package/LICENSE

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

package/README.md

@@ -0,0 +1,72 @@
+# `@solana-mobile/wallet-adapter-mobile`
+
+This is a plugin for use with [`@solana/wallet-adapter`](https://github.com/solana-labs/wallet-adapter). It enables apps to use a native wallet app on a mobile device to sign messages and transactions, and to send transactions if the wallet offers support for sending transactions.
+
+![A screenshot showing the Solana Mobile wallet adapter in use with the wallet adapter dialog](https://user-images.githubusercontent.com/13243/174880433-92486385-6f9a-4221-bb55-c05bab057be6.png)
+
+## Usage
+
+Create an instance of the mobile wallet adapter like this.
+
+```typescript
+new SolanaMobileWalletAdapter({
+    appIdentity: {
+        name: 'My app',
+        uri: 'https://myapp.io',
+        icon: 'relative/path/to/icon.png',
+    },
+    authorizationResultCache: createDefaultAuthorizationResultCache(),
+});
+```
+
+Use that adapter instance alongside the other adapters used by your app.
+
+```typescript
+const wallets = useMemo(() => [
+    new SolanaMobileWalletAdapter({
+        appIdentity: {
+            name: 'My app',
+            uri: 'https://myapp.io',
+            icon: 'relative/path/to/icon.png',
+       },
+        authorizationResultCache: createDefaultAuthorizationResultCache(),
+    });
+    new PhantomWalletAdapter(),
+    /* ... other wallets ... */
+]);
+
+return (
+    <ConnectionProvider endpoint={clusterApiUrl(WalletAdapterNetwork.Devnet)}>
+        <WalletProvider wallets={wallets}>
+            <MyApp />
+        </WalletProvider>
+    </ConnectionProvider>
+)
+```
+
+For more information about how to use wallet adapter plugins, visit https://github.com/solana-labs/wallet-adapter
+
+## Configuration
+
+### App identity
+
+The `AppIdentity` config identifies your app to a native mobile wallet. When someone connects to a wallet for the first time, the wallet may present this information in the on-screen prompt where the ask if the visitor would like to authorize your app for use with their account.
+
+- `name` &ndash; The plain-language name of your application.
+- `uri` &ndash; The uri of your application. This uri may be required to participate in [dApp identity verification](https://github.com/solana-mobile/mobile-wallet-adapter/blob/main/spec/spec.md#dapp-identity-verification) as part of the mobile wallet adapter protocol specification.
+- `icon` &ndash; An icon file path, relative to the `uri`.
+
+### Authorization result cache
+
+The first time that someone authorizes a native wallet app for use with your application, you should cache that authorization for future use. You can supply your own implementation that conforms to the `AuthorizationResultCache` interface.
+
+```typescript
+export interface AuthorizationResultCache {
+    clear(): Promise<void>;
+    get(): Promise<AuthorizationResult | undefined>;
+    set(authorizationResult: AuthorizationResult): Promise<void>;
+}
+```
+
+Alternatively, you can use the included `createDefaultAuthorizationResultCache()` method to create a cache that reads and writes the adapter's last-obtained `AuthorizationResult` to your browser's local storage, if available.
+

package/lib/cjs/index.browser.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;