@imtbl/wallet 2.12.7-alpha.1 → 2.12.7-alpha.11

package/src/connectWallet.test.ts

@@ -1,17 +1,21 @@
-jest.mock('@imtbl/auth', () => {
-  const Auth = jest.fn().mockImplementation(() => ({
-    getConfig: jest.fn().mockReturnValue({
-      authenticationDomain: 'https://auth.immutable.com',
-      passportDomain: 'https://passport.immutable.com',
-      oidcConfiguration: {
-        clientId: 'client',
-        redirectUri: 'https://redirect',
-      },
-    }),
-    getUser: jest.fn().mockResolvedValue({ profile: { sub: 'user' } }),
-    getUserOrLogin: jest.fn().mockResolvedValue({ profile: { sub: 'user' }, accessToken: 'token' }),
-  }));
+// Mock Auth with configurable behavior
+const mockAuthInstance = {
+  getConfig: jest.fn().mockReturnValue({
+    authenticationDomain: 'https://auth.immutable.com',
+    passportDomain: 'https://passport.immutable.com',
+    oidcConfiguration: {
+      clientId: 'client',
+      redirectUri: 'https://redirect',
+    },
+  }),
+  getUser: jest.fn().mockResolvedValue({ profile: { sub: 'user' } }),
+  getUserOrLogin: jest.fn().mockResolvedValue({ profile: { sub: 'user' }, accessToken: 'token' }),
+  loginCallback: jest.fn().mockResolvedValue(undefined),
+};
 
+const Auth = jest.fn().mockImplementation(() => mockAuthInstance);
+
+jest.mock('@imtbl/auth', () => {
   const TypedEventEmitter = jest.fn().mockImplementation(() => ({
     emit: jest.fn(),
     on: jest.fn(),
@@ -43,18 +47,6 @@ jest.mock('./zkEvm/zkEvmProvider', () => ({
   ZkEvmProvider: jest.fn(),
 }));
 
-jest.mock('./sequence/sequenceProvider', () => ({
-  SequenceProvider: jest.fn(),
-}));
-
-jest.mock('./sequence/signer', () => ({
-  createSequenceSigner: jest.fn().mockReturnValue({
-    getAddress: jest.fn().mockResolvedValue('0x1234'),
-    signPayload: jest.fn(),
-    signMessage: jest.fn(),
-  }),
-}));
-
 jest.mock('./provider/eip6963', () => ({
   announceProvider: jest.fn(),
   passportProviderInfo: { name: 'passport', rdns: 'com.immutable.passport', icon: '' },
@@ -64,7 +56,6 @@ const { connectWallet } = require('./connectWallet');
 
 const { announceProvider } = jest.requireMock('./provider/eip6963');
 const { ZkEvmProvider } = jest.requireMock('./zkEvm/zkEvmProvider');
-const { SequenceProvider } = jest.requireMock('./sequence/sequenceProvider');
 
 const zkEvmChain = {
   chainId: 13473,
@@ -74,15 +65,6 @@ const zkEvmChain = {
   name: 'Immutable zkEVM Testnet',
 };
 
-const arbitrumChain = {
-  chainId: 42161,
-  rpcUrl: 'https://arb1.arbitrum.io/rpc',
-  relayerUrl: 'https://next-arbitrum-one-relayer.sequence.app',
-  apiUrl: 'https://api.immutable.com',
-  name: 'Arbitrum One',
-  sequenceIdentityInstrumentEndpoint: 'https://sequence.immutable.com',
-};
-
 // Create a mock getUser function for tests
 const createGetUserMock = () => jest.fn().mockResolvedValue({
   profile: { sub: 'user' },
@@ -92,26 +74,461 @@ const createGetUserMock = () => jest.fn().mockResolvedValue({
 describe('connectWallet', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    Auth.mockClear();
+    mockAuthInstance.getUser.mockClear();
+    mockAuthInstance.getUserOrLogin.mockClear();
+    mockAuthInstance.loginCallback.mockClear();
   });
 
-  it('announces provider by default', async () => {
-    const getUser = createGetUserMock();
+  describe('with external getUser (existing tests)', () => {
+    it('announces provider by default', async () => {
+      const getUser = createGetUserMock();
 
-    const provider = await connectWallet({ getUser, chains: [zkEvmChain] });
+      const provider = await connectWallet({ getUser, chains: [zkEvmChain] });
 
-    expect(ZkEvmProvider).toHaveBeenCalled();
-    expect(announceProvider).toHaveBeenCalledWith({
-      info: expect.any(Object),
-      provider,
+      expect(ZkEvmProvider).toHaveBeenCalled();
+      expect(announceProvider).toHaveBeenCalledWith({
+        info: expect.any(Object),
+        provider,
+      });
+    });
+
+    it('does not announce provider when disabled', async () => {
+      const getUser = createGetUserMock();
+
+      await connectWallet({ getUser, chains: [zkEvmChain], announceProvider: false });
+
+      expect(announceProvider).not.toHaveBeenCalled();
+    });
+
+    it('uses provided getUser when supplied', async () => {
+      const getUser = createGetUserMock();
+
+      await connectWallet({ getUser, chains: [zkEvmChain] });
+
+      // Should NOT create internal Auth instance
+      expect(Auth).not.toHaveBeenCalled();
+      // Should use the provided getUser
+      expect(getUser).toHaveBeenCalled();
     });
   });
 
-  it('does not announce provider when disabled', async () => {
-    const getUser = createGetUserMock();
+  describe('default auth (no getUser provided)', () => {
+    describe('Auth instance creation', () => {
+      it('creates internal Auth instance when getUser is not provided', async () => {
+        await connectWallet({ chains: [zkEvmChain] });
+
+        expect(Auth).toHaveBeenCalledTimes(1);
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            scope: 'openid profile email offline_access transact',
+            audience: 'platform_api',
+            authenticationDomain: 'https://auth.immutable.com',
+          }),
+        );
+      });
+
+      it('uses getUserOrLogin from internal Auth', async () => {
+        await connectWallet({ chains: [zkEvmChain] });
+
+        // Internal Auth's getUserOrLogin should be called during setup
+        expect(mockAuthInstance.getUserOrLogin).toHaveBeenCalled();
+      });
+
+      it('derives passportDomain from chain apiUrl', async () => {
+        const customChain = {
+          ...zkEvmChain,
+          apiUrl: 'https://api.custom.immutable.com',
+        };
+
+        await connectWallet({ chains: [customChain] });
+
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            passportDomain: 'https://passport.custom.immutable.com',
+          }),
+        );
+      });
+
+      it('uses provided passportDomain if specified in chain config', async () => {
+        const customChain = {
+          ...zkEvmChain,
+          passportDomain: 'https://custom-passport.immutable.com',
+        };
+
+        await connectWallet({ chains: [customChain] });
+
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            passportDomain: 'https://custom-passport.immutable.com',
+          }),
+        );
+      });
+
+      it('uses default redirect URI fallback', async () => {
+        await connectWallet({ chains: [zkEvmChain] });
+
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            redirectUri: 'https://auth.immutable.com/im-logged-in',
+            popupRedirectUri: 'https://auth.immutable.com/im-logged-in',
+            logoutRedirectUri: 'https://auth.immutable.com/im-logged-in',
+          }),
+        );
+      });
+
+      it('passes popupOverlayOptions to Auth', async () => {
+        const popupOverlayOptions = {
+          disableGenericPopupOverlay: true,
+          disableBlockedPopupOverlay: false,
+        };
+
+        await connectWallet({ chains: [zkEvmChain], popupOverlayOptions });
+
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            popupOverlayOptions,
+          }),
+        );
+      });
+
+      it('passes crossSdkBridgeEnabled to Auth', async () => {
+        await connectWallet({ chains: [zkEvmChain], crossSdkBridgeEnabled: true });
+
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            crossSdkBridgeEnabled: true,
+          }),
+        );
+      });
+    });
+
+    describe('clientId auto-detection', () => {
+      it('uses sandbox client ID for testnet chain (chainId 13473)', async () => {
+        const testnetChain = {
+          ...zkEvmChain,
+          chainId: 13473,
+          apiUrl: 'https://api.sandbox.immutable.com',
+        };
+
+        await connectWallet({ chains: [testnetChain] });
+
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            clientId: 'mjtCL8mt06BtbxSkp2vbrYStKWnXVZfo', // Sandbox client ID
+          }),
+        );
+      });
+
+      it('uses production client ID for mainnet chain (chainId 13371)', async () => {
+        const mainnetChain = {
+          chainId: 13371,
+          rpcUrl: 'https://rpc.immutable.com',
+          relayerUrl: 'https://relayer.immutable.com',
+          apiUrl: 'https://api.immutable.com',
+          name: 'Immutable zkEVM Mainnet',
+        };
+
+        await connectWallet({ chains: [mainnetChain] });
+
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            clientId: 'PtQRK4iRJ8GkXjiz6xfImMAYhPhW0cYk', // Production client ID
+          }),
+        );
+      });
+
+      it('detects sandbox from apiUrl containing "sandbox"', async () => {
+        const sandboxChain = {
+          chainId: 99999, // unknown chainId
+          rpcUrl: 'https://rpc.custom.com',
+          relayerUrl: 'https://relayer.custom.com',
+          apiUrl: 'https://api.sandbox.custom.com', // "sandbox" in URL
+          name: 'Custom Sandbox Chain',
+          magicPublishableApiKey: 'pk_test_123',
+          magicProviderId: 'provider-123',
+        };
+
+        await connectWallet({ chains: [sandboxChain] });
+
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            clientId: 'mjtCL8mt06BtbxSkp2vbrYStKWnXVZfo', // Sandbox client ID
+          }),
+        );
+      });
+
+      it('detects sandbox from apiUrl containing "testnet"', async () => {
+        const testnetChain = {
+          chainId: 99999,
+          rpcUrl: 'https://rpc.testnet.custom.com',
+          relayerUrl: 'https://relayer.testnet.custom.com',
+          apiUrl: 'https://api.testnet.custom.com', // "testnet" in URL
+          name: 'Custom Testnet Chain',
+          magicPublishableApiKey: 'pk_test_123',
+          magicProviderId: 'provider-123',
+        };
+
+        await connectWallet({ chains: [testnetChain] });
+
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            clientId: 'mjtCL8mt06BtbxSkp2vbrYStKWnXVZfo', // Sandbox client ID
+          }),
+        );
+      });
+
+      it('uses provided clientId when explicitly set', async () => {
+        const customClientId = 'custom-client-id-123';
+
+        await connectWallet({ chains: [zkEvmChain], clientId: customClientId });
+
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            clientId: customClientId,
+          }),
+        );
+      });
 
-    await connectWallet({ getUser, chains: [zkEvmChain], announceProvider: false });
+      it('prefers provided clientId over auto-detected one', async () => {
+        const customClientId = 'custom-client-id-456';
+        const mainnetChain = {
+          chainId: 13371,
+          rpcUrl: 'https://rpc.immutable.com',
+          relayerUrl: 'https://relayer.immutable.com',
+          apiUrl: 'https://api.immutable.com',
+          name: 'Immutable zkEVM Mainnet',
+        };
 
-    expect(announceProvider).not.toHaveBeenCalled();
+        await connectWallet({ chains: [mainnetChain], clientId: customClientId });
+
+        // Should use custom, not production client ID
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            clientId: customClientId,
+          }),
+        );
+      });
+    });
+
+    describe('popup callback handling', () => {
+      it('sets up message listener for popup callback', async () => {
+        const addEventListenerSpy = jest.spyOn(window, 'addEventListener');
+
+        await connectWallet({ chains: [zkEvmChain] });
+
+        expect(addEventListenerSpy).toHaveBeenCalledWith('message', expect.any(Function));
+
+        addEventListenerSpy.mockRestore();
+      });
+
+      it('handles OAuth callback message with code and state', async () => {
+        let messageHandler: ((event: MessageEvent) => void) | null = null;
+        const addEventListenerSpy = jest.spyOn(window, 'addEventListener').mockImplementation((event, handler) => {
+          if (event === 'message') {
+            messageHandler = handler as (event: MessageEvent) => void;
+          }
+        });
+
+        const replaceStateSpy = jest.spyOn(window.history, 'replaceState').mockImplementation(() => {});
+
+        await connectWallet({ chains: [zkEvmChain] });
+
+        expect(messageHandler).not.toBeNull();
+
+        // Simulate popup callback message
+        const callbackMessage = {
+          data: {
+            code: 'auth-code-123',
+            state: 'state-456',
+          },
+        } as MessageEvent;
+
+        // Trigger the message event
+        const promise = messageHandler!(callbackMessage);
+
+        // Wait for async operations
+        await promise;
+        await Promise.resolve();
+
+        // Should call Auth.loginCallback
+        expect(mockAuthInstance.loginCallback).toHaveBeenCalled();
+
+        // Should update browser history with code/state
+        expect(replaceStateSpy).toHaveBeenCalledTimes(2);
+
+        addEventListenerSpy.mockRestore();
+        replaceStateSpy.mockRestore();
+      });
+
+      it('ignores messages without code and state', async () => {
+        let messageHandler: ((event: MessageEvent) => void) | null = null;
+        const addEventListenerSpy = jest.spyOn(window, 'addEventListener').mockImplementation((event, handler) => {
+          if (event === 'message') {
+            messageHandler = handler as (event: MessageEvent) => void;
+          }
+        });
+
+        await connectWallet({ chains: [zkEvmChain] });
+
+        // Simulate non-callback message
+        const regularMessage = {
+          data: {
+            someOtherData: 'value',
+          },
+        } as MessageEvent;
+
+        messageHandler!(regularMessage);
+
+        await Promise.resolve();
+
+        // Should NOT call Auth.loginCallback
+        expect(mockAuthInstance.loginCallback).not.toHaveBeenCalled();
+
+        addEventListenerSpy.mockRestore();
+      });
+
+      it('updates query string with code and state during callback', async () => {
+        let messageHandler: ((event: MessageEvent) => void) | null = null;
+        const addEventListenerSpy = jest.spyOn(window, 'addEventListener').mockImplementation((event, handler) => {
+          if (event === 'message') {
+            messageHandler = handler as (event: MessageEvent) => void;
+          }
+        });
+
+        const replaceStateSpy = jest.spyOn(window.history, 'replaceState').mockImplementation(() => {});
+
+        // Mock window.location.search
+        Object.defineProperty(window, 'location', {
+          value: { search: '?existing=param' },
+          writable: true,
+        });
+
+        await connectWallet({ chains: [zkEvmChain] });
+
+        const callbackMessage = {
+          data: {
+            code: 'test-code',
+            state: 'test-state',
+          },
+        } as MessageEvent;
+
+        const promise = messageHandler!(callbackMessage);
+        await promise;
+        await Promise.resolve();
+
+        // First call: add code and state
+        expect(replaceStateSpy).toHaveBeenNthCalledWith(
+          1,
+          null,
+          '',
+          expect.stringContaining('code=test-code'),
+        );
+        expect(replaceStateSpy).toHaveBeenNthCalledWith(
+          1,
+          null,
+          '',
+          expect.stringContaining('state=test-state'),
+        );
+
+        // Second call: remove code and state after callback
+        expect(replaceStateSpy).toHaveBeenNthCalledWith(
+          2,
+          null,
+          '',
+          expect.not.stringContaining('code='),
+        );
+
+        addEventListenerSpy.mockRestore();
+        replaceStateSpy.mockRestore();
+      });
+    });
+
+    describe('provider creation with default auth', () => {
+      it('creates provider successfully without getUser', async () => {
+        const provider = await connectWallet({ chains: [zkEvmChain] });
+
+        expect(provider).toBeDefined();
+        expect(ZkEvmProvider).toHaveBeenCalled();
+      });
+
+      it('passes getUser function to ZkEvmProvider', async () => {
+        await connectWallet({ chains: [zkEvmChain] });
+
+        const zkEvmProviderCall = (ZkEvmProvider as jest.Mock).mock.calls[0][0];
+        expect(zkEvmProviderCall.getUser).toEqual(expect.any(Function));
+      });
+
+      it('passes clientId to ZkEvmProvider', async () => {
+        await connectWallet({ chains: [zkEvmChain] });
+
+        const zkEvmProviderCall = (ZkEvmProvider as jest.Mock).mock.calls[0][0];
+        expect(zkEvmProviderCall.clientId).toBe('mjtCL8mt06BtbxSkp2vbrYStKWnXVZfo');
+      });
+
+      it('works with custom chain configuration', async () => {
+        const customChain = {
+          chainId: 99999,
+          rpcUrl: 'https://rpc.custom.com',
+          relayerUrl: 'https://relayer.custom.com',
+          apiUrl: 'https://api.custom.com',
+          passportDomain: 'https://passport.custom.com',
+          name: 'Custom Chain',
+          magicPublishableApiKey: 'pk_test_custom',
+          magicProviderId: 'provider-custom',
+        };
+
+        const provider = await connectWallet({ chains: [customChain] });
+
+        expect(provider).toBeDefined();
+        expect(Auth).toHaveBeenCalledWith(
+          expect.objectContaining({
+            passportDomain: 'https://passport.custom.com',
+          }),
+        );
+      });
+    });
+
+    describe('error handling', () => {
+      it('handles auth failure gracefully', async () => {
+        mockAuthInstance.getUserOrLogin.mockRejectedValueOnce(new Error('Auth failed'));
+
+        const provider = await connectWallet({ chains: [zkEvmChain] });
+
+        // Should still create provider (user will be null)
+        expect(provider).toBeDefined();
+        expect(ZkEvmProvider).toHaveBeenCalledWith(
+          expect.objectContaining({
+            user: null,
+          }),
+        );
+      });
+
+      it('handles loginCallback failure gracefully', async () => {
+        let messageHandler: ((event: MessageEvent) => void) | null = null;
+        const addEventListenerSpy = jest.spyOn(window, 'addEventListener').mockImplementation((event, handler) => {
+          if (event === 'message') {
+            messageHandler = handler as (event: MessageEvent) => void;
+          }
+        });
+
+        mockAuthInstance.loginCallback.mockRejectedValueOnce(new Error('Callback failed'));
+
+        await connectWallet({ chains: [zkEvmChain] });
+
+        const callbackMessage = {
+          data: {
+            code: 'test-code',
+            state: 'test-state',
+          },
+        } as MessageEvent;
+
+        // Should not throw (error is handled internally)
+        await expect(messageHandler!(callbackMessage)).rejects.toThrow('Callback failed');
+
+        addEventListenerSpy.mockRestore();
+      });
+    });
   });
 
   describe('provider selection', () => {
@@ -121,13 +538,12 @@ describe('connectWallet', () => {
       await connectWallet({ getUser, chains: [zkEvmChain] });
 
       expect(ZkEvmProvider).toHaveBeenCalled();
-      expect(SequenceProvider).not.toHaveBeenCalled();
     });
 
     it('uses ZkEvmProvider for zkEVM devnet chain', async () => {
       const getUser = createGetUserMock();
       const devChain = {
-        chainId: 15003, // zkEVM devnet chainId
+        chainId: 99999, // unknown chainId
         rpcUrl: 'https://rpc.dev.immutable.com',
         relayerUrl: 'https://relayer.dev.immutable.com',
         apiUrl: 'https://api.dev.immutable.com',
@@ -139,16 +555,6 @@ describe('connectWallet', () => {
       await connectWallet({ getUser, chains: [devChain] });
 
       expect(ZkEvmProvider).toHaveBeenCalled();
-      expect(SequenceProvider).not.toHaveBeenCalled();
-    });
-
-    it('uses SequenceProvider for non-zkEVM chain (Arbitrum)', async () => {
-      const getUser = createGetUserMock();
-
-      await connectWallet({ getUser, chains: [arbitrumChain] });
-
-      expect(SequenceProvider).toHaveBeenCalled();
-      expect(ZkEvmProvider).not.toHaveBeenCalled();
     });
   });
 });