fix: Fix SessionProvider.probe() returning undefined after ingestSessionFromRedirect

Fixes a regression introduced in #2401 where probe() would always return undefined
after calling ingestSessionFromRedirect on a deep link redirect (Capacitor, etc).

The issue: #2401 moved session restoration into _init(), which runs once during
construction. For deep links, the session data arrives *after* construction via
ingestSessionFromRedirect, so _init() never sees it. Result: probe() had no path
to create the account.

Changes:
- Separate concerns: _setSigningKeys() (sync) and _resolvePreset() (async)
- Restore on-demand retrieval: probe/connect/username call tryRetrieveSessionAccount
- Rename tryRetrieveFromQueryOrStorage to tryRetrieveSessionAccount for clarity
- Mark tryRetrieveSessionAccount as private since it's internal restoration logic
- Add comments explaining the two session entry points (localStorage and URL query)

This restores the pre-#2401 behavior of checking storage on every public method
call, allowing both web redirects (query param flow) and deep links (explicit call
flow) to work correctly.

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>

Author: kronosapiens

packages/controller/src/session/provider.ts

@@ -50,12 +50,12 @@ export default class SessionProvider extends BaseProvider {
   protected _disconnectRedirectUrl?: string;
   protected _policies: ParsedSessionPolicies;
   protected _preset?: string;
-  private _ready: Promise<void>;
   protected _keychainUrl: string;
   protected _apiUrl: string;
   protected _publicKey!: string;
   protected _sessionKeyGuid!: string;
   protected _signupOptions?: AuthOptions;
+  private _readyPromise: Promise<void>;
   public reopenBrowser: boolean = true;
 
   constructor({
@@ -102,35 +102,23 @@ export default class SessionProvider extends BaseProvider {
     this._apiUrl = apiUrl ?? API_URL;
     this._signupOptions = signupOptions;
 
-    // Eagerly start async init: resolve preset policies (if any),
-    // then try to restore an existing session from storage.
-    // All public async methods await this before proceeding.
-    this._ready = this._init();
+    this._setSigningKeys();
+    this._readyPromise = this._resolvePreset();
 
     if (typeof window !== "undefined") {
       (window as any).starknet_controller_session = this;
     }
   }
 
-  private async _init(): Promise<void> {
-    if (this._preset) {
-      const config = await loadConfig(this._preset);
-      if (!config) {
-        throw new Error(`Failed to load preset: ${this._preset}`);
-      }
-
-      const sessionPolicies = getPresetSessionPolicies(config, this._chainId);
-      if (!sessionPolicies) {
-        throw new Error(
-          `No policies found for chain ${this._chainId} in preset ${this._preset}`,
-        );
-      }
-
-      this._policies = parsePolicies(sessionPolicies);
-    }
-
-    const account = this.tryRetrieveFromQueryOrStorage();
-    if (!account) {
+  private _setSigningKeys(): void {
+    const signerString = localStorage.getItem("sessionSigner");
+    if (signerString) {
+      const signer = JSON.parse(signerString);
+      this._publicKey = signer.pubKey;
+      this._sessionKeyGuid = signerToGuid({
+        starknet: { privateKey: encode.addHexPrefix(signer.privKey) },
+      });
+    } else {
       const pk = stark.randomAddress();
       this._publicKey = ec.starkCurve.getStarkKey(pk);
 
@@ -144,20 +132,27 @@ export default class SessionProvider extends BaseProvider {
       this._sessionKeyGuid = signerToGuid({
         starknet: { privateKey: encode.addHexPrefix(pk) },
       });
-    } else {
-      const pk = localStorage.getItem("sessionSigner");
-      if (!pk) throw new Error("failed to get sessionSigner");
+    }
+  }
 
-      const jsonPk: {
-        privKey: string;
-        pubKey: string;
-      } = JSON.parse(pk);
+  // Resolve preset policies asynchronously.
+  // Public methods await this before proceeding.
+  private async _resolvePreset(): Promise<void> {
+    if (!this._preset) return;
 
-      this._publicKey = jsonPk.pubKey;
-      this._sessionKeyGuid = signerToGuid({
-        starknet: { privateKey: encode.addHexPrefix(jsonPk.privKey) },
-      });
+    const config = await loadConfig(this._preset);
+    if (!config) {
+      throw new Error(`Failed to load preset: ${this._preset}`);
     }
+
+    const sessionPolicies = getPresetSessionPolicies(config, this._chainId);
+    if (!sessionPolicies) {
+      throw new Error(
+        `No policies found for chain ${this._chainId} in preset ${this._preset}`,
+      );
+    }
+
+    this._policies = parsePolicies(sessionPolicies);
   }
 
   private validatePoliciesSubset(
@@ -247,17 +242,31 @@ export default class SessionProvider extends BaseProvider {
   }
 
   async username() {
-    await this._ready;
+    await this._readyPromise;
+
+    if (!this.account) {
+      this.tryRetrieveSessionAccount();
+    }
+
     return this._username;
   }
 
   async probe(): Promise<WalletAccount | undefined> {
-    await this._ready;
+    await this._readyPromise;
+
+    if (!this.account) {
+      this.tryRetrieveSessionAccount();
+    }
+
     return this.account;
   }
 
   async connect(): Promise<WalletAccount | undefined> {
-    await this._ready;
+    await this._readyPromise;
+
+    if (!this.account) {
+      this.tryRetrieveSessionAccount();
+    }
 
     if (this.account) {
       return this.account;
@@ -319,7 +328,7 @@ export default class SessionProvider extends BaseProvider {
       };
       localStorage.setItem("session", JSON.stringify(session));
 
-      this.tryRetrieveFromQueryOrStorage();
+      this.tryRetrieveSessionAccount();
 
       return this.account;
     } catch (e) {
@@ -367,15 +376,15 @@ export default class SessionProvider extends BaseProvider {
     return promise;
   }
 
-  tryRetrieveFromQueryOrStorage() {
+  // Try to retrieve the session account from localStorage or URL query params
+  private tryRetrieveSessionAccount() {
     if (this.account) {
       return this.account;
     }
 
-    const signerString = localStorage.getItem("sessionSigner");
-    const signer = signerString ? JSON.parse(signerString) : null;
     let sessionRegistration: SessionRegistration | null = null;
 
+    // Load session from localStorage (saved by ingestSessionFromRedirect or connect)
     const sessionString = localStorage.getItem("session");
     if (sessionString) {
       const parsed = JSON.parse(sessionString) as Partial<SessionRegistration>;
@@ -388,6 +397,7 @@ export default class SessionProvider extends BaseProvider {
       }
     }
 
+    // Ingest session from URL query params (web redirect flow)
     if (window.location.search.includes("startapp")) {
       const params = new URLSearchParams(window.location.search);
       const session = params.get("startapp");
@@ -411,6 +421,9 @@ export default class SessionProvider extends BaseProvider {
       }
     }
 
+    const signerString = localStorage.getItem("sessionSigner");
+    const signer = signerString ? JSON.parse(signerString) : null;
+
     if (!sessionRegistration || !signer) {
       return;
     }

packages/keychain/src/utils/api/generated.ts

@@ -5465,6 +5465,7 @@ export type Session = Node & {
   /** Whether the session has been revoked */
   isRevoked: Scalars["Boolean"];
   metadata?: Maybe<SessionMetadata>;
+  sessionKeyGUID?: Maybe<Scalars["String"]>;
   signer?: Maybe<Signer>;
   updatedAt: Scalars["Time"];
 };
@@ -5604,6 +5605,22 @@ export type SessionWhereInput = {
   isRevokedNEQ?: InputMaybe<Scalars["Boolean"]>;
   not?: InputMaybe<SessionWhereInput>;
   or?: InputMaybe<Array<SessionWhereInput>>;
+  /** session_key_guid field predicates */
+  sessionKeyGUID?: InputMaybe<Scalars["String"]>;
+  sessionKeyGUIDContains?: InputMaybe<Scalars["String"]>;
+  sessionKeyGUIDContainsFold?: InputMaybe<Scalars["String"]>;
+  sessionKeyGUIDEqualFold?: InputMaybe<Scalars["String"]>;
+  sessionKeyGUIDGT?: InputMaybe<Scalars["String"]>;
+  sessionKeyGUIDGTE?: InputMaybe<Scalars["String"]>;
+  sessionKeyGUIDHasPrefix?: InputMaybe<Scalars["String"]>;
+  sessionKeyGUIDHasSuffix?: InputMaybe<Scalars["String"]>;
+  sessionKeyGUIDIn?: InputMaybe<Array<Scalars["String"]>>;
+  sessionKeyGUIDIsNil?: InputMaybe<Scalars["Boolean"]>;
+  sessionKeyGUIDLT?: InputMaybe<Scalars["String"]>;
+  sessionKeyGUIDLTE?: InputMaybe<Scalars["String"]>;
+  sessionKeyGUIDNEQ?: InputMaybe<Scalars["String"]>;
+  sessionKeyGUIDNotIn?: InputMaybe<Array<Scalars["String"]>>;
+  sessionKeyGUIDNotNil?: InputMaybe<Scalars["Boolean"]>;
   /** updated_at field predicates */
   updatedAt?: InputMaybe<Scalars["Time"]>;
   updatedAtGT?: InputMaybe<Scalars["Time"]>;