@layerswap/wallets 1.7.0-next.1 → 2.0.0-next.0

package/README.md

@@ -47,16 +47,16 @@ export default function Page() {
 }
 ```
 
-Render the Layerswap Widget with the wallet providers you want to enable. Only the providers you include are bundled (tree-shakeable).
+Render the Layerswap Widget with the wallet providers you want to enable. Only EVM is wired eagerly; every other chain is a lazy descriptor whose SDK is dynamic-imported when the user first opens the connect modal, so it stays out of your entry chunk.
 
 ```tsx
 import { LayerswapProvider, Swap } from "@layerswap/widget";
 import {
   createEVMProvider,
-  createStarknetProvider,
-  createSVMProvider,
-  createTONProvider,
-  createTronProvider,
+  createStarknetDescriptor,
+  createSVMDescriptor,
+  createTONDescriptor,
+  createTronDescriptor,
 } from "@layerswap/wallets";
 
 export default function Page() {
@@ -73,21 +73,15 @@ export default function Page() {
     createEVMProvider({
       walletConnectConfigs
     }),
-    createStarknetProvider({
-      walletConnectConfigs
-    }),
-    createSVMProvider({
-      walletConnectConfigs
-    }),
-    createTONProvider({
-      tonConfigs: {
-        tonApiKey: "your-ton-api-key",
-        manifestUrl: "https://your-app.com/tonconnect-manifest.json"
-      }
+    createStarknetDescriptor(),
+    createSVMDescriptor(walletConnectConfigs),
+    createTONDescriptor({
+      tonApiKey: "your-ton-api-key",
+      manifestUrl: "https://your-app.com/tonconnect-manifest.json"
     }),
-    createTronProvider(),
+    createTronDescriptor(),
   ];
-  
+
   return (
     <LayerswapProvider walletProviders={walletProviders}>
       <Swap />
@@ -98,21 +92,32 @@ export default function Page() {
 
 ## Usage by network
 
-All provider factories are exported from `@layerswap/wallets`:
-
-- EVM (Ethereum, L2s): `createEVMProvider()`
-- Starknet: `createStarknetProvider()`
-- Solana: `createSVMProvider()`
-- TON: `createTONProvider()`
-- Tron: `createTronProvider()`
-- Fuel: `createFuelProvider()`
-- Bitcoin: `createBitcoinProvider()`
-- Paradex: `createParadexProvider()`
-- Immutable Passport: `createImmutablePassportProvider()`
-- Loopring (module): `createLoopringModule()` - use with `createEVMProvider()`
-- zkSync (module): `createZkSyncModule()` - use with `createEVMProvider()`
-
-You can mix and match any subset depending on your app needs.
+Exported from the `@layerswap/wallets` root:
+
+- EVM (Ethereum, L2s): `createEVMProvider()` — eager
+- Starknet: `createStarknetDescriptor()`
+- Solana: `createSVMDescriptor()`
+- TON: `createTONDescriptor()`
+- Tron: `createTronDescriptor()`
+- Fuel: `createFuelDescriptor()`
+- Bitcoin: `createBitcoinDescriptor()`
+- Paradex: `createParadexDescriptor()`
+- Immutable Passport: `createImmutablePassportDescriptor()`
+
+You can mix and match any subset depending on your app needs. If you need the eager (non-descriptor) factory for a chain, import it directly from that chain's package, e.g. `import { createStarknetProvider } from "@layerswap/wallet-starknet"`.
+
+### Eager Immutable Passport subpath
+
+`createImmutablePassportProvider` and `imtblPassportLoginCallback` are intentionally not exported from the package root — a static root import would pull `@imtbl/sdk` (~993 KB Brotli) into every consumer's bundle. Import them from the dedicated subpath, and only from chunks that genuinely need them eagerly (e.g. an OAuth callback page):
+
+```tsx
+import {
+  createImmutablePassportProvider,
+  imtblPassportLoginCallback,
+} from "@layerswap/wallets/eager/imtbl-passport";
+```
+
+For the common case, use the lazy descriptor via `getDefaultProviders({ immutablePassport })` or `createImmutablePassportDescriptor()` instead.
 
 ## Included packages
 

package/dist/esm/descriptors/bitcoin.js

@@ -0,0 +1,34 @@
+import { defineWalletDescriptor } from "./defineWalletDescriptor";
+import { readStorageJson } from "./persistedSession";
+const BITCOIN_NETWORKS = ['BITCOIN_MAINNET', 'BITCOIN_TESTNET'];
+/**
+ * Tree-shake-safe stand-in for `createBitcoinProvider`. Defers `bitcoinjs-lib`,
+ * `@bigmi/client`, `bn.js`, and `tweetnacl` — combined ~280 KB parsed /
+ * ~88 KB gzip — out of the host's entry chunk.
+ */
+export function createBitcoinDescriptor(options) {
+    const supportedNetworks = options?.supportedNetworks ?? BITCOIN_NETWORKS;
+    return defineWalletDescriptor({
+        id: 'bitcoin',
+        name: 'Bitcoin',
+        autofillSupportedNetworks: supportedNetworks,
+        withdrawalSupportedNetworks: supportedNetworks,
+        asSourceSupportedNetworks: supportedNetworks,
+        // Mirrors the real provider's snapshot (BitcoinConnectionService.buildProvider):
+        // without it the pre-hydration stub counts Bitcoin as mobile-supported,
+        // flipping platform-gated state once the descriptor loads.
+        unsupportedPlatforms: ['mobile'],
+        // @bigmi/client's `<prefix>.recentConnectorId`. A MetaMask marker is
+        // not restorable (its reconnect opens a popup, so wallet-bitcoin's
+        // NON_SILENT_CONNECTOR_IDS excludes it from session restore); the id
+        // is inlined so this stub never imports the SDK.
+        hasPersistedSession: () => {
+            const recent = readStorageJson('bigmi.recentConnectorId');
+            return typeof recent === 'string' && recent !== 'io.metamask.bitcoin';
+        },
+        loadProvider: async () => {
+            const mod = await import('@layerswap/wallet-bitcoin');
+            return mod.createBitcoinProvider();
+        },
+    });
+}

package/dist/esm/descriptors/defineWalletDescriptor.js

@@ -0,0 +1,17 @@
+/**
+ * Identity helper that pins a default descriptor's `id` at the type level:
+ *
+ * 1. The id must be a member of the public `WalletProviderId` union in
+ *    `@layerswap/widget-types` — the contract `walletProvidersConfig`'s
+ *    `include`/`exclude` filters are typed against.
+ * 2. The provider returned by `loadProvider()` must declare the same literal
+ *    id (chain packages type their factories as
+ *    `WalletProvider & { id: typeof id }`), so the registry key cannot flip
+ *    when a descriptor hydrates into its real provider.
+ *
+ * Either kind of drift is a compile error instead of a silently broken
+ * id-keyed lookup.
+ */
+export function defineWalletDescriptor(descriptor) {
+    return descriptor;
+}

package/dist/esm/descriptors/fuel.js

@@ -0,0 +1,26 @@
+import { defineWalletDescriptor } from "./defineWalletDescriptor";
+import { hasStorageKey } from "./persistedSession";
+const FUEL_NETWORKS = ['FUEL_MAINNET', 'FUEL_TESTNET', 'FUEL_DEVNET'];
+/**
+ * Tree-shake-safe stand-in for `createFuelProvider`. Defers `@fuel-ts/*` +
+ * `@fuels/vm-asm` — ~373 KB parsed / ~116 KB gzip — out of the host's entry
+ * chunk.
+ */
+export function createFuelDescriptor(options) {
+    const supportedNetworks = options?.supportedNetworks ?? FUEL_NETWORKS;
+    return defineWalletDescriptor({
+        id: 'fuel',
+        name: 'Fuel',
+        autofillSupportedNetworks: supportedNetworks,
+        withdrawalSupportedNetworks: supportedNetworks,
+        asSourceSupportedNetworks: supportedNetworks,
+        // `Fuel.STORAGE_KEY` in @fuel-ts/account — written once a fuel
+        // connector was detected as installed, so hydration only triggers
+        // for users who actually have a Fuel-family extension.
+        hasPersistedSession: () => hasStorageKey('fuel-current-connector'),
+        loadProvider: async () => {
+            const mod = await import('@layerswap/wallet-fuel');
+            return mod.createFuelProvider();
+        },
+    });
+}

package/dist/esm/descriptors/imtblPassport.js

@@ -0,0 +1,22 @@
+import { defineWalletDescriptor } from "./defineWalletDescriptor";
+/**
+ * Tree-shake-safe stand-in for `createImmutablePassportProvider`. The factory
+ * is small, but running it imports `ImtblPassportService`, whose `@imtbl/sdk`
+ * chunks (~993 KB) then load eagerly on `/` — so defer the factory call
+ * itself. `/imtblRedirect` is unaffected (it imports the real factory
+ * directly). Empty network arrays are intentional: Passport authenticates and
+ * delegates to the EVM provider, so it's a connector, never a route source.
+ */
+export function createImmutablePassportDescriptor(imtblPassportConfig) {
+    return defineWalletDescriptor({
+        id: 'imtblPassport',
+        name: 'Immutable Passport',
+        autofillSupportedNetworks: [],
+        withdrawalSupportedNetworks: [],
+        asSourceSupportedNetworks: [],
+        loadProvider: async () => {
+            const mod = await import('@layerswap/wallet-imtbl-passport');
+            return mod.createImmutablePassportProvider({ imtblPassportConfig });
+        },
+    });
+}

package/dist/esm/descriptors/paradex.js

@@ -0,0 +1,32 @@
+import { defineWalletDescriptor } from "./defineWalletDescriptor";
+import { readStorageJson } from "./persistedSession";
+// Inlined — importing Paradex's runtime constants drags `starknet` (~884 KB
+// parsed) into the host entry chunk. Keep in sync with the
+// `ParadexMainnet`/`ParadexTestnet` entries in widget's `knownIds.ts`.
+const PARADEX_NETWORKS = ['PARADEX_MAINNET', 'PARADEX_TESTNET'];
+/**
+ * Tree-shake-safe stand-in for `createParadexProvider` — defers
+ * `@paradex/sdk` → `starknet` out of the host's entry chunk.
+ */
+export function createParadexDescriptor(options) {
+    const supportedNetworks = options?.supportedNetworks ?? PARADEX_NETWORKS;
+    return defineWalletDescriptor({
+        id: 'paradex',
+        name: 'Paradex',
+        autofillSupportedNetworks: supportedNetworks,
+        withdrawalSupportedNetworks: supportedNetworks,
+        asSourceSupportedNetworks: supportedNetworks,
+        hideFromList: true,
+        // Key presence isn't a session signal — any write to widget's
+        // walletStore creates `ls-paradex-accounts`, even with no accounts.
+        // Hydrate eagerly only when actual L1 → Paradex mappings exist.
+        hasPersistedSession: () => {
+            const persisted = readStorageJson('ls-paradex-accounts');
+            return Object.keys(persisted?.state?.paradexAccounts ?? {}).length > 0;
+        },
+        loadProvider: async () => {
+            const mod = await import('@layerswap/wallet-paradex');
+            return mod.createParadexProvider();
+        },
+    });
+}

package/dist/esm/descriptors/persistedSession.js

@@ -0,0 +1,26 @@
+/**
+ * Probe helpers for descriptor `hasPersistedSession`. Storage-key literals
+ * are inlined at each call site — importing an SDK's key constant would drag
+ * in the SDK that descriptors exist to defer.
+ */
+export function hasStorageKey(key) {
+    if (typeof window === 'undefined')
+        return false;
+    try {
+        return window.localStorage.getItem(key) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+export function readStorageJson(key) {
+    if (typeof window === 'undefined')
+        return undefined;
+    try {
+        const raw = window.localStorage.getItem(key);
+        return raw ? JSON.parse(raw) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/esm/descriptors/starknet.js

@@ -0,0 +1,32 @@
+import { defineWalletDescriptor } from "./defineWalletDescriptor";
+import { readStorageJson } from "./persistedSession";
+// Inlined — importing `KnownInternalNames` pulls a runtime barrel that
+// defeats lazy-loading. Keep in sync with packages/wallets/adapters/starknet/src/constants.ts.
+const STARKNET_NETWORKS = ['STARKNET_MAINNET', 'STARKNET_SEPOLIA', 'STARKNET_GOERLI'];
+/**
+ * Tree-shake-safe stand-in for `createStarknetProvider` — defers
+ * `@layerswap/wallet-starknet` (`starknet`, starknetkit) out of the host's
+ * entry chunk.
+ */
+export function createStarknetDescriptor(options) {
+    const supportedNetworks = options?.supportedNetworks ?? STARKNET_NETWORKS;
+    return defineWalletDescriptor({
+        id: 'starknet',
+        name: 'Starknet',
+        autofillSupportedNetworks: supportedNetworks,
+        withdrawalSupportedNetworks: supportedNetworks,
+        asSourceSupportedNetworks: supportedNetworks,
+        // Key presence isn't a session signal — any write to wallet-starknet's
+        // store creates `ls-starknet-accounts`, even with empty state.
+        // Hydrate eagerly only when actual account state exists.
+        hasPersistedSession: () => {
+            const persisted = readStorageJson('ls-starknet-accounts');
+            const state = persisted?.state;
+            return !!state?.activeWalletAddress || Object.keys(state?.starknetAccounts ?? {}).length > 0;
+        },
+        loadProvider: async () => {
+            const mod = await import('@layerswap/wallet-starknet');
+            return mod.createStarknetProvider();
+        },
+    });
+}

package/dist/esm/descriptors/svm.js

@@ -0,0 +1,39 @@
+import { defineWalletDescriptor } from "./defineWalletDescriptor";
+import { hasStorageKey } from "./persistedSession";
+// SVM's runtime list is built dynamically from `NetworkType.Solana` networks
+// in `SvmConnectionService` — for static gating we mirror the universe of
+// Solana network ids from widget's `knownIds.ts`. Extras don't hurt the
+// route filter (it intersects with the active networks list); missing entries
+// would.
+const SVM_NETWORKS = ['SOLANA_MAINNET', 'SOLANA_TESTNET', 'SOLANA_DEVNET'];
+/**
+ * Tree-shake-safe stand-in for `createSVMProvider`. Defers the eager portion
+ * of `@solana/web3.js` (~142 KB parsed) and `@walletconnect` adapters dragged
+ * by `SolanaWalletConnectAdapter` (~138 KB parsed) out of the host's entry
+ * chunk.
+ */
+export function createSVMDescriptor(walletConnectConfigs, options) {
+    const supportedNetworks = options?.supportedNetworks ?? SVM_NETWORKS;
+    return defineWalletDescriptor({
+        id: 'solana',
+        name: 'Solana',
+        // Keep this descriptor's module graph type-only; loading the widget or
+        // Solana runtime here would defeat the lazy-provider boundary.
+        capabilities: {
+            walletConnectRegistry: {
+                networkTypes: ['solana'],
+            },
+        },
+        autofillSupportedNetworks: supportedNetworks,
+        withdrawalSupportedNetworks: supportedNetworks,
+        asSourceSupportedNetworks: supportedNetworks,
+        // `STORAGE_KEY` in wallet-svm's svmAdapterManager — persisted only
+        // after a selection actually connected, so it's a reliable
+        // restorable-session hint.
+        hasPersistedSession: () => hasStorageKey('walletAdapterPreviouslySelectedName'),
+        loadProvider: async () => {
+            const mod = await import('@layerswap/wallet-svm');
+            return mod.createSVMProvider({ walletConnectConfigs });
+        },
+    });
+}

package/dist/esm/descriptors/ton.js

@@ -0,0 +1,29 @@
+import { defineWalletDescriptor } from "./defineWalletDescriptor";
+import { hasStorageKey } from "./persistedSession";
+// Inlined — see notes in ./starknet.ts on why we don't import the chain
+// package's constants (it would drag the SDK). Keep in sync with
+// packages/wallets/adapters/ton/src/constants.ts and widget's `knownIds.ts`.
+const TON_NETWORKS = ['TON_MAINNET', 'TON_TESTNET'];
+/**
+ * Tree-shake-safe stand-in for `createTONProvider`. Defers `@tonconnect/sdk`
+ * + `@ton/*` (~404 KB parsed / 139 KB gzip on `apps/bridge`) out of the
+ * host's entry chunk. The TON wallet only appears when a tonConfigs is
+ * supplied, mirroring the previous conditional in `getDefaultProviders`.
+ */
+export function createTONDescriptor(tonConfigs, options) {
+    const supportedNetworks = options?.supportedNetworks ?? TON_NETWORKS;
+    return defineWalletDescriptor({
+        id: 'ton',
+        name: 'Ton',
+        autofillSupportedNetworks: supportedNetworks,
+        withdrawalSupportedNetworks: supportedNetworks,
+        asSourceSupportedNetworks: supportedNetworks,
+        // @tonconnect/sdk's connection storage key — holds both injected and
+        // http (bridge) sessions that restoreConnection() can resume.
+        hasPersistedSession: () => hasStorageKey('ton-connect-storage_bridge-connection'),
+        loadProvider: async () => {
+            const mod = await import('@layerswap/wallet-ton');
+            return mod.createTONProvider({ tonConfigs });
+        },
+    });
+}

package/dist/esm/descriptors/tron.js

@@ -0,0 +1,24 @@
+import { defineWalletDescriptor } from "./defineWalletDescriptor";
+import { readStorageJson } from "./persistedSession";
+const TRON_NETWORKS = ['TRON_MAINNET', 'TRON_TESTNET'];
+/**
+ * Tree-shake-safe stand-in for `createTronProvider`. Defers `tronweb` +
+ * `validator` (a transitive 125 KB dep of tronweb) + `bignumber.js` +
+ * `google-protobuf` schemas — ~775 KB parsed / ~165 KB gzip — out of the
+ * host's entry chunk.
+ */
+export function createTronDescriptor(options) {
+    const supportedNetworks = options?.supportedNetworks ?? TRON_NETWORKS;
+    return defineWalletDescriptor({
+        id: 'tron',
+        name: 'Tron',
+        autofillSupportedNetworks: supportedNetworks,
+        withdrawalSupportedNetworks: supportedNetworks,
+        asSourceSupportedNetworks: supportedNetworks,
+        hasPersistedSession: () => typeof readStorageJson('tronAdapterName') === 'string',
+        loadProvider: async () => {
+            const mod = await import('@layerswap/wallet-tron');
+            return mod.createTronProvider();
+        },
+    });
+}

package/dist/esm/eager/imtblPassport.js

@@ -0,0 +1,8 @@
+// Eager re-exports of Immutable Passport. Importing this subpath pulls
+// `@imtbl/sdk` (~993 KB Brotli) into your bundle eagerly — only do this
+// from chunks that genuinely need it (e.g. the OAuth callback page).
+//
+// For the common case, use the lazy descriptor instead via
+// `getDefaultProviders({ immutablePassport })` from the main entry of
+// `@layerswap/wallets`.
+export { createImmutablePassportProvider, imtblPassportLoginCallback, } from "@layerswap/wallet-imtbl-passport";

package/dist/esm/index.js

@@ -1,75 +1,44 @@
 // Import all wallet provider factories and types
-import { createBitcoinProvider } from "@layerswap/wallet-bitcoin";
-import { createEVMProvider, useChainConfigs } from "@layerswap/wallet-evm";
-import { createFuelProvider } from "@layerswap/wallet-fuel";
-import { createImmutablePassportProvider, ImtblRedirect } from "@layerswap/wallet-imtbl-passport";
-import { createParadexProvider } from "@layerswap/wallet-paradex";
-import { createStarknetProvider } from "@layerswap/wallet-starknet";
-import { createSVMProvider } from "@layerswap/wallet-svm";
-import { createTONProvider } from "@layerswap/wallet-ton";
-import { createTronProvider } from "@layerswap/wallet-tron";
-export { createBitcoinProvider };
-export { createEVMProvider, useChainConfigs };
-export { createFuelProvider };
-export { createImmutablePassportProvider, ImtblRedirect };
-export { createParadexProvider };
-export { createStarknetProvider };
-export { createSVMProvider };
-export { createTONProvider };
-export { createTronProvider };
-/**
- * @deprecated Use createBitcoinProvider() instead. This export will be removed in a future version.
- */
-export { BitcoinProvider } from "@layerswap/wallet-bitcoin";
-/**
- * @deprecated Use createEVMProvider() instead. This export will be removed in a future version.
- */
-export { EVMProvider } from "@layerswap/wallet-evm";
-/**
- * @deprecated Use createFuelProvider() instead. This export will be removed in a future version.
- */
-export { FuelProvider } from "@layerswap/wallet-fuel";
-/**
- * @deprecated Use createImmutablePassportProvider() instead. This export will be removed in a future version.
- */
-export { ImtblPassportProvider } from "@layerswap/wallet-imtbl-passport";
-/**
- * @deprecated Use createParadexProvider() instead. This export will be removed in a future version.
- */
-export { ParadexProvider } from "@layerswap/wallet-paradex";
-/**
- * @deprecated Use createStarknetProvider() instead. This export will be removed in a future version.
- */
-export { StarknetProvider } from "@layerswap/wallet-starknet";
-/**
- * @deprecated Use createSVMProvider() instead. This export will be removed in a future version.
- */
-export { SVMProvider } from "@layerswap/wallet-svm";
-/**
- * @deprecated Use createTONProvider() instead. This export will be removed in a future version.
- */
-export { TONProvider } from "@layerswap/wallet-ton";
-/**
- * @deprecated Use createTronProvider() instead. This export will be removed in a future version.
- */
-export { TronProvider } from "@layerswap/wallet-tron";
+//
+// IMPORTANT: only `createEVMProvider`, `createImmutablePassportProvider`, and
+// `imtblPassportLoginCallback` are value-imported eagerly from the chain
+// packages. Every other chain is wired via a descriptor (see
+// ./descriptors/*) so the chain SDK stays out of the host's entry chunk
+// until the user actually opens the connect modal. Direct consumers can
+// still `import { create<X>Provider } from "@layerswap/wallet-<chain>"`
+// themselves if they want the eager path.
+import { createBitcoinDescriptor } from "./descriptors/bitcoin";
+import { createEVMProvider } from "@layerswap/wallet-evm";
+import { createFuelDescriptor } from "./descriptors/fuel";
+import { createImmutablePassportDescriptor } from "./descriptors/imtblPassport";
+import { createParadexDescriptor } from "./descriptors/paradex";
+import { createStarknetDescriptor } from "./descriptors/starknet";
+import { createSVMDescriptor } from "./descriptors/svm";
+import { createTONDescriptor } from "./descriptors/ton";
+import { createTronDescriptor } from "./descriptors/tron";
+export { defineWalletDescriptor } from "./descriptors/defineWalletDescriptor";
+export { createBitcoinDescriptor };
+export { createEVMProvider };
+export { createFuelDescriptor };
+export { createImmutablePassportDescriptor };
+// For eager `createImmutablePassportProvider` / `imtblPassportLoginCallback`
+// see the dedicated subpath: `@layerswap/wallets/eager/imtbl-passport`.
+export { createParadexDescriptor };
+export { createStarknetDescriptor };
+export { createSVMDescriptor };
+export { createTONDescriptor };
+export { createTronDescriptor };
 /**
  * Creates and returns a default configuration of all wallet providers.
  *
- * This function provides a convenient way to instantiate all supported wallet providers
- * with a single function call. Providers are configured based on the options provided:
- *
- * - **EVM, Starknet, SVM**: Use WalletConnect configuration if provided, with fallback to undefined
- * - **TON**: Always included, uses provided configuration or undefined as fallback
- * - **Immutable Passport**: Included only if Immutable Passport configuration is provided
- * - **Bitcoin, Fuel, Tron, Paradex, ImmutableX**: Always included (no configuration required)
- * - **EVM**: Includes zkSync and Loopring modules by default
+ * Only EVM (and Immutable Passport, when configured) is wired eagerly. Every
+ * other chain ships as a `WalletProviderDescriptor` — the real SDK is
+ * dynamic-imported on first connect-modal open. This keeps starknet,
+ * @paradex/sdk, @ton/*, @tonconnect/sdk, @fuel-ts/*, @solana/web3.js,
+ * tronweb (+ its transitive `validator`/`bignumber.js`), bitcoinjs-lib,
+ * @bigmi, and the connector adapters out of the host's entry chunk.
  *
  * @param config - Configuration options for the wallet providers
- * @param config.walletConnect - Optional WalletConnect configuration (projectId, name, description, url, icons)
- * @param config.ton - Optional TON client configuration (tonApiKey, manifestUrl)
- * @param config.immutablePassport - Optional Immutable Passport configuration (publishableKey, clientId, redirectUri, logoutRedirectUri)
- *
  * @returns Array of configured wallet providers ready to be passed to LayerswapProvider
  *
  * @example
@@ -103,28 +72,31 @@ export { TronProvider } from "@layerswap/wallet-tron";
 export function getDefaultProviders(config = {}) {
     const { walletConnect, ton, immutablePassport } = config;
     const providers = [
-        // EVM with modules
+        // EVM — eager (common case, kept on the initial bundle).
         createEVMProvider({
             walletConnectConfigs: walletConnect,
         }),
-        // Starknet
-        createStarknetProvider(),
-        // Fuel
-        createFuelProvider(),
-        // Paradex
-        createParadexProvider(),
-        // Bitcoin
-        createBitcoinProvider(),
-        // TON
-        ...(ton ? [createTONProvider({ tonConfigs: ton })] : []),
-        // SVM (Solana)
-        createSVMProvider({
-            walletConnectConfigs: walletConnect
-        }),
-        // Tron
-        createTronProvider(),
-        // Immutable Passport (conditional)
-        ...(immutablePassport ? [createImmutablePassportProvider({ imtblPassportConfig: immutablePassport })] : [])
+        // Starknet — lazy. Pulls starknet/starkware-crypto on connect.
+        createStarknetDescriptor(),
+        // Fuel — lazy. Pulls @fuel-ts/* + @fuels/vm-asm on connect.
+        createFuelDescriptor(),
+        // Paradex — lazy. Drags @paradex/sdk → starknet → starkware-crypto.
+        createParadexDescriptor(),
+        // Bitcoin — lazy. Pulls bitcoinjs-lib + @bigmi + bn.js + tweetnacl.
+        createBitcoinDescriptor(),
+        // TON — lazy and conditional (only included when tonConfigs supplied,
+        // matching the prior eager behaviour).
+        ...(ton ? [createTONDescriptor(ton)] : []),
+        // SVM (Solana) — lazy. Pulls @solana/web3.js + SolanaWalletConnectAdapter.
+        createSVMDescriptor(walletConnect),
+        // Tron — lazy. Pulls tronweb + its transitive validator/bignumber/protobuf.
+        createTronDescriptor(),
+        // Immutable Passport — lazy and conditional. The SDK + service
+        // init chain pulls ~993 KB Brotli; deferring it to first
+        // connect-modal open removes that from the home page waterfall.
+        // The OAuth redirect page (`/imtblRedirect`) imports the
+        // eager factory + login callback directly so it still works.
+        ...(immutablePassport ? [createImmutablePassportDescriptor(immutablePassport)] : [])
     ];
     return providers;
 }