@meshconnect/uwc-react 0.9.4 → 0.10.0

package/src/providers/ConnectionProvider.singleton.test.tsx

@@ -1,7 +1,17 @@
 import { useContext, act } from 'react'
 import { describe, it, expect, beforeEach, vi } from 'vitest'
 import { createRoot } from 'react-dom/client'
-import type { TronConnectorConfig } from '@meshconnect/uwc-types'
+import type {
+  TronConnectorConfig,
+  WalletMetadata
+} from '@meshconnect/uwc-types'
+
+// The provider only constructs a connector when at least one wallet is present
+// (core rejects an empty wallet list), so these construction-focused tests pass
+// a minimal wallet.
+const TEST_WALLETS: WalletMetadata[] = [
+  { id: 'metamask', name: 'MetaMask', metadata: {} }
+]
 
 describe('ConnectionProvider singleton behavior', () => {
   beforeEach(async () => {
@@ -68,14 +78,14 @@ describe('ConnectionProvider singleton behavior', () => {
         <>
           <ConnectionProvider
             networks={[]}
-            wallets={[]}
+            wallets={TEST_WALLETS}
             usingIntegratedBrowser={false}
           >
             <Capture />
           </ConnectionProvider>
           <ConnectionProvider
             networks={[]}
-            wallets={[]}
+            wallets={TEST_WALLETS}
             usingIntegratedBrowser={false}
           >
             <Capture />
@@ -88,9 +98,10 @@ describe('ConnectionProvider singleton behavior', () => {
     // @ts-expect-error test-only property
     expect(UniversalWalletConnector.calls).toBe(1)
 
-    // Both providers should expose the same connector instance
-    expect(connectors.length).toBe(2)
-    expect(connectors[0]).toBe(connectors[1])
+    // Both providers should expose the same connector instance (render count is
+    // an implementation detail — assert the singleton invariant, not the count).
+    expect(connectors.length).toBeGreaterThanOrEqual(2)
+    expect(connectors.every(c => c === connectors[0])).toBe(true)
 
     await act(async () => {
       root.unmount()
@@ -140,7 +151,7 @@ describe('ConnectionProvider singleton behavior', () => {
       root.render(
         <ConnectionProvider
           networks={[]}
-          wallets={[]}
+          wallets={TEST_WALLETS}
           tronConnectorConfig={tronConnectorConfig}
         >
           <div />

package/src/providers/ConnectionProvider.tsx

@@ -12,8 +12,35 @@ import type {
 // Guard against double initialization
 let sharedConnector: UniversalWalletConnector | null = null
 
-interface ConnectionContextValue {
-  connector: UniversalWalletConnector
+/**
+ * Session served before any wallet is connected — and while the provider is
+ * mounted without wallets (a wallet-less session; see `connector` below). Every
+ * field is at its natural empty per the `Session` type, so the read-only hooks
+ * (`useSession`/`useNetworks`/`useWallets`) work unchanged and the sign/transfer
+ * hooks short-circuit on their existing `activeAddress` guard.
+ */
+const EMPTY_SESSION: Session = {
+  connectionMode: null,
+  activeNetwork: null,
+  activeWalletCapabilities: null,
+  activeNetworkWalletCapabilities: null,
+  activeAddress: null,
+  publicKey: null,
+  availableNetworks: [],
+  activeWallet: null,
+  availableAddresses: []
+}
+
+export interface ConnectionContextValue {
+  /**
+   * `null` when the provider is mounted without wallets. `@meshconnect/uwc-core`
+   * requires at least one wallet to construct a connector, so a wallet-less
+   * session (e.g. a CEX-only catalog) legitimately has none. Hooks treat a null
+   * connector as "no wallet session" and return inert values instead of
+   * throwing, so a host that mounts this provider for every session — wallet or
+   * not — does not crash.
+   */
+  connector: UniversalWalletConnector | null
   session: Session
   wallets: WalletMetadata[]
   networks: Network[]
@@ -41,7 +68,10 @@ export function ConnectionProvider({
   tonConnectConfig,
   tronConnectorConfig
 }: ConnectionProviderProps) {
-  if (!sharedConnector) {
+  // Core rejects an empty wallet list, so only construct once there is at least
+  // one wallet. A wallet-less session keeps `connector` null; the effect below
+  // adopts the connector if wallets arrive later (async catalog population).
+  if (!sharedConnector && wallets.length > 0) {
     sharedConnector = new UniversalWalletConnector(
       networks,
       wallets,
@@ -54,10 +84,19 @@ export function ConnectionProvider({
 
   const connector = sharedConnector
 
-  const [session, setSession] = useState<Session>(() => connector.getSession())
-  const [isReady, setIsReady] = useState(() => connector.isReady())
+  const [session, setSession] = useState<Session>(
+    () => connector?.getSession() ?? EMPTY_SESSION
+  )
+  const [isReady, setIsReady] = useState(() => connector?.isReady() ?? false)
 
   useEffect(() => {
+    if (!connector) return
+
+    // Sync once on adoption — covers the case where the connector was created
+    // after the first render (wallets populated asynchronously).
+    setSession(connector.getSession())
+    setIsReady(connector.isReady())
+
     const unsubscribe = connector.subscribe(() => {
       setSession(connector.getSession())
       setIsReady(connector.isReady())
@@ -69,8 +108,8 @@ export function ConnectionProvider({
   const value: ConnectionContextValue = {
     connector,
     session,
-    wallets: connector.getWallets(),
-    networks: connector.getNetworks(),
+    wallets: connector ? connector.getWallets() : wallets,
+    networks: connector ? connector.getNetworks() : networks,
     isReady
   }