@reown/appkit 1.5.3-k2f8w6.0 → 1.5.3

package/dist/types/exports/constants.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "1.5.3-k2f8w6.0";
+export declare const PACKAGE_VERSION = "1.5.3";

package/dist/types/src/adapters/ChainAdapterBlueprint.d.ts

@@ -5,7 +5,7 @@ import type UniversalProvider from '@walletconnect/universal-provider';
 import type { W3mFrameProvider } from '@reown/appkit-wallet';
 import type { AppKitOptions } from '../utils/index.js';
 import type { AppKit } from '../client.js';
-type EventName = 'disconnect' | 'accountChanged' | 'switchNetwork' | 'statusChanged';
+type EventName = 'disconnect' | 'accountChanged' | 'switchNetwork';
 type EventData = {
     disconnect: () => void;
     accountChanged: {
@@ -16,7 +16,6 @@ type EventData = {
         address?: string;
         chainId: number | string;
     };
-    statusChanged: AccountControllerState['status'];
 };
 type EventCallback<T extends EventName> = (data: EventData[T]) => void;
 /**

package/dist/types/src/client.d.ts

@@ -86,7 +86,7 @@ export declare class AppKit {
     getCaipAddress: (chainNamespace?: ChainNamespace) => `eip155:${string}:${string}` | `eip155:${number}:${string}` | `solana:${string}:${string}` | `solana:${number}:${string}` | `polkadot:${string}:${string}` | `polkadot:${number}:${string}` | `bip122:${string}:${string}` | `bip122:${number}:${string}` | undefined;
     getAddressByChainNamespace: (chainNamespace: ChainNamespace) => string | undefined;
     getAddress: (chainNamespace?: ChainNamespace) => string | undefined;
-    getProvider: () => UniversalProvider | Provider | import("@reown/appkit-core").CombinedProvider | undefined;
+    getProvider: () => Provider | UniversalProvider | import("@reown/appkit-core").CombinedProvider | undefined;
     getPreferredAccountType: () => W3mFrameTypes.AccountType;
     setCaipAddress: (typeof AccountController)['setCaipAddress'];
     setProvider: (typeof AccountController)['setProvider'];
@@ -121,6 +121,7 @@ export declare class AppKit {
     disconnect(): Promise<void>;
     private initControllers;
     private getDefaultMetaData;
+    private setUnsupportedNetwork;
     private extendCaipNetworks;
     private extendDefaultCaipNetwork;
     private createClients;

package/dist/types/src/networks/bitcoin.d.ts

@@ -45,3 +45,50 @@ export declare const bitcoin: {
         imageUrl: string | undefined;
     } | undefined;
 };
+export declare const bitcoinTestnet: {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        universalSignatureVerifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    name: "Bitcoin Testnet";
+    nativeCurrency: {
+        readonly name: "Bitcoin";
+        readonly symbol: "BTC";
+        readonly decimals: 8;
+    };
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.walletconnect.org/v1"];
+        };
+    };
+    sourceId?: number | undefined;
+    testnet?: boolean | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    id: "000000000933ea01ad0ee984209779ba";
+    chainNamespace: "bip122";
+    caipNetworkId: "bip122:000000000933ea01ad0ee984209779ba";
+    assets?: {
+        imageId: string | undefined;
+        imageUrl: string | undefined;
+    } | undefined;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reown/appkit",
-  "version": "1.5.3-k2f8w6.0",
+  "version": "1.5.3",
   "type": "module",
   "main": "./dist/esm/exports/index.js",
   "types": "./dist/types/exports/index.d.ts",
@@ -95,14 +95,14 @@
     "bs58": "6.0.0",
     "valtio": "1.11.2",
     "viem": "2.x",
-    "@reown/appkit-common": "1.5.3-k2f8w6.0",
-    "@reown/appkit-core": "1.5.3-k2f8w6.0",
-    "@reown/appkit-polyfills": "1.5.3-k2f8w6.0",
-    "@reown/appkit-scaffold-ui": "1.5.3-k2f8w6.0",
-    "@reown/appkit-siwe": "1.5.3-k2f8w6.0",
-    "@reown/appkit-ui": "1.5.3-ae9267.0",
-    "@reown/appkit-utils": "1.5.3-k2f8w6.0",
-    "@reown/appkit-wallet": "1.5.3-k2f8w6.0"
+    "@reown/appkit-common": "1.5.3",
+    "@reown/appkit-core": "1.5.3",
+    "@reown/appkit-polyfills": "1.5.3",
+    "@reown/appkit-scaffold-ui": "1.5.3",
+    "@reown/appkit-siwe": "1.5.3",
+    "@reown/appkit-ui": "1.5.3",
+    "@reown/appkit-utils": "1.5.3",
+    "@reown/appkit-wallet": "1.5.3"
   },
   "devDependencies": {
     "@types/react": "18.3.1",

package/dist/esm/src/tests/appkit.test.js

@@ -1,533 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { AppKit } from '../client';
-import { mainnet, polygon } from '../networks/index.js';
-import { AccountController, ModalController, ThemeController, PublicStateController, SnackController, RouterController, OptionsController, BlockchainApiController, ConnectionController, EnsController, EventsController, AssetUtil, ConnectorController, ChainController, StorageUtil } from '@reown/appkit-core';
-import { SafeLocalStorage, SafeLocalStorageKeys } from '@reown/appkit-common';
-import { mockOptions } from './mocks/Options';
-import { UniversalAdapter } from '../universal-adapter/client';
-// Mock all controllers and UniversalAdapterClient
-vi.mock('@reown/appkit-core');
-vi.mock('../universal-adapter/client');
-describe('Base', () => {
-    let appKit;
-    beforeEach(() => {
-        vi.resetAllMocks();
-        vi.mocked(ChainController).state = {
-            chains: new Map(),
-            activeChain: 'eip155'
-        };
-        vi.mocked(ConnectorController).getConnectors = vi.fn().mockReturnValue([]);
-        appKit = new AppKit(mockOptions);
-    });
-    describe('Base Initialization', () => {
-        it('should initialize controllers with required provided options', () => {
-            expect(OptionsController.setSdkVersion).toHaveBeenCalledWith(mockOptions.sdkVersion);
-            expect(OptionsController.setProjectId).toHaveBeenCalledWith(mockOptions.projectId);
-            expect(OptionsController.setMetadata).toHaveBeenCalledWith(mockOptions.metadata);
-        });
-        it('should initialize adapters in ChainController', () => {
-            expect(ChainController.initialize).toHaveBeenCalledWith(mockOptions.adapters);
-        });
-    });
-    describe('Base Public methods', () => {
-        it('should open modal', async () => {
-            await appKit.open();
-            expect(ModalController.open).toHaveBeenCalled();
-        });
-        it('should close modal', async () => {
-            await appKit.close();
-            expect(ModalController.close).toHaveBeenCalled();
-        });
-        it('should set loading state', () => {
-            appKit.setLoading(true);
-            expect(ModalController.setLoading).toHaveBeenCalledWith(true);
-        });
-        it('should get theme mode', () => {
-            vi.mocked(ThemeController).state = { themeMode: 'dark' };
-            expect(appKit.getThemeMode()).toBe('dark');
-        });
-        it('should set theme mode', () => {
-            appKit.setThemeMode('light');
-            expect(ThemeController.setThemeMode).toHaveBeenCalledWith('light');
-        });
-        it('should get theme variables', () => {
-            vi.mocked(ThemeController).state = {
-                themeVariables: { '--w3m-accent': '#000' }
-            };
-            expect(appKit.getThemeVariables()).toEqual({ '--w3m-accent': '#000' });
-        });
-        it('should set theme variables', () => {
-            const themeVariables = { '--w3m-accent': '#fff' };
-            appKit.setThemeVariables(themeVariables);
-            expect(ThemeController.setThemeVariables).toHaveBeenCalledWith(themeVariables);
-        });
-        it('should subscribe to theme changes', () => {
-            const callback = vi.fn();
-            appKit.subscribeTheme(callback);
-            expect(ThemeController.subscribe).toHaveBeenCalledWith(callback);
-        });
-        it('should get wallet info', () => {
-            vi.mocked(AccountController).state = { connectedWalletInfo: { name: 'Test Wallet' } };
-            expect(appKit.getWalletInfo()).toEqual({ name: 'Test Wallet' });
-        });
-        it('should subscribe to wallet info changes', () => {
-            const callback = vi.fn();
-            appKit.subscribeWalletInfo(callback);
-            expect(AccountController.subscribeKey).toHaveBeenCalledWith('connectedWalletInfo', callback);
-        });
-        it('should subscribe to address updates', () => {
-            const callback = vi.fn();
-            appKit.subscribeShouldUpdateToAddress(callback);
-            expect(AccountController.subscribeKey).toHaveBeenCalledWith('shouldUpdateToAddress', callback);
-        });
-        it('should subscribe to CAIP network changes', () => {
-            const callback = vi.fn();
-            appKit.subscribeCaipNetworkChange(callback);
-            expect(ChainController.subscribeKey).toHaveBeenCalledWith('activeCaipNetwork', callback);
-        });
-        it('should get state', () => {
-            vi.mocked(PublicStateController).state = { isConnected: true };
-            expect(appKit.getState()).toEqual({ isConnected: true });
-        });
-        it('should subscribe to state changes', () => {
-            const callback = vi.fn();
-            appKit.subscribeState(callback);
-            expect(PublicStateController.subscribe).toHaveBeenCalledWith(callback);
-        });
-        it('should show error message', () => {
-            appKit.showErrorMessage('Test error');
-            expect(SnackController.showError).toHaveBeenCalledWith('Test error');
-        });
-        it('should show success message', () => {
-            appKit.showSuccessMessage('Test success');
-            expect(SnackController.showSuccess).toHaveBeenCalledWith('Test success');
-        });
-        it('should get event', () => {
-            vi.mocked(EventsController).state = { name: 'test_event' };
-            expect(appKit.getEvent()).toEqual({ name: 'test_event' });
-        });
-        it('should subscribe to events', () => {
-            const callback = vi.fn();
-            appKit.subscribeEvents(callback);
-            expect(EventsController.subscribe).toHaveBeenCalledWith(callback);
-        });
-        it('should replace route', () => {
-            appKit.replace('Connect');
-            expect(RouterController.replace).toHaveBeenCalledWith('Connect');
-        });
-        it('should redirect to route', () => {
-            appKit.redirect('Networks');
-            expect(RouterController.push).toHaveBeenCalledWith('Networks');
-        });
-        it('should pop transaction stack', () => {
-            appKit.popTransactionStack(true);
-            expect(RouterController.popTransactionStack).toHaveBeenCalledWith(true);
-        });
-        it('should check if modal is open', () => {
-            vi.mocked(ModalController).state = { open: true };
-            expect(appKit.isOpen()).toBe(true);
-        });
-        it('should check if transaction stack is empty', () => {
-            vi.mocked(RouterController).state = { transactionStack: [] };
-            expect(appKit.isTransactionStackEmpty()).toBe(true);
-        });
-        it('should check if transaction should replace view', () => {
-            vi.mocked(RouterController).state = { transactionStack: [{ replace: true }] };
-            expect(appKit.isTransactionShouldReplaceView()).toBe(true);
-        });
-        it('should set status', () => {
-            appKit.setStatus('connected', 'eip155');
-            expect(AccountController.setStatus).toHaveBeenCalledWith('connected', 'eip155');
-        });
-        it('should set all accounts', () => {
-            const addresses = ['0x123', '0x456'];
-            appKit.setAllAccounts(addresses, 'eip155');
-            expect(AccountController.setAllAccounts).toHaveBeenCalledWith(addresses, 'eip155');
-            expect(OptionsController.setHasMultipleAddresses).toHaveBeenCalledWith(true);
-        });
-        it('should add address label', () => {
-            appKit.addAddressLabel('0x123', 'eip155 Address', 'eip155');
-            expect(AccountController.addAddressLabel).toHaveBeenCalledWith('0x123', 'eip155 Address', 'eip155');
-        });
-        it('should remove address label', () => {
-            appKit.removeAddressLabel('0x123', 'eip155');
-            expect(AccountController.removeAddressLabel).toHaveBeenCalledWith('0x123', 'eip155');
-        });
-        it('should get CAIP address', () => {
-            vi.mocked(ChainController).state = {
-                activeChain: 'eip155',
-                activeCaipAddress: 'eip155:1:0x123'
-            };
-            expect(appKit.getCaipAddress()).toBe('eip155:1:0x123');
-        });
-        it('should get address', () => {
-            vi.mocked(AccountController).state = { address: '0x123' };
-            expect(appKit.getAddress()).toBe('0x123');
-        });
-        it('should get provider', () => {
-            const mockProvider = { request: vi.fn() };
-            vi.mocked(AccountController).state = { provider: mockProvider };
-            expect(appKit.getProvider()).toBe(mockProvider);
-        });
-        it('should get preferred account type', () => {
-            vi.mocked(AccountController).state = { preferredAccountType: 'eoa' };
-            expect(appKit.getPreferredAccountType()).toBe('eoa');
-        });
-        it('should set CAIP address', () => {
-            // First mock AccountController.setCaipAddress to update ChainController state
-            vi.mocked(AccountController.setCaipAddress).mockImplementation(() => {
-                vi.mocked(ChainController).state = {
-                    ...vi.mocked(ChainController).state,
-                    activeCaipAddress: 'eip155:1:0x123'
-                };
-            });
-            appKit.setCaipAddress('eip155:1:0x123', 'eip155');
-            expect(AccountController.setCaipAddress).toHaveBeenCalledWith('eip155:1:0x123', 'eip155');
-            expect(appKit.getIsConnectedState()).toBe(true);
-        });
-        it('should set provider', () => {
-            const mockProvider = {
-                request: vi.fn()
-            };
-            appKit.setProvider(mockProvider, 'eip155');
-            expect(AccountController.setProvider).toHaveBeenCalledWith(mockProvider, 'eip155');
-        });
-        it('should set balance', () => {
-            appKit.setBalance('1.5', 'ETH', 'eip155');
-            expect(AccountController.setBalance).toHaveBeenCalledWith('1.5', 'ETH', 'eip155');
-        });
-        it('should set profile name', () => {
-            appKit.setProfileName('John Doe', 'eip155');
-            expect(AccountController.setProfileName).toHaveBeenCalledWith('John Doe', 'eip155');
-        });
-        it('should set profile image', () => {
-            appKit.setProfileImage('https://example.com/image.png', 'eip155');
-            expect(AccountController.setProfileImage).toHaveBeenCalledWith('https://example.com/image.png', 'eip155');
-        });
-        it('should reset account', () => {
-            appKit.resetAccount('eip155');
-            expect(AccountController.resetAccount).toHaveBeenCalledWith('eip155');
-        });
-        it('should set CAIP network', () => {
-            const caipNetwork = { id: 'eip155:1', name: 'Ethereum' };
-            appKit.setCaipNetwork(caipNetwork);
-            expect(ChainController.setActiveCaipNetwork).toHaveBeenCalledWith(caipNetwork);
-        });
-        it('should get CAIP network', () => {
-            vi.mocked(ChainController).state = {
-                activeCaipNetwork: { id: 'eip155:1', name: 'Ethereum' }
-            };
-            expect(appKit.getCaipNetwork()).toEqual({ id: 'eip155:1', name: 'Ethereum' });
-        });
-        it('should set requested CAIP networks', () => {
-            const requestedNetworks = [{ id: 'eip155:1', name: 'Ethereum' }];
-            appKit.setRequestedCaipNetworks(requestedNetworks, 'eip155');
-            expect(ChainController.setRequestedCaipNetworks).toHaveBeenCalledWith(requestedNetworks, 'eip155');
-        });
-        it('should set connectors', () => {
-            const existingConnectors = [
-                { id: 'phantom', name: 'Phantom', chain: 'eip155', type: 'INJECTED' }
-            ];
-            // Mock getConnectors to return existing connectors
-            vi.mocked(ConnectorController.getConnectors).mockReturnValue(existingConnectors);
-            const newConnectors = [
-                { id: 'metamask', name: 'MetaMask', chain: 'eip155', type: 'INJECTED' }
-            ];
-            appKit.setConnectors(newConnectors);
-            // Verify that setConnectors was called with combined array
-            expect(ConnectorController.setConnectors).toHaveBeenCalledWith([
-                ...existingConnectors,
-                ...newConnectors
-            ]);
-        });
-        it('should add connector', () => {
-            const connector = {
-                id: 'metamask',
-                name: 'MetaMask',
-                chain: 'eip155',
-                type: 'INJECTED'
-            };
-            appKit.addConnector(connector);
-            expect(ConnectorController.addConnector).toHaveBeenCalledWith(connector);
-        });
-        it('should get connectors', () => {
-            const mockConnectors = [
-                { id: 'metamask', name: 'MetaMask', chain: 'eip155:1', type: 'INJECTED' }
-            ];
-            vi.mocked(ConnectorController.getConnectors).mockReturnValue(mockConnectors);
-            expect(appKit.getConnectors()).toEqual(mockConnectors);
-        });
-        it('should get approved CAIP network IDs', () => {
-            vi.mocked(ChainController.getAllApprovedCaipNetworkIds).mockReturnValue(['eip155:1']);
-            expect(appKit.getApprovedCaipNetworkIds()).toEqual(['eip155:1']);
-        });
-        it('should set approved CAIP networks data', () => {
-            appKit.setApprovedCaipNetworksData('eip155');
-            expect(ChainController.setApprovedCaipNetworksData).toHaveBeenCalledWith('eip155');
-        });
-        it('should reset network', () => {
-            appKit.resetNetwork('eip155');
-            expect(ChainController.resetNetwork).toHaveBeenCalled();
-        });
-        it('should reset WC connection', () => {
-            appKit.resetWcConnection();
-            expect(ConnectionController.resetWcConnection).toHaveBeenCalled();
-        });
-        it('should fetch identity', async () => {
-            const mockRequest = { caipChainId: 'eip155:1', address: '0x123' };
-            vi.mocked(BlockchainApiController.fetchIdentity).mockResolvedValue({
-                name: 'John Doe',
-                avatar: null
-            });
-            const result = await appKit.fetchIdentity(mockRequest);
-            expect(BlockchainApiController.fetchIdentity).toHaveBeenCalledWith(mockRequest);
-            expect(result).toEqual({ name: 'John Doe', avatar: null });
-        });
-        it('should set address explorer URL', () => {
-            appKit.setAddressExplorerUrl('https://etherscan.io/address/0x123', 'eip155');
-            expect(AccountController.setAddressExplorerUrl).toHaveBeenCalledWith('https://etherscan.io/address/0x123', 'eip155');
-        });
-        it('should set smart account deployed', () => {
-            appKit.setSmartAccountDeployed(true, 'eip155');
-            expect(AccountController.setSmartAccountDeployed).toHaveBeenCalledWith(true, 'eip155');
-        });
-        it('should set connected wallet info', () => {
-            const walletInfo = { name: 'MetaMask', icon: 'icon-url' };
-            appKit.setConnectedWalletInfo(walletInfo, 'eip155');
-            expect(AccountController.setConnectedWalletInfo).toHaveBeenCalledWith(walletInfo, 'eip155');
-        });
-        it('should set smart account enabled networks', () => {
-            const networks = [1, 137];
-            appKit.setSmartAccountEnabledNetworks(networks, 'eip155');
-            expect(ChainController.setSmartAccountEnabledNetworks).toHaveBeenCalledWith(networks, 'eip155');
-        });
-        it('should set preferred account type', () => {
-            appKit.setPreferredAccountType('eoa', 'eip155');
-            expect(AccountController.setPreferredAccountType).toHaveBeenCalledWith('eoa', 'eip155');
-        });
-        it('should get Reown name', async () => {
-            vi.mocked(EnsController.getNamesForAddress).mockResolvedValue([
-                {
-                    name: 'john.reown.id',
-                    addresses: { eip155: { address: '0x123', created: '0' } },
-                    attributes: [],
-                    registered: 0,
-                    updated: 0
-                }
-            ]);
-            const result = await appKit.getReownName('john.reown.id');
-            expect(EnsController.getNamesForAddress).toHaveBeenCalledWith('john.reown.id');
-            expect(result).toEqual([
-                {
-                    name: 'john.reown.id',
-                    addresses: { eip155: { address: '0x123', created: '0' } },
-                    attributes: [],
-                    registered: 0,
-                    updated: 0
-                }
-            ]);
-        });
-        it('should set EIP6963 enabled', () => {
-            appKit.setEIP6963Enabled(true);
-            expect(OptionsController.setEIP6963Enabled).toHaveBeenCalledWith(true);
-        });
-        it('should set client ID', () => {
-            appKit.setClientId('client-123');
-            expect(BlockchainApiController.setClientId).toHaveBeenCalledWith('client-123');
-        });
-        it('should get connector image', () => {
-            vi.mocked(AssetUtil.getConnectorImage).mockReturnValue('connector-image-url');
-            const result = appKit.getConnectorImage({ id: 'metamask', type: 'INJECTED', chain: 'eip155' });
-            expect(AssetUtil.getConnectorImage).toHaveBeenCalledWith({
-                id: 'metamask',
-                type: 'INJECTED',
-                chain: 'eip155'
-            });
-            expect(result).toBe('connector-image-url');
-        });
-        it('should switch network when requested', async () => {
-            vi.mocked(ChainController.switchActiveNetwork).mockResolvedValue(undefined);
-            await appKit.switchNetwork(mainnet);
-            expect(ChainController.switchActiveNetwork).toHaveBeenCalledWith(expect.objectContaining({
-                id: mainnet.id,
-                name: mainnet.name
-            }));
-            await appKit.switchNetwork(polygon);
-            expect(ChainController.switchActiveNetwork).toHaveBeenCalledTimes(1);
-        });
-        it('should set connected wallet info when syncing account', async () => {
-            // Mock the connector data
-            const mockConnector = {
-                id: 'test-wallet'
-            };
-            vi.mocked(ConnectorController.getConnectors).mockReturnValue([mockConnector]);
-            const mockAccountData = {
-                address: '0x123',
-                chainId: '1',
-                chainNamespace: 'eip155'
-            };
-            vi.spyOn(SafeLocalStorage, 'getItem').mockImplementation((key) => {
-                if (key === SafeLocalStorageKeys.CONNECTED_CONNECTOR) {
-                    return mockConnector.id;
-                }
-                return undefined;
-            });
-            await appKit['syncAccount'](mockAccountData);
-            expect(AccountController.setConnectedWalletInfo).toHaveBeenCalledWith(expect.objectContaining({
-                name: mockConnector.id
-            }), 'eip155');
-        });
-        it('should disconnect correctly', async () => {
-            vi.mocked(ChainController).state = {
-                chains: new Map([['eip155', { namespace: 'eip155' }]]),
-                activeChain: 'eip155'
-            };
-            const mockRemoveItem = vi.fn();
-            vi.spyOn(SafeLocalStorage, 'removeItem').mockImplementation(mockRemoveItem);
-            await appKit.disconnect();
-            expect(mockRemoveItem).toHaveBeenCalledWith(SafeLocalStorageKeys.CONNECTED_CONNECTOR);
-            expect(mockRemoveItem).toHaveBeenCalledWith(SafeLocalStorageKeys.ACTIVE_CAIP_NETWORK_ID);
-            expect(AccountController.resetAccount).toHaveBeenCalledWith('eip155');
-            expect(AccountController.setStatus).toHaveBeenCalledWith('disconnected', 'eip155');
-        });
-        it('should show unsupported chain UI when synced chainId is not supported', async () => {
-            vi.mocked(ChainController).state = {
-                chains: new Map([['eip155', { namespace: 'eip155' }]]),
-                activeChain: 'eip155'
-            };
-            appKit.caipNetworks = [{ id: 'eip155:1', chainNamespace: 'eip155' }];
-            const mockAdapter = {
-                syncConnection: vi.fn().mockResolvedValue({
-                    chainId: 'eip155:999', // Unsupported chain
-                    address: '0x123'
-                }),
-                getBalance: vi.fn().mockResolvedValue({ balance: '0', symbol: 'ETH' }),
-                getProfile: vi.fn().mockResolvedValue({}),
-                on: vi.fn(),
-                off: vi.fn(),
-                emit: vi.fn()
-            };
-            vi.spyOn(appKit, 'getAdapter').mockReturnValue(mockAdapter);
-            vi.spyOn(StorageUtil, 'setConnectedConnector').mockImplementation(vi.fn());
-            vi.spyOn(StorageUtil, 'setConnectedNamespace').mockImplementation(vi.fn());
-            vi.spyOn(SafeLocalStorage, 'getItem').mockImplementation((key) => {
-                if (key === SafeLocalStorageKeys.CONNECTED_CONNECTOR) {
-                    return 'test-wallet';
-                }
-                if (key === SafeLocalStorageKeys.CONNECTED_NAMESPACE) {
-                    return 'eip155';
-                }
-                return undefined;
-            });
-            vi.mocked(ChainController.showUnsupportedChainUI).mockImplementation(vi.fn());
-            await appKit.syncExistingConnection();
-            expect(ChainController.showUnsupportedChainUI).toHaveBeenCalled();
-        });
-    });
-    describe('Base Initialization', () => {
-        let appKit;
-        let mockAdapter;
-        let mockUniversalAdapter;
-        beforeEach(() => {
-            vi.resetAllMocks();
-            vi.mocked(ChainController).state = {
-                chains: new Map(),
-                activeChain: 'eip155'
-            };
-            vi.mocked(ConnectorController).getConnectors = vi.fn().mockReturnValue([]);
-            mockAdapter = {
-                namespace: 'eip155',
-                construct: vi.fn(),
-                setUniversalProvider: vi.fn(),
-                setAuthProvider: vi.fn(),
-                syncConnectors: vi.fn(),
-                connectors: [],
-                on: vi.fn(),
-                off: vi.fn(),
-                emit: vi.fn()
-            };
-            vi.mocked(UniversalAdapter).mockImplementation(() => mockUniversalAdapter);
-            appKit = new AppKit({
-                ...mockOptions,
-                adapters: [mockAdapter]
-            });
-            vi.spyOn(appKit, 'getUniversalProvider').mockResolvedValue({
-                on: vi.fn(),
-                off: vi.fn(),
-                emit: vi.fn()
-            });
-        });
-        it('should call syncConnectors when initializing adapters', async () => {
-            const createAdapters = appKit.createAdapters.bind(appKit);
-            vi.spyOn(appKit, 'createUniversalProvider').mockResolvedValue(undefined);
-            await createAdapters([mockAdapter]);
-            expect(mockAdapter.syncConnectors).toHaveBeenCalledWith(expect.objectContaining({
-                projectId: mockOptions.projectId,
-                metadata: mockOptions.metadata
-            }), expect.any(Object));
-        });
-        it('should create UniversalAdapter when no blueprint is provided for namespace', async () => {
-            const createAdapters = appKit.createAdapters.bind(appKit);
-            vi.spyOn(appKit, 'createUniversalProvider').mockResolvedValue(undefined);
-            const mockUniversalAdapter = {
-                setUniversalProvider: vi.fn(),
-                setAuthProvider: vi.fn()
-            };
-            vi.mocked(UniversalAdapter).mockImplementation(() => mockUniversalAdapter);
-            const adapters = await createAdapters([]);
-            expect(adapters.eip155).toBeDefined();
-            expect(mockUniversalAdapter.setUniversalProvider).toHaveBeenCalled();
-        });
-        it('should initialize multiple adapters for different namespaces', async () => {
-            const createAdapters = appKit.createAdapters.bind(appKit);
-            const mockSolanaAdapter = {
-                namespace: 'solana',
-                construct: vi.fn(),
-                setUniversalProvider: vi.fn(),
-                setAuthProvider: vi.fn(),
-                syncConnectors: vi.fn(),
-                connectors: [],
-                on: vi.fn(),
-                off: vi.fn(),
-                emit: vi.fn()
-            };
-            vi.spyOn(appKit, 'createUniversalProvider').mockResolvedValue(undefined);
-            const adapters = await createAdapters([mockAdapter, mockSolanaAdapter]);
-            expect(mockAdapter.syncConnectors).toHaveBeenCalled();
-            expect(mockSolanaAdapter.syncConnectors).toHaveBeenCalled();
-            expect(adapters.eip155).toBeDefined();
-            expect(adapters.solana).toBeDefined();
-        });
-        it('should set universal provider and auth provider for each adapter', async () => {
-            const createAdapters = appKit.createAdapters.bind(appKit);
-            const mockUniversalProvider = {
-                on: vi.fn(),
-                off: vi.fn(),
-                emit: vi.fn()
-            };
-            vi.spyOn(appKit, 'createUniversalProvider').mockResolvedValue(undefined);
-            vi.spyOn(appKit, 'getUniversalProvider').mockResolvedValue(mockUniversalProvider);
-            await createAdapters([mockAdapter]);
-            expect(mockAdapter.setUniversalProvider).toHaveBeenCalledWith(expect.objectContaining({
-                on: expect.any(Function),
-                off: expect.any(Function),
-                emit: expect.any(Function)
-            }));
-            expect(mockAdapter.setAuthProvider).toHaveBeenCalled();
-        });
-        it('should update ChainController state with initialized adapters', async () => {
-            const createAdapters = appKit.createAdapters.bind(appKit);
-            vi.spyOn(appKit, 'createUniversalProvider').mockResolvedValue(undefined);
-            await createAdapters([mockAdapter]);
-            expect(ChainController.state.chains.get('eip155')).toEqual(expect.objectContaining({
-                namespace: 'eip155',
-                connectionControllerClient: expect.any(Object),
-                networkControllerClient: expect.any(Object),
-                networkState: expect.any(Object),
-                accountState: expect.any(Object),
-                caipNetworks: expect.any(Array)
-            }));
-        });
-    });
-});
-//# sourceMappingURL=appkit.test.js.map