@mictonode/widget 0.3.22 → 0.3.23

package/test/wallet/reown/EvmNetworkProvisioner.test.ts

@@ -0,0 +1,264 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { Eip1193Provider } from '../../../lib/wallet/providers/Eip1193Provider';
+import type { ReownNetwork } from '../../../lib/wallet/reown/ReownConfig';
+import { ensureEvmNetwork } from '../../../lib/wallet/reown/EvmNetworkProvisioner';
+
+const network: ReownNetwork = {
+  id: 8765,
+  caipNetworkId: 'eip155:8765',
+  name: 'Warden Mainnet',
+  rpcUrl: 'https://evm.wardenprotocol.org/',
+  nativeCurrency: { name: 'WARD', symbol: 'WARD', decimals: 18 },
+  explorerUrl: 'https://explorer.wardenprotocol.org/',
+};
+
+function providerWith(
+  request: Eip1193Provider['request'],
+): Eip1193Provider {
+  return { request };
+}
+
+describe('ensureEvmNetwork', () => {
+  it('does not add or switch an already active configured network', async () => {
+    const request = vi.fn(async ({ method }) => {
+      if (method === 'eth_chainId') return '0x223d';
+      throw new Error(`Unexpected method: ${method}`);
+    });
+
+    await ensureEvmNetwork(providerWith(request), network);
+
+    expect(request).toHaveBeenCalledOnce();
+    expect(request).toHaveBeenCalledWith({ method: 'eth_chainId' });
+  });
+
+  it('switches a known network and verifies the resulting chain', async () => {
+    let chainRead = 0;
+    const request = vi.fn(async ({ method }) => {
+      if (method === 'eth_chainId') {
+        chainRead += 1;
+        return chainRead === 1 ? '0x1' : '0x223d';
+      }
+      if (method === 'wallet_switchEthereumChain') return null;
+      throw new Error(`Unexpected method: ${method}`);
+    });
+
+    await ensureEvmNetwork(providerWith(request), network);
+
+    expect(request.mock.calls).toEqual([
+      [{ method: 'eth_chainId' }],
+      [{
+        method: 'wallet_switchEthereumChain',
+        params: [{ chainId: '0x223d' }],
+      }],
+      [{ method: 'eth_chainId' }],
+    ]);
+  });
+
+  it('adds an unknown network once before switching and verifying it', async () => {
+    let chainRead = 0;
+    let switchAttempt = 0;
+    const request = vi.fn(async ({ method }) => {
+      if (method === 'eth_chainId') {
+        chainRead += 1;
+        return chainRead === 1 ? '0x1' : '0x223d';
+      }
+      if (method === 'wallet_switchEthereumChain') {
+        switchAttempt += 1;
+        if (switchAttempt === 1) throw { code: 4902 };
+        return null;
+      }
+      if (method === 'wallet_addEthereumChain') return null;
+      throw new Error(`Unexpected method: ${method}`);
+    });
+
+    await ensureEvmNetwork(providerWith(request), network);
+
+    expect(request.mock.calls).toEqual([
+      [{ method: 'eth_chainId' }],
+      [{
+        method: 'wallet_switchEthereumChain',
+        params: [{ chainId: '0x223d' }],
+      }],
+      [{
+        method: 'wallet_addEthereumChain',
+        params: [{
+          chainId: '0x223d',
+          chainName: 'Warden Mainnet',
+          nativeCurrency: {
+            name: 'WARD',
+            symbol: 'WARD',
+            decimals: 18,
+          },
+          rpcUrls: ['https://evm.wardenprotocol.org/'],
+          blockExplorerUrls: [
+            'https://explorer.wardenprotocol.org/',
+          ],
+        }],
+      }],
+      [{
+        method: 'wallet_switchEthereumChain',
+        params: [{ chainId: '0x223d' }],
+      }],
+      [{ method: 'eth_chainId' }],
+    ]);
+  });
+
+  it.each([
+    { code: '4902' },
+    { data: { originalError: { code: 4902 } } },
+    { error: { data: { code: '4902' } } },
+  ])(
+    'adds an unknown network when a provider wraps the 4902 error as %j',
+    async (unknownChainError) => {
+      let chainRead = 0;
+      let switchAttempt = 0;
+      const request = vi.fn(async ({ method }) => {
+        if (method === 'eth_chainId') {
+          chainRead += 1;
+          return chainRead === 1 ? '0x1' : '0x223d';
+        }
+        if (method === 'wallet_switchEthereumChain') {
+          switchAttempt += 1;
+          if (switchAttempt === 1) throw unknownChainError;
+          return null;
+        }
+        if (method === 'wallet_addEthereumChain') return null;
+        throw new Error(`Unexpected method: ${method}`);
+      });
+
+      await ensureEvmNetwork(providerWith(request), network);
+
+      expect(request).toHaveBeenCalledWith({
+        method: 'wallet_addEthereumChain',
+        params: [expect.objectContaining({ chainId: '0x223d' })],
+      });
+    },
+  );
+
+  it('does not retry a rejected switch request', async () => {
+    const rejection = { code: 4001 };
+    const request = vi.fn(async ({ method }) => {
+      if (method === 'eth_chainId') return '0x1';
+      if (method === 'wallet_switchEthereumChain') throw rejection;
+      throw new Error(`Unexpected method: ${method}`);
+    });
+
+    await expect(
+      ensureEvmNetwork(providerWith(request), network),
+    ).rejects.toBe(rejection);
+
+    expect(request).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not add a network when an outer rejection wraps a 4902 error', async () => {
+    const rejection = {
+      code: 4001,
+      data: { originalError: { code: 4902 } },
+    };
+    const request = vi.fn(async ({ method }) => {
+      if (method === 'eth_chainId') return '0x1';
+      if (method === 'wallet_switchEthereumChain') throw rejection;
+      throw new Error(`Unexpected method: ${method}`);
+    });
+
+    await expect(
+      ensureEvmNetwork(providerWith(request), network),
+    ).rejects.toBe(rejection);
+
+    expect(request).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not retry a rejected add-network request', async () => {
+    const rejection = { code: 4001 };
+    const request = vi.fn(async ({ method }) => {
+      if (method === 'eth_chainId') return '0x1';
+      if (method === 'wallet_switchEthereumChain') throw { code: 4902 };
+      if (method === 'wallet_addEthereumChain') throw rejection;
+      throw new Error(`Unexpected method: ${method}`);
+    });
+
+    await expect(
+      ensureEvmNetwork(providerWith(request), network),
+    ).rejects.toBe(rejection);
+
+    expect(request).toHaveBeenCalledTimes(3);
+  });
+
+  it('rejects when the provider resolves without changing chains', async () => {
+    const request = vi.fn(async ({ method }) => {
+      if (method === 'eth_chainId') return '0x1';
+      if (method === 'wallet_switchEthereumChain') return null;
+      throw new Error(`Unexpected method: ${method}`);
+    });
+
+    await expect(
+      ensureEvmNetwork(providerWith(request), network),
+    ).rejects.toThrow('EVM wallet did not switch to configured network');
+  });
+
+  it('does not add a network after the owning attempt becomes stale', async () => {
+    let active = true;
+    const request = vi.fn(async ({ method }) => {
+      if (method === 'eth_chainId') return '0x1';
+      if (method === 'wallet_switchEthereumChain') {
+        active = false;
+        throw { code: 4902 };
+      }
+      throw new Error(`Unexpected method: ${method}`);
+    });
+
+    await expect(
+      ensureEvmNetwork(providerWith(request), network, () => active),
+    ).rejects.toThrow('EVM network request is no longer active');
+
+    expect(request.mock.calls).toEqual([
+      [{ method: 'eth_chainId' }],
+      [{
+        method: 'wallet_switchEthereumChain',
+        params: [{ chainId: '0x223d' }],
+      }],
+    ]);
+  });
+
+  it('does not switch again after an add request loses ownership', async () => {
+    let active = true;
+    let switchAttempt = 0;
+    const request = vi.fn(async ({ method }) => {
+      if (method === 'eth_chainId') return '0x1';
+      if (method === 'wallet_switchEthereumChain') {
+        switchAttempt += 1;
+        if (switchAttempt === 1) throw { code: 4902 };
+        return null;
+      }
+      if (method === 'wallet_addEthereumChain') {
+        active = false;
+        return null;
+      }
+      throw new Error(`Unexpected method: ${method}`);
+    });
+
+    await expect(
+      ensureEvmNetwork(providerWith(request), network, () => active),
+    ).rejects.toThrow('EVM network request is no longer active');
+
+    expect(request).toHaveBeenCalledTimes(3);
+  });
+
+  it('does not verify a switch after the owning attempt becomes stale', async () => {
+    let active = true;
+    const request = vi.fn(async ({ method }) => {
+      if (method === 'eth_chainId') return '0x1';
+      if (method === 'wallet_switchEthereumChain') {
+        active = false;
+        return null;
+      }
+      throw new Error(`Unexpected method: ${method}`);
+    });
+
+    await expect(
+      ensureEvmNetwork(providerWith(request), network, () => active),
+    ).rejects.toThrow('EVM network request is no longer active');
+
+    expect(request).toHaveBeenCalledTimes(2);
+  });
+});

package/test/wallet/reown/ReownGateway.test.ts

@@ -1,7 +1,12 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-const { appKit, createAppKit } = vi.hoisted(() => {
+const { appKit, createAppKit, ethereumMainnet, provider } = vi.hoisted(() => {
   const provider = { request: vi.fn() };
+  const ethereumMainnet = {
+    id: 1,
+    caipNetworkId: 'eip155:1',
+    name: 'Ethereum',
+  };
   const appKit = {
     ready: vi.fn(async () => undefined),
     open: vi.fn(async () => undefined),
@@ -15,6 +20,9 @@ const { appKit, createAppKit } = vi.hoisted(() => {
       caipAddress:
         'eip155:9191:0x1111111111111111111111111111111111111111',
     })),
+    getCaipNetwork: vi.fn(() => ({
+      caipNetworkId: 'eip155:9191',
+    })),
     getWalletInfo: vi.fn(() => ({
       name: 'Rabby Wallet',
       type: 'injected',
@@ -26,6 +34,8 @@ const { appKit, createAppKit } = vi.hoisted(() => {
   return {
     appKit,
     createAppKit: vi.fn(() => appKit),
+    ethereumMainnet,
+    provider,
   };
 });
 
@@ -35,6 +45,7 @@ vi.mock('@reown/appkit-adapter-ethers', () => ({
 }));
 vi.mock('@reown/appkit/networks', () => ({
   defineChain: vi.fn((network) => network),
+  mainnet: ethereumMainnet,
 }));
 
 import {
@@ -65,6 +76,7 @@ describe('ReownGateway', () => {
   beforeEach(() => {
     resetReownGatewayForTests();
     vi.clearAllMocks();
+    provider.request.mockResolvedValue('0x23e7');
   });
 
   it('initializes once and exposes the eip155 provider', async () => {
@@ -82,6 +94,59 @@ describe('ReownGateway', () => {
       namespace: 'eip155',
     });
     expect(first.getProvider()).toBe(appKit.getProvider('eip155'));
+    expect(first.getNetwork()).toEqual({
+      caipNetworkId: 'eip155:9191',
+    });
+    expect(appKit.getCaipNetwork).toHaveBeenCalledWith('eip155');
+    expect(createAppKit).toHaveBeenCalledWith(
+      expect.objectContaining({ allowUnsupportedChain: true }),
+    );
+  });
+
+  it('connects through Ethereum before provisioning the configured network', async () => {
+    await getReownGateway(config);
+
+    expect(createAppKit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        networks: [
+          expect.objectContaining({
+            id: config.network.id,
+            caipNetworkId: config.network.caipNetworkId,
+          }),
+          ethereumMainnet,
+        ],
+        defaultNetwork: ethereumMainnet,
+        enableNetworkSwitch: false,
+      }),
+    );
+  });
+
+  it('ensures the configured network through the active provider', async () => {
+    provider.request
+      .mockResolvedValueOnce('0x1')
+      .mockResolvedValueOnce(null)
+      .mockResolvedValueOnce('0x23e7');
+    const gateway = await getReownGateway(config);
+
+    await gateway.ensureNetwork();
+
+    expect(provider.request.mock.calls).toEqual([
+      [{ method: 'eth_chainId' }],
+      [{
+        method: 'wallet_switchEthereumChain',
+        params: [{ chainId: '0x23e7' }],
+      }],
+      [{ method: 'eth_chainId' }],
+    ]);
+  });
+
+  it('rejects network provisioning when no provider is active', async () => {
+    appKit.getProvider.mockImplementationOnce(() => undefined as never);
+    const gateway = await getReownGateway(config);
+
+    await expect(gateway.ensureNetwork()).rejects.toThrow(
+      'EVM wallet provider is unavailable',
+    );
   });
 
   it('creates a different gateway for a different network config', async () => {

package/dist/features-a2f2ff4f.js

@@ -1,8 +0,0 @@
-import { R as r, a } from "./ReownAuthentication-7c5b6e79.js";
-import "./ConstantsUtil-df193f67.js";
-import "./main-7ddb238e.js";
-import "./abis-61cccfbf.js";
-export {
-  r as ReownAuthentication,
-  a as ReownAuthenticationMessenger
-};