@bounded-sh/client 0.0.112 → 0.0.113

package/dist/{injected-wallet-provider-D1ygndjX.mjs → injected-wallet-provider-DxPcYxP-.mjs}

@@ -1,5 +1,5 @@
 import { getActiveSessionManager, genAuthNonce, genSolanaSignInRequest, createSessionWithSignature } from '@bounded-sh/core';
-import { e as bs58, f as getWallets, i as isSolanaMobileWallet, j as solanaMobileWalletLeavesPage, r as resolveSolanaWalletStandardChain, n as normalizeSolanaRpcUrl, k as setAuthLoading, s as setCurrentUser, l as bufferExports, m as setStoredAuthMethod, g as getPlatform, t as transactionHasSignature, o as confirmAndCheckTransaction, p as resolveSolanaRpcUrl } from './index.native-DyR93n8K.mjs';
+import { e as bs58, f as getWallets, i as isSolanaMobileWallet, j as solanaMobileWalletLeavesPage, k as solanaMobileWalletAnswersSignInFromCache, r as resolveSolanaWalletStandardChain, w as walletStandardFeatureName, n as normalizeSolanaRpcUrl, l as setAuthLoading, s as setCurrentUser, m as bufferExports, o as setStoredAuthMethod, g as getPlatform, t as transactionHasSignature, p as confirmAndCheckTransaction, q as resolveSolanaRpcUrl } from './index.native-DcW2klyn.mjs';
 import 'react';
 
 const crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
@@ -2468,7 +2468,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) => 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,
@@ -2543,13 +2545,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 (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 };
             },
         }
@@ -2832,37 +2844,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;
         setAuthLoading(true);
         try {
             const provider = this.resolveProvider();
-            const address = await this.connectAddress(provider);
-            // Reuse a still-valid session for THIS wallet.
-            const existing = await 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 getActiveSessionManager().getSession() : null;
+            if (trusted && existing && existing.address === trusted) {
+                const user = { address: trusted, id: trusted, provider: this };
+                this.authenticatedAddress = trusted;
                 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 genAuthNonce();
             const request = await 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.
@@ -3180,4 +3221,4 @@ class InjectedWalletProvider {
 }
 
 export { InjectedWalletProvider, WALLET_SIGN_IN_UNSUPPORTED_ERR, defaultInjectedProvider };
-//# sourceMappingURL=injected-wallet-provider-D1ygndjX.mjs.map
+//# sourceMappingURL=injected-wallet-provider-DxPcYxP-.mjs.map