fix: guard REACTOR_ADDRESS_MAPPING[chainId] against undefined (#669)

PR #654 expanded SUPPORTED_CHAINS from 7 to 18, but not every new chain
has an entry in the SDK's REACTOR_ADDRESS_MAPPING. Five call sites
indexed REACTOR_ADDRESS_MAPPING[chainId][orderType] without guarding the
parent, so an unmapped chain produced
"TypeError: Cannot read properties of undefined (reading 'Relay')".

EventWatcherMap.createRelayEventWatcherMap() runs at module load of
get-orders/index.ts. With beta provisioned concurrency reset to 0
(#666), every cold start re-evaluated the module, the TypeError aborted
init, and API Gateway surfaced 502s for requests that should have been
4xx (e.g. e2e Error Handling > should handle invalid parameters).

Optional-chain the lookups so unmapped chains fall through to existing
guard branches:
- EventWatcherMap: skip the chain instead of throwing at module load.
- OffChain{Relay,UniswapX}OrderValidator: return "Invalid reactor
  address" (400) instead of TypeError (500).
- check-order-status/util.getWatcher: existing throw fires with the
  intended message instead of a TypeError.
- gs-reaper.processBlockRange: short-circuit the orderType loop when
  the chain has no reactor mapping; the cron keeps running for other
  chains.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: codyborn

lib/crons/gs-reaper/gs-reaper.ts

@@ -266,8 +266,13 @@ async function processBlockRange(
 ): Promise<{ updates: Record<string, OrderUpdate>, remainingHashes: Set<string> }> {
   const orderUpdates = { ...existingUpdates }
 
-  for (const orderType of Object.keys(REACTOR_ADDRESS_MAPPING[chainId])) {
-    const reactorAddress = REACTOR_ADDRESS_MAPPING[chainId][orderType as OrderType]
+  const reactorMap = REACTOR_ADDRESS_MAPPING[chainId]
+  if (!reactorMap) {
+    log.info(`No reactor mapping for chainId ${chainId}, skipping block range`)
+    return { updates: orderUpdates, remainingHashes: orderHashSet }
+  }
+  for (const orderType of Object.keys(reactorMap)) {
+    const reactorAddress = reactorMap[orderType as OrderType]
     if (!reactorAddress || reactorAddress === "0x0000000000000000000000000000000000000000") continue
     log.info(`Processing block range ${fromBlock} to ${toBlock} for chainId ${chainId} orderType ${orderType}`)
 

lib/handlers/EventWatcherMap.ts

@@ -29,9 +29,9 @@ export class EventWatcherMap<T extends UniswapXEventWatcher | RelayEventWatcher>
   public static createRelayEventWatcherMap() {
     const map = new EventWatcherMap<RelayEventWatcher>()
     for (const chainId of SUPPORTED_CHAINS) {
-      const address = REACTOR_ADDRESS_MAPPING[chainId][OrderType.Relay]
+      const address = REACTOR_ADDRESS_MAPPING[chainId]?.[OrderType.Relay]
       if (!address) {
-        throw new Error(`No Reactor Address Configured for ${chainId}, ${OrderType.Relay}`)
+        continue
       }
       map.set(
         chainId,

lib/handlers/check-order-status/util.ts

@@ -284,7 +284,7 @@ export function getWatcher(
   orderType: OrderType
 ): UniswapXEventWatcher {
   const reactorType = orderType === OrderType.Limit ? OrderType.Dutch : orderType
-  const address = REACTOR_ADDRESS_MAPPING[chainId][reactorType]
+  const address = REACTOR_ADDRESS_MAPPING[chainId]?.[reactorType]
   if (!address) {
     throw new Error(`No Reactor Address Defined in UniswapX SDK for chainId:${chainId}, orderType:${reactorType}`)
   }

lib/util/OffChainRelayOrderValidator.ts

@@ -72,7 +72,8 @@ export class OffChainRelayOrderValidator {
   }
 
   private validateReactorAddress(reactor: string, chainId: number): OrderValidationResponse {
-    if (reactor.toLowerCase() != REACTOR_ADDRESS_MAPPING[chainId][OrderType.Relay]!.toLowerCase()) {
+    const expected = REACTOR_ADDRESS_MAPPING[chainId]?.[OrderType.Relay]
+    if (!expected || reactor.toLowerCase() != expected.toLowerCase()) {
       return {
         valid: false,
         errorString: `Invalid reactor address`,

lib/util/OffChainUniswapXOrderValidator.ts

@@ -254,7 +254,8 @@ export class OffChainUniswapXOrderValidator {
     chainId: number,
     orderType: OrderType | undefined
   ): OrderValidationResponse {
-    if (!orderType || reactor.toLowerCase() != REACTOR_ADDRESS_MAPPING[chainId][orderType]!.toLowerCase()) {
+    const expected = orderType ? REACTOR_ADDRESS_MAPPING[chainId]?.[orderType] : undefined
+    if (!expected || reactor.toLowerCase() != expected.toLowerCase()) {
       return {
         valid: false,
         errorString: `Invalid reactor address`,