fix: missing test update and w3a context

Author: tuna1207

packages/modal/test/modalManager.test.ts

@@ -133,7 +133,7 @@ describe("Web3Auth (modal)", () => {
   it("connect resolves on CONSENT_ACCEPTED when consent is required", async () => {
     const sdk = createSdk({
       uiConfig: {
-        consentRequired: true,
+        consentConfig: { required: true },
         privacyPolicy: "https://example.com/privacy",
         tncLink: "https://example.com/terms",
       } as never,

packages/no-modal/src/noModal.ts

@@ -409,6 +409,7 @@ export class Web3AuthNoModal extends SafeEventEmitter<Web3AuthNoModalEvents> imp
         this.removeListener(CONNECTOR_EVENTS.CONNECTED, onConnected);
         this.removeListener(CONNECTOR_EVENTS.ERRORED, onErrored);
         this.removeListener(CONNECTOR_EVENTS.AUTHORIZED, onAuthorized);
+        this.removeListener(CONNECTOR_EVENTS.CONSENT_ACCEPTED, onConsentAccepted);
       };
 
       const checkCompletion = async () => {
@@ -449,6 +450,10 @@ export class Web3AuthNoModal extends SafeEventEmitter<Web3AuthNoModalEvents> imp
         await checkCompletion();
       };
 
+      const onConsentAccepted = async () => {
+        await completeConnection();
+      };
+
       const onErrored = async (err: Web3AuthError) => {
         // track connection failed event
         this.analytics.track(ANALYTICS_EVENTS.CONNECTION_FAILED, {
@@ -464,6 +469,9 @@ export class Web3AuthNoModal extends SafeEventEmitter<Web3AuthNoModalEvents> imp
       if (finalLoginParams.getAuthTokenInfo) {
         this.once(CONNECTOR_EVENTS.AUTHORIZED, onAuthorized);
       }
+      if (this.consentRequired) {
+        this.once(CONNECTOR_EVENTS.CONSENT_ACCEPTED, onConsentAccepted);
+      }
       this.once(CONNECTOR_EVENTS.ERRORED, onErrored);
       connector.connect(finalLoginParams);
       this.setCurrentChain(initialChain.chainId);

packages/no-modal/src/react/context/useWeb3AuthInnerContextValue.ts

@@ -39,6 +39,29 @@ type UseWeb3AuthInnerContextValueOptions<TWeb3Auth extends IWeb3Auth, TWeb3AuthO
   initEffectDependency?: unknown;
 };
 
+type InitialWeb3AuthState = {
+  chainId: string | null;
+  chainNamespace: ChainNamespaceType | null;
+  connection: Connection | null;
+  isAuthorized: boolean;
+  isConnected: boolean;
+  status: CONNECTOR_STATUS_TYPE | null;
+};
+
+function getInitialState(web3Auth: IWeb3Auth): InitialWeb3AuthState {
+  const isConnected = web3Auth.status === CONNECTOR_STATUS.CONNECTED;
+  const isAuthorized = web3Auth.status === CONNECTOR_STATUS.AUTHORIZED;
+
+  return {
+    chainId: isConnected ? web3Auth.currentChainId : null,
+    chainNamespace: isConnected ? (web3Auth.currentChain?.chainNamespace ?? null) : null,
+    connection: isConnected ? web3Auth.connection : null,
+    isAuthorized,
+    isConnected,
+    status: web3Auth.status,
+  };
+}
+
 export function useWeb3AuthInnerContextValue<TWeb3Auth extends IWeb3Auth, TWeb3AuthOptions>({
   Web3AuthConstructor,
   web3AuthOptions,
@@ -47,20 +70,20 @@ export function useWeb3AuthInnerContextValue<TWeb3Auth extends IWeb3Auth, TWeb3A
   cleanupOnUnmount = false,
   initEffectDependency,
 }: UseWeb3AuthInnerContextValueOptions<TWeb3Auth, TWeb3AuthOptions>): IWeb3AuthInnerContextValue<TWeb3Auth> {
-  const [chainId, setChainId] = useState<string | null>(null);
-  const [chainNamespace, setChainNamespace] = useState<ChainNamespaceType | null>(null);
+  const web3Auth = useMemo(() => {
+    return new Web3AuthConstructor(web3AuthOptions, initialState);
+  }, [Web3AuthConstructor, web3AuthOptions, initialState]);
+  const initialWeb3AuthState = getInitialState(web3Auth);
+  const [chainId, setChainId] = useState<string | null>(() => initialWeb3AuthState.chainId);
+  const [chainNamespace, setChainNamespace] = useState<ChainNamespaceType | null>(() => initialWeb3AuthState.chainNamespace);
   const [isInitializing, setIsInitializing] = useState<boolean>(false);
   const [initError, setInitError] = useState<Error | null>(null);
-  const [connection, setConnection] = useState<Connection | null>(null);
+  const [connection, setConnection] = useState<Connection | null>(() => initialWeb3AuthState.connection);
   const [isInitialized, setIsInitialized] = useState<boolean>(false);
   const [isMFAEnabled, setIsMFAEnabled] = useState<boolean>(false);
-  const web3Auth = useMemo(() => {
-    setConnection(null);
-    return new Web3AuthConstructor(web3AuthOptions, initialState);
-  }, [Web3AuthConstructor, web3AuthOptions, initialState]);
-  const [isConnected, setIsConnected] = useState<boolean>(false);
-  const [status, setStatus] = useState<CONNECTOR_STATUS_TYPE | null>(null);
-  const [isAuthorized, setIsAuthorized] = useState<boolean>(false);
+  const [isConnected, setIsConnected] = useState<boolean>(initialWeb3AuthState.isConnected);
+  const [status, setStatus] = useState<CONNECTOR_STATUS_TYPE | null>(initialWeb3AuthState.status);
+  const [isAuthorized, setIsAuthorized] = useState<boolean>(initialWeb3AuthState.isAuthorized);
 
   const getPlugin = useCallback(
     ((name: string) => {
@@ -70,6 +93,19 @@ export function useWeb3AuthInnerContextValue<TWeb3Auth extends IWeb3Auth, TWeb3A
     [web3Auth]
   );
 
+  // Reset derived hook state when a new SDK instance is created.
+  useEffect(() => {
+    const nextState = getInitialState(web3Auth);
+
+    setConnection(nextState.connection);
+    setIsMFAEnabled(false);
+    setIsConnected(nextState.isConnected);
+    setIsAuthorized(nextState.isAuthorized);
+    setStatus(nextState.status);
+    setChainId(nextState.chainId);
+    setChainNamespace(nextState.chainNamespace);
+  }, [web3Auth]);
+
   useEffect(() => {
     const controller = new AbortController();
 

packages/no-modal/test/noModal.test.ts

@@ -1,4 +1,4 @@
-import { beforeAll, describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 
 import {
   CHAIN_NAMESPACES,
@@ -41,15 +41,13 @@ class TestWeb3AuthNoModal extends Web3AuthNoModal {
   public exposeSubscribeToConnectorEvents(connector: MockConnector) {
     this.subscribeToConnectorEvents(connector as unknown as IConnector<unknown>);
   }
+
+  public exposeCompleteConsentAcceptance() {
+    return this.completeConsentAcceptance();
+  }
 }
 
 describe("Web3AuthNoModal", () => {
-  beforeAll(() => {
-    vi.stubGlobal("window", {
-      location: { origin: "http://localhost:3000" },
-    });
-  });
-
   it("throws when clientId is missing", () => {
     expect(
       () =>
@@ -273,20 +271,21 @@ describe("Web3AuthNoModal", () => {
     await expect(sdk.getUserInfo()).rejects.toThrow(WalletLoginError);
   });
 
-  it("auto-skips consent UI when consent:<userId> is true", async () => {
+  it("auto-skips consent UI when prior consent is true", async () => {
     const storage = createMockStorage();
-    await storage.set(WEB3AUTH_STATE_STORAGE_KEY, JSON.stringify({ consentDecisions: { "0xabc123": true } }));
+    await storage.set(WEB3AUTH_STATE_STORAGE_KEY, JSON.stringify({ hasUserConsent: true }));
     const sdk = createSdk({
       initialAuthenticationMode: CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN,
       storage: { sessionId: storage },
     });
+    await Promise.resolve();
     sdk.exposeSetConsentRequired(true);
     const consentRequiredListener = vi.fn();
     sdk.on(CONNECTOR_EVENTS.CONSENT_REQUIRING, consentRequiredListener);
 
     const ethereumProvider = { request: vi.fn().mockResolvedValue(["0xAbC123"]) };
-    const consentAcceptedListener = vi.fn();
-    sdk.on(CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
+    const authorizedListener = vi.fn();
+    sdk.on(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
     const connector = new MockConnector({ name: WALLET_CONNECTORS.METAMASK } as never);
     (sdk as unknown as { connectors: MockConnector[] }).connectors = [connector];
     sdk.exposeSubscribeToConnectorEvents(connector);
@@ -309,20 +308,21 @@ describe("Web3AuthNoModal", () => {
       authTokenInfo: { idToken: "id-token" },
     });
     await vi.waitFor(() => {
-      expect(consentAcceptedListener).toHaveBeenCalledTimes(1);
+      expect(authorizedListener).toHaveBeenCalledTimes(1);
     });
 
     expect(sdk.status).toBe(CONNECTOR_STATUS.AUTHORIZED);
     expect(consentRequiredListener).not.toHaveBeenCalled();
   });
 
-  it("shows consent UI when stored decision is false", async () => {
+  it("shows consent UI when prior consent is false", async () => {
     const storage = createMockStorage();
-    await storage.set(WEB3AUTH_STATE_STORAGE_KEY, JSON.stringify({ consentDecisions: { "0xbeef": false } }));
+    await storage.set(WEB3AUTH_STATE_STORAGE_KEY, JSON.stringify({ hasUserConsent: false }));
     const sdk = createSdk({
       initialAuthenticationMode: CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_ONLY,
       storage: { sessionId: storage },
     });
+    await Promise.resolve();
     sdk.exposeSetConsentRequired(true);
     const consentRequiredListener = vi.fn();
     sdk.on(CONNECTOR_EVENTS.CONSENT_REQUIRING, consentRequiredListener);
@@ -349,11 +349,11 @@ describe("Web3AuthNoModal", () => {
     await vi.waitFor(() => {
       expect(consentRequiredListener).toHaveBeenCalledTimes(1);
     });
-    await sdk.acceptConsent();
+    await sdk.exposeCompleteConsentAcceptance();
     await expect(connectionPromise).resolves.not.toBeNull();
   });
 
-  it("persists consent:<userId> when user accepts consent UI", async () => {
+  it("persists user consent when user accepts consent UI", async () => {
     const storage = createMockStorage();
     const sdk = createSdk({
       initialAuthenticationMode: CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_ONLY,
@@ -385,12 +385,12 @@ describe("Web3AuthNoModal", () => {
     await vi.waitFor(() => {
       expect(consentRequiredListener).toHaveBeenCalledTimes(1);
     });
-    await sdk.acceptConsent();
+    await sdk.exposeCompleteConsentAcceptance();
     await connectionPromise;
 
     const stateJson = await storage.get(WEB3AUTH_STATE_STORAGE_KEY);
     const state = JSON.parse(stateJson!);
-    expect(state.consentDecisions["0xfeed"]).toBe(true);
+    expect(state.hasUserConsent).toBe(true);
   });
 
   it("setConnectors deduplicates and emits updates only for new connectors", () => {

packages/no-modal/test/reactContext.test.ts

@@ -1,5 +1,5 @@
 import { SafeEventEmitter } from "@web3auth/auth";
-import { act, createElement } from "react";
+import { act, createElement, useMemo } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { afterEach, describe, expect, it } from "vitest";
 
@@ -41,6 +41,8 @@ let latestInstance: TestWeb3Auth | null = null;
 class TestWeb3Auth extends SafeEventEmitter<Web3AuthNoModalEvents> implements IWeb3Auth {
   public status: CONNECTOR_STATUS_TYPE;
 
+  public loginMode = LOGIN_MODE.MODAL;
+
   public currentChainId: string | null = null;
 
   public currentChain: CustomChainConfig | undefined = undefined;
@@ -68,16 +70,16 @@ class TestWeb3Auth extends SafeEventEmitter<Web3AuthNoModalEvents> implements IW
 type TestComponentProps = {
   renders: RenderSnapshot[];
   onValue?: (value: LiveSnapshot) => void;
-  seedStateFromStatus: boolean;
   status: CONNECTOR_STATUS_TYPE;
 };
 
-function TestComponent({ renders, onValue, seedStateFromStatus, status }: TestComponentProps): null {
+function TestComponent({ renders, onValue, status }: TestComponentProps): null {
+  const web3AuthOptions = useMemo(() => ({ status }), [status]);
+
   // @ts-expect-error - For testing purposes
   const value = useWeb3AuthInnerContextValue<TestWeb3Auth, TestWeb3AuthOptions>({
     Web3AuthConstructor: TestWeb3Auth,
-    web3AuthOptions: { status },
-    seedStateFromStatus,
+    web3AuthOptions,
   });
 
   const snapshot: LiveSnapshot = {
@@ -99,7 +101,7 @@ function TestComponent({ renders, onValue, seedStateFromStatus, status }: TestCo
   return null;
 }
 
-async function renderHook(options: TestWeb3AuthOptions & { seedStateFromStatus: boolean }) {
+async function renderHook(options: TestWeb3AuthOptions) {
   const renders: RenderSnapshot[] = [];
   const latestValue: { current: LiveSnapshot | null } = { current: null };
   const container = document.createElement("div");
@@ -113,7 +115,6 @@ async function renderHook(options: TestWeb3AuthOptions & { seedStateFromStatus:
         onValue: (value: LiveSnapshot) => {
           latestValue.current = value;
         },
-        seedStateFromStatus: options.seedStateFromStatus,
         status: options.status,
       })
     );
@@ -139,9 +140,8 @@ describe("useWeb3AuthInnerContextValue", () => {
     latestInstance = null;
   });
 
-  it("seeds a connected first render from sdk status when enabled", async () => {
+  it("seeds a connected first render from sdk status", async () => {
     const rendered = await renderHook({
-      seedStateFromStatus: true,
       status: CONNECTOR_STATUS.CONNECTED,
     });
     ({ root, container } = rendered);
@@ -153,9 +153,8 @@ describe("useWeb3AuthInnerContextValue", () => {
     });
   });
 
-  it("seeds an authorized first render from sdk status when enabled", async () => {
+  it("seeds an authorized first render from sdk status", async () => {
     const rendered = await renderHook({
-      seedStateFromStatus: true,
       status: CONNECTOR_STATUS.AUTHORIZED,
     });
     ({ root, container } = rendered);
@@ -167,23 +166,8 @@ describe("useWeb3AuthInnerContextValue", () => {
     });
   });
 
-  it("keeps the first render disconnected when seeding is disabled", async () => {
-    const rendered = await renderHook({
-      seedStateFromStatus: false,
-      status: CONNECTOR_STATUS.CONNECTED,
-    });
-    ({ root, container } = rendered);
-
-    expect(rendered.renders[0]).toEqual({
-      isConnected: false,
-      isAuthorized: false,
-      status: null,
-    });
-  });
-
   it("waits for consent acceptance before marking the hook connected", async () => {
     const rendered = await renderHook({
-      seedStateFromStatus: false,
       status: CONNECTOR_STATUS.CONNECTING,
     });
     ({ root, container } = rendered);