@bounded-sh/client 0.0.112 → 0.0.114

package/dist/{injected-wallet-provider-nwd3ialR.js → injected-wallet-provider-Dqmk-m4V.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var core = require('@bounded-sh/core');
-var index_native = require('./index.native-C5glqiTU.js');
+var index_native = require('./index.native-DJSOqyKQ.js');
 require('react');
 
 const crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
@@ -2470,7 +2470,9 @@ function standardWalletToInjectedProvider(wallet, configuredNetwork) {
     // mobile adapter fills DEFAULT_FEATURES in exactly that case. So an empty list
     // means none, and reading it as "everything" picks an account that cannot sign
     // and fails at the wallet instead of here.
-    const accountSupports = (account, feature) => account.features.includes(feature);
+    // The mobile adapter hands a wallet app's own feature names through
+    // untranslated, so each name is read as its Wallet Standard equivalent.
+    const accountSupports = (account, feature) => account.features.some((f) => index_native.walletStandardFeatureName(f) === feature);
     const pickSolanaAccount = (accounts) => {
         // With a network configured, an account that does not support it is not a
         // usable account: `WalletAccount.chains` is what that account can sign for,
@@ -2545,13 +2547,23 @@ function standardWalletToInjectedProvider(wallet, configuredNetwork) {
         } }, (hasFeature(wallet, SolanaSignIn)
         ? {
             async signIn(input) {
-                const acc = requireAccount();
-                if (!accountSupports(acc, SolanaSignIn))
-                    throw new Error("Wallet account does not support solana:signIn");
+                var _a;
                 const sign = feature(wallet, SolanaSignIn);
                 if (!sign)
                     throw new Error("Wallet does not support solana:signIn");
+                const open = currentAccount();
+                if (open && !accountSupports(open, SolanaSignIn))
+                    throw new Error("Wallet account does not support solana:signIn");
+                if (index_native.solanaMobileWalletAnswersSignInFromCache(wallet.name)) {
+                    // Drop the cached authorization so this sign-in is performed by the
+                    // wallet app, with its payload, rather than answered from a record
+                    // that holds no sign-in result or an earlier sign-in's spent nonce.
+                    // Local to the page: the adapter's disconnect opens nothing.
+                    await ((_a = feature(wallet, StandardDisconnect)) === null || _a === void 0 ? void 0 : _a.disconnect());
+                }
                 const [out] = await sign.signIn(input);
+                if (!out)
+                    throw new Error("Wallet returned no sign-in result");
                 return { account: { address: out.account.address }, signedMessage: out.signedMessage, signature: out.signature };
             },
         }
@@ -2834,37 +2846,66 @@ class InjectedWalletProvider {
             throw new Error('Wallet did not return a public key on connect');
         return pk.toString();
     }
+    /**
+     * The account the wallet already holds open for this page, named WITHOUT a
+     * prompt: a live connection, else a silent connect (an injected wallet that
+     * still trusts the page; the mobile wallet's cached authorization, read from
+     * storage). Null when the wallet would have to ask the user.
+     */
+    async trustedAddress(provider) {
+        try {
+            return await this.connectAddress(provider, true);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
     async login() {
+        var _a;
         index_native.setAuthLoading(true);
         try {
             const provider = this.resolveProvider();
-            const address = await this.connectAddress(provider);
-            // Reuse a still-valid session for THIS wallet.
-            const existing = await core.getActiveSessionManager().getSession();
-            if (existing && existing.address === address) {
-                const user = { address, id: address, provider: this };
-                this.authenticatedAddress = address;
+            // SEC-01: a wallet without Sign In With Solana is refused before it is
+            // asked anything, never downgraded to plain message signing.
+            if (typeof provider.signIn !== 'function')
+                throw new Error(WALLET_SIGN_IN_UNSUPPORTED_ERR);
+            // Reuse a still-valid session for THIS wallet, when the wallet names its
+            // account without prompting. Nothing here opens the wallet: the sign-in
+            // below is the one interactive step of a login.
+            const trusted = await this.trustedAddress(provider);
+            const existing = trusted ? await core.getActiveSessionManager().getSession() : null;
+            if (trusted && existing && existing.address === trusted) {
+                const user = { address: trusted, id: trusted, provider: this };
+                this.authenticatedAddress = trusted;
                 index_native.setCurrentUser(user);
                 this.markAuthMethod();
                 return user;
             }
-            // Sign In With Solana (SEC-01): the wallet renders the standard sign-in
-            // text and, with the domain left unset here, stamps THIS page's host; the
-            // issuer refuses any other domain for the request's Origin, so a phishing
-            // page cannot obtain a login for another site. Bounded chooses only the nonce,
-            // the validity window and the app id (Request ID); a wallet without the
-            // feature is refused, never downgraded to plain message signing. The
-            // nonce is fetched HERE, after connect, on purpose: a network round trip
-            // before the wallet handoff decays the transient activation the mobile
-            // wallet's intent navigation needs.
-            if (typeof provider.signIn !== 'function')
-                throw new Error(WALLET_SIGN_IN_UNSUPPORTED_ERR);
+            // Sign In With Solana (SEC-01) is connect and sign in ONE wallet step:
+            // the wallet authorizes an account, renders the standard sign-in text
+            // for it and, with the domain left unset here, stamps THIS page's host;
+            // the issuer refuses any other domain for the request's Origin, so a
+            // phishing page cannot obtain a login for another site. Bounded chooses
+            // only the nonce, the validity window and the app id (Request ID).
+            // No separate connect comes first: the mobile adapter would answer the
+            // sign-in from the authorization that connect cached, with no sign-in
+            // result in it, and a second wallet prompt is friction for every other
+            // wallet. The nonce is fetched BEFORE the gesture below, so nothing
+            // async sits between the tap and the wallet handoff - a network round
+            // trip there decays the transient activation the mobile wallet's intent
+            // navigation needs.
             const nonce = await core.genAuthNonce();
             const request = await core.genSolanaSignInRequest(nonce);
-            await this.freshActivation(provider, 'login', address);
+            await this.freshActivation(provider, 'login', trusted);
             const signedIn = normalizeSignInOutput(await provider.signIn(request));
-            if (signedIn.account.address !== address) {
-                throw new Error(`The wallet signed in as ${signedIn.account.address}, not the connected account ${address}. Sign in again.`);
+            const address = signedIn.account.address;
+            // The account the wallet now reports as open must be the one that signed
+            // in: a proof for another account would bind this session to an identity
+            // the wallet is not acting as (DS2-0369). A wallet that reports no account
+            // leaves the sign-in output as the only word on which one it is.
+            const active = (_a = provider.publicKey) === null || _a === void 0 ? void 0 : _a.toString();
+            if (active && active !== address) {
+                throw new Error(`The wallet signed in as ${address}, not the connected account ${active}. Sign in again.`);
             }
             // The issuer verifies the signature over the EXACT bytes the wallet signed
             // and parses them, so the text travels as the wallet rendered it.
@@ -3184,4 +3225,4 @@ class InjectedWalletProvider {
 exports.InjectedWalletProvider = InjectedWalletProvider;
 exports.WALLET_SIGN_IN_UNSUPPORTED_ERR = WALLET_SIGN_IN_UNSUPPORTED_ERR;
 exports.defaultInjectedProvider = defaultInjectedProvider;
-//# sourceMappingURL=injected-wallet-provider-nwd3ialR.js.map
+//# sourceMappingURL=injected-wallet-provider-Dqmk-m4V.js.map