[gdpatchagent] fix(core,citizen-claim-widget): add switch-chain timeout, fix custodial misconfig status, use shared chain constant

- provider.tsx: some WalletConnect sessions never resolve or reject
  wallet_switchEthereumChain, so the request could hang switchChain forever
  and never reach the integrator override fallback. Races it against a
  10s timeout, treated like any other rejection.
- adapter.ts: when custodial execution has no configured client for any
  supported chain, this was reported as 'unsupported_chain', driving a
  "switch network" narrative the user has no way to act on (custodial mode
  has no wallet chain to switch). Now reports 'error' with a clear message
  instead, reserving 'unsupported_chain' for the real switchable case.
- CitizenClaimWidget.tsx: replaced a hard-coded 42220 fallback chain id
  with the existing SupportedChains.CELO constant already used elsewhere.

On-Behalf-Of: gdpatchagent[onecli] (yaskkeryodtdijpv)

Author: goodbounties-nanoclaw-agent[bot]

packages/citizen-claim-widget/src/CitizenClaimWidget.tsx

@@ -621,7 +621,7 @@ function CitizenClaimShell({
         ]}
         activeTab={activeTab}
         onTabChange={(tabId: string) => setActiveTab(tabId as CitizenClaimTab)}
-        chainId={chainId ?? fallbackChainId ?? 42220}
+        chainId={chainId ?? fallbackChainId ?? SupportedChains.CELO}
       />
       {activeTab === 'claim' ? (
         <>

packages/citizen-claim-widget/src/adapter.ts

@@ -550,13 +550,29 @@ export function useCitizenClaimAdapter(
         null
       : chainId
 
+    if (isCustodialExecution && statusChainId === null) {
+      await auxiliaryReads
+      // Custodial execution has no wallet chain to switch, so a missing
+      // client for every supported chain is an integrator configuration
+      // problem rather than something the "switch network" narrative below
+      // could ever resolve — route it to a plain error instead.
+      setAmount(null)
+      setNextClaimTime(null)
+      setStatus('error')
+      setError(
+        humanReadableError(
+          new CitizenClaimAdapterError('Claim execution is not configured for any supported chain.'),
+        ),
+      )
+      return
+    }
+
     if (statusChainId === null || !isSupportedChain(statusChainId)) {
       await auxiliaryReads
-      // Chain is known but unsupported (or custodial has no chain configured
-      // at all) — a distinct status from not_connected so the UI can show
-      // "switch chain" copy instead of misleadingly asking an already-connected
-      // wallet to connect. Clear personalized entitlement from whatever chain
-      // was previously active.
+      // Chain is known but unsupported — a distinct status from not_connected
+      // so the UI can show "switch chain" copy instead of misleadingly asking
+      // an already-connected wallet to connect. Clear personalized entitlement
+      // from whatever chain was previously active.
       setAmount(null)
       setNextClaimTime(null)
       setStatus('unsupported_chain')

packages/core/src/provider.tsx

@@ -42,11 +42,36 @@ export interface GoodWidgetContextValue extends GoodWidgetState {
 }
 
 const SWITCH_CHAIN_UNAVAILABLE_ERROR = 'No wallet provider available to switch chains'
+const SWITCH_CHAIN_TIMEOUT_ERROR = 'Timed out waiting for the wallet to respond to the network switch request'
+const SWITCH_CHAIN_REQUEST_TIMEOUT_MS = 10_000
 
 const noopSwitchChain = async () => {
   throw new Error(SWITCH_CHAIN_UNAVAILABLE_ERROR)
 }
 
+/**
+ * Races a promise against a timeout so a request the wallet never settles
+ * (some WalletConnect sessions never resolve or reject
+ * wallet_switchEthereumChain at all) doesn't hang the caller forever — a
+ * timeout is treated the same as any other rejection, so switchChain's
+ * existing override fallback below still applies.
+ */
+function raceWithTimeout<T>(promise: Promise<T>, timeoutMs: number, timeoutMessage: string): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs)
+    promise.then(
+      (value) => {
+        clearTimeout(timer)
+        resolve(value)
+      },
+      (err) => {
+        clearTimeout(timer)
+        reject(err)
+      },
+    )
+  })
+}
+
 /**
  * EIP-1193's standard user-rejection code (4001), plus ethers v6's
  * ACTION_REJECTED — both mean the wallet's own switch-chain prompt was
@@ -206,16 +231,21 @@ export function GoodWidgetProvider({
 
   // Tries the standard EIP-3326 request first; falls back to the
   // integrator's own switch/network-modal flow (e.g. AppKit) when the
-  // active connector rejects or does not support it — some WalletConnect
-  // sessions never resolve wallet_switchEthereumChain at all.
+  // active connector rejects, does not support it, or never settles the
+  // request at all (some WalletConnect sessions do this, hence the timeout
+  // race below rather than a bare await).
   const switchChain = useCallback(
     async (targetChainId: number) => {
       if (resolvedProvider) {
         try {
-          await resolvedProvider.request({
-            method: 'wallet_switchEthereumChain',
-            params: [{ chainId: `0x${targetChainId.toString(16)}` }],
-          })
+          await raceWithTimeout(
+            resolvedProvider.request({
+              method: 'wallet_switchEthereumChain',
+              params: [{ chainId: `0x${targetChainId.toString(16)}` }],
+            }),
+            SWITCH_CHAIN_REQUEST_TIMEOUT_MS,
+            SWITCH_CHAIN_TIMEOUT_ERROR,
+          )
           return
         } catch (err) {
           if (!switchChainOverride || isUserRejectedSwitchChain(err)) throw err