@solana-mobile/wallet-adapter-mobile 0.0.1-alpha.6 → 0.9.0

package/README.md

@@ -10,6 +10,7 @@ Create an instance of the mobile wallet adapter like this.
 
 ```typescript
 new SolanaMobileWalletAdapter({
+    addressSelector: createDefaultAddressSelector(),
     appIdentity: {
         name: 'My app',
         uri: 'https://myapp.io',
@@ -24,6 +25,7 @@ Use that adapter instance alongside the other adapters used by your app.
 ```typescript
 const wallets = useMemo(() => [
     new SolanaMobileWalletAdapter({
+        addressSelector: createDefaultAddressSelector(),
         appIdentity: {
             name: 'My app',
             uri: 'https://myapp.io',

package/lib/cjs/index.browser.js

@@ -31,6 +31,13 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
+function toUint8Array(base64EncodedByteArray) {
+    return new Uint8Array(window
+        .atob(base64EncodedByteArray)
+        .split('')
+        .map((c) => c.charCodeAt(0)));
+}
+
 function getIsSupported() {
     return (typeof window !== 'undefined' &&
         window.isSecureContext &&
@@ -40,6 +47,10 @@ function getIsSupported() {
 
 const SolanaMobileWalletAdapterWalletName = 'Default wallet app';
 const SIGNATURE_LENGTH_IN_BYTES = 64;
+function getPublicKeyFromAddress(address) {
+    const publicKeyByteArray = toUint8Array(address);
+    return new web3_js.PublicKey(publicKeyByteArray);
+}
 class SolanaMobileWalletAdapter extends walletAdapterBase.BaseMessageSignerWalletAdapter {
     constructor(config) {
         super();
@@ -49,7 +60,9 @@ class SolanaMobileWalletAdapter extends walletAdapterBase.BaseMessageSignerWalle
         this._connecting = false;
         this._readyState = getIsSupported() ? walletAdapterBase.WalletReadyState.Loadable : walletAdapterBase.WalletReadyState.Unsupported;
         this._authorizationResultCache = config.authorizationResultCache;
+        this._addressSelector = config.addressSelector;
         this._appIdentity = config.appIdentity;
+        this._cluster = config.cluster;
         if (this._readyState !== walletAdapterBase.WalletReadyState.Unsupported) {
             this._authorizationResultCache.get().then((authorizationResult) => {
                 if (authorizationResult) {
@@ -62,8 +75,13 @@ class SolanaMobileWalletAdapter extends walletAdapterBase.BaseMessageSignerWalle
         }
     }
     get publicKey() {
-        if (this._publicKey == null && this._authorizationResult != null) {
-            this._publicKey = new web3_js.PublicKey(this._authorizationResult.pub_key);
+        if (this._publicKey == null && this._selectedAddress != null) {
+            try {
+                this._publicKey = getPublicKeyFromAddress(this._selectedAddress);
+            }
+            catch (e) {
+                throw new walletAdapterBase.WalletPublicKeyError((e instanceof Error && (e === null || e === void 0 ? void 0 : e.message)) || 'Unknown error', e);
+            }
         }
         return this._publicKey ? this._publicKey : null;
     }
@@ -76,71 +94,88 @@ class SolanaMobileWalletAdapter extends walletAdapterBase.BaseMessageSignerWalle
     get readyState() {
         return this._readyState;
     }
-    connect() {
+    runWithGuard(callback) {
         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;
+            try {
+                return yield callback();
             }
-            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;
+            catch (e) {
+                this.emit('error', e);
+                throw e;
             }
-            try {
-                yield this.transact((wallet) => __awaiter(this, void 0, void 0, function* () {
-                    const { auth_token, pub_key: base58PublicKey, wallet_uri_base, } = yield wallet.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);
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.runWithGuard(() => __awaiter(this, void 0, void 0, function* () {
+                if (this._readyState !== walletAdapterBase.WalletReadyState.Installed && this._readyState !== walletAdapterBase.WalletReadyState.Loadable) {
+                    throw new walletAdapterBase.WalletNotReadyError();
+                }
+                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.handleAuthorizationResult({
-                        auth_token,
-                        pub_key: base58PublicKey,
-                        wallet_uri_base: wallet_uri_base,
-                    }); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
+                    this._selectedAddress = yield this._addressSelector.select(cachedAuthorizationResult.accounts.map(({ address }) => address));
                     this.emit('connect', 
-                    // Having just set an `authorizationResult`, `this.publicKey` is definitely non-null
+                    // Having just set `this._selectedAddress`, `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;
-            }
+                    return;
+                }
+                try {
+                    yield this.transact((wallet) => __awaiter(this, void 0, void 0, function* () {
+                        const authorizationResult = yield wallet.authorize({
+                            cluster: this._cluster,
+                            identity: this._appIdentity,
+                        });
+                        this.handleAuthorizationResult(authorizationResult); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
+                    }));
+                }
+                catch (e) {
+                    throw new walletAdapterBase.WalletConnectionError((e instanceof Error && e.message) || 'Unknown error', e);
+                }
+                finally {
+                    this._connecting = false;
+                }
+            }));
         });
     }
     handleAuthorizationResult(authorizationResult) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            const didPublicKeysChange = 
+            // Case 1: We started from having no authorization.
+            this._authorizationResult == null ||
+                // Case 2: The number of authorized accounts changed.
+                ((_a = this._authorizationResult) === null || _a === void 0 ? void 0 : _a.accounts.length) !== authorizationResult.accounts.length ||
+                // Case 3: The new list of addresses isn't exactly the same as the old list, in the same order.
+                this._authorizationResult.accounts.some((account, ii) => account.address !== authorizationResult.accounts[ii].address);
             this._authorizationResult = authorizationResult;
+            if (didPublicKeysChange) {
+                const nextSelectedAddress = yield this._addressSelector.select(authorizationResult.accounts.map(({ address }) => address));
+                if (nextSelectedAddress !== this._selectedAddress) {
+                    this._selectedAddress = nextSelectedAddress;
+                    delete this._publicKey;
+                    this.emit('connect', 
+                    // Having just set `this._selectedAddress`, `this.publicKey` is definitely non-null
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    this.publicKey);
+                }
+            }
             yield this._authorizationResultCache.set(authorizationResult);
         });
     }
-    performReauthorization(wallet, currentAuthorizationResult) {
+    performReauthorization(wallet, authToken) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const { auth_token } = yield wallet.reauthorize({
-                    auth_token: currentAuthorizationResult.auth_token,
+                const authorizationResult = yield wallet.reauthorize({
+                    auth_token: authToken,
                 });
-                if (currentAuthorizationResult.auth_token !== auth_token) {
-                    this.handleAuthorizationResult(Object.assign(Object.assign({}, currentAuthorizationResult), { auth_token })); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
-                }
-                return auth_token;
+                this.handleAuthorizationResult(authorizationResult); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
             }
             catch (e) {
                 this.disconnect();
@@ -153,6 +188,7 @@ class SolanaMobileWalletAdapter extends walletAdapterBase.BaseMessageSignerWalle
             this._authorizationResultCache.clear(); // TODO: Evaluate whether there's any threat to not `awaiting` this expression
             delete this._authorizationResult;
             delete this._publicKey;
+            delete this._selectedAddress;
             this.emit('disconnect');
         });
     }
@@ -165,46 +201,82 @@ class SolanaMobileWalletAdapter extends walletAdapterBase.BaseMessageSignerWalle
         });
     }
     assertIsAuthorized() {
-        const authorizationResult = this._authorizationResult;
-        if (!authorizationResult)
+        if (!this._authorizationResult || !this._selectedAddress)
             throw new walletAdapterBase.WalletNotConnectedError();
-        return authorizationResult;
+        return {
+            authToken: this._authorizationResult.auth_token,
+            selectedAddress: this._selectedAddress,
+        };
     }
     performSignTransactions(transactions) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { authToken } = this.assertIsAuthorized();
             try {
-                const authorizationResult = this.assertIsAuthorized();
-                try {
-                    return yield this.transact((wallet) => __awaiter(this, void 0, void 0, function* () {
-                        const freshAuthToken = yield this.performReauthorization(wallet, authorizationResult);
-                        const signedTransactions = yield wallet.signTransaction({
-                            auth_token: freshAuthToken,
-                            transactions,
-                        });
-                        return signedTransactions;
-                    }));
-                }
-                catch (error) {
-                    throw new walletAdapterBase.WalletSignTransactionError(error === null || error === void 0 ? void 0 : error.message, error);
-                }
+                return yield this.transact((wallet) => __awaiter(this, void 0, void 0, function* () {
+                    yield this.performReauthorization(wallet, authToken);
+                    const signedTransactions = yield wallet.signTransactions({
+                        transactions,
+                    });
+                    return signedTransactions;
+                }));
             }
             catch (error) {
-                this.emit('error', error);
-                throw error;
+                throw new walletAdapterBase.WalletSignTransactionError(error === null || error === void 0 ? void 0 : error.message, error);
             }
         });
     }
-    sendTransaction(transaction, connection, _options) {
+    sendTransaction(transaction, connection, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const authorizationResult = this.assertIsAuthorized();
+            return yield this.runWithGuard(() => __awaiter(this, void 0, void 0, function* () {
+                const { authToken } = this.assertIsAuthorized();
+                const minContextSlot = options === null || options === void 0 ? void 0 : options.minContextSlot;
                 try {
                     return yield this.transact((wallet) => __awaiter(this, void 0, void 0, function* () {
-                        const freshAuthToken = yield this.performReauthorization(wallet, authorizationResult);
-                        const signatures = yield wallet.signAndSendTransaction({
-                            auth_token: freshAuthToken,
-                            fee_payer: this.publicKey || undefined,
-                            connection,
+                        var _a;
+                        let targetCommitment;
+                        switch (connection.commitment) {
+                            case 'confirmed':
+                            case 'finalized':
+                            case 'processed':
+                                targetCommitment = connection.commitment;
+                                break;
+                            default:
+                                targetCommitment = 'finalized';
+                        }
+                        let targetPreflightCommitment;
+                        switch (options === null || options === void 0 ? void 0 : options.preflightCommitment) {
+                            case 'confirmed':
+                            case 'finalized':
+                            case 'processed':
+                                targetPreflightCommitment = options.preflightCommitment;
+                                break;
+                            case undefined:
+                                targetPreflightCommitment = targetCommitment;
+                            default:
+                                targetPreflightCommitment = 'finalized';
+                        }
+                        yield Promise.all([
+                            this.performReauthorization(wallet, authToken),
+                            (() => __awaiter(this, void 0, void 0, function* () {
+                                if (transaction.recentBlockhash == null) {
+                                    const preflightCommitmentScore = targetPreflightCommitment === 'finalized'
+                                        ? 2
+                                        : targetPreflightCommitment === 'confirmed'
+                                            ? 1
+                                            : 0;
+                                    const targetCommitmentScore = targetCommitment === 'finalized' ? 2 : targetCommitment === 'confirmed' ? 1 : 0;
+                                    const { blockhash } = yield connection.getLatestBlockhash({
+                                        commitment: preflightCommitmentScore < targetCommitmentScore
+                                            ? targetPreflightCommitment
+                                            : targetCommitment,
+                                    });
+                                    transaction.recentBlockhash = blockhash;
+                                }
+                            }))(),
+                        ]);
+                        transaction.feePayer || (transaction.feePayer = (_a = this.publicKey) !== null && _a !== void 0 ? _a : undefined);
+                        const signatures = yield wallet.signAndSendTransactions({
+                            minContextSlot,
                             transactions: [transaction],
                         });
                         return signatures[0];
@@ -213,34 +285,34 @@ class SolanaMobileWalletAdapter extends walletAdapterBase.BaseMessageSignerWalle
                 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;
+            return yield this.runWithGuard(() => __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;
+            return yield this.runWithGuard(() => __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();
+            return yield this.runWithGuard(() => __awaiter(this, void 0, void 0, function* () {
+                const { authToken, selectedAddress } = this.assertIsAuthorized();
                 try {
                     return yield this.transact((wallet) => __awaiter(this, void 0, void 0, function* () {
-                        const freshAuthToken = yield this.performReauthorization(wallet, authorizationResult);
-                        const [signedMessage] = yield wallet.signMessage({
-                            auth_token: freshAuthToken,
+                        yield this.performReauthorization(wallet, authToken);
+                        const [signedMessage] = yield wallet.signMessages({
+                            addresses: [selectedAddress],
                             payloads: [message],
                         });
                         const signature = signedMessage.slice(-SIGNATURE_LENGTH_IN_BYTES);
@@ -250,15 +322,21 @@ class SolanaMobileWalletAdapter extends walletAdapterBase.BaseMessageSignerWalle
                 catch (error) {
                     throw new walletAdapterBase.WalletSignMessageError(error === null || error === void 0 ? void 0 : error.message, error);
                 }
-            }
-            catch (error) {
-                this.emit('error', error);
-                throw error;
-            }
+            }));
         });
     }
 }
 
+function createDefaultAddressSelector() {
+    return {
+        select(addresses) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return addresses[0];
+            });
+        },
+    };
+}
+
 const CACHE_KEY = 'SolanaMobileWalletAdapterDefaultAuthorizationCache';
 function createDefaultAuthorizationResultCache() {
     let storage;
@@ -309,4 +387,5 @@ function createDefaultAuthorizationResultCache() {
 
 exports.SolanaMobileWalletAdapter = SolanaMobileWalletAdapter;
 exports.SolanaMobileWalletAdapterWalletName = SolanaMobileWalletAdapterWalletName;
+exports.createDefaultAddressSelector = createDefaultAddressSelector;
 exports.createDefaultAuthorizationResultCache = createDefaultAuthorizationResultCache;