refactor: chain-agnostic MIN_RETRY_WAIT_SECONDS for Step Functions retries

Rename MIN_RETRY_WAIT_SECONDS_TEMPO to MIN_RETRY_WAIT_SECONDS, drop the
Tempo-only branch in calculateDutchRetryWaitSeconds, and apply the floor
to all chains. The floor exists to prevent Step Functions Wait state from
rounding sub-second block times to zero — that risk applies to any future
chain with sub-second blocks, not just Tempo. Lowered the floor value
from 2s to 1s (the minimum Step Functions can represent).

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

Author: codyborn

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

@@ -274,10 +274,10 @@ export const AVERAGE_BLOCK_TIME = (chainId: ChainId): number => {
     case ChainId.CELO:
       return 5
     case ChainId.TEMPO:
-      // Tempo blocks are ~500ms. Reported in seconds as a fractional value
-      // for accurate block-number arithmetic (see timestampToBlockNumber).
-      // Step Functions retry waits floor this via MIN_RETRY_WAIT_SECONDS_TEMPO
-      // in calculateDutchRetryWaitSeconds.
+      // Reported in seconds as a fractional value for accurate block-number
+      // arithmetic (see timestampToBlockNumber); calculateDutchRetryWaitSeconds
+      // floors retry waits at MIN_RETRY_WAIT_SECONDS so Step Functions Wait
+      // state doesn't round to zero.
       return 0.5
     case ChainId.POLYGON:
       // Keep this at the default 12 for now since we would have to do more retries
@@ -355,21 +355,12 @@ export function getValidator(provider: ethers.providers.StaticJsonRpcProvider, c
 }
 
 /*
- * Minimum wait between Step Functions retries on Tempo.
- *
- * Step Functions Wait state granularity is whole seconds, and Tempo's ~500ms
- * block time (AVERAGE_BLOCK_TIME = 0.5) would round down to 0 — effectively a
- * hot loop. Even at 1s per retry, 300 first-hour retries with ~7 history
- * events each would chew through the 25,000-event execution-history limit.
- *
- * 2 seconds keeps the first-hour-polling phase well under the event limit
- * (300 retries * ~7 events ≈ 2,100) while still being responsive enough to
- * detect fills promptly on Tempo.
- *
- * This floor is intentionally scoped to Tempo only so we don't change
- * behavior on chains like Arbitrum/Unichain where 1-second waits are fine.
+ * Minimum wait between Step Functions retries. Wait state granularity is
+ * whole seconds, so any sub-second block time would round to zero and
+ * hot-loop the state machine. Floor is one second — Step Functions' minimum
+ * representable wait.
  */
-export const MIN_RETRY_WAIT_SECONDS_TEMPO = 2
+export const MIN_RETRY_WAIT_SECONDS = 1
 
 /*
  * In the first hour of order submission, we check the order status roughly every block.
@@ -383,8 +374,5 @@ export function calculateDutchRetryWaitSeconds(chainId: ChainId, retryCount: num
       : retryCount <= 450
       ? Math.ceil(AVERAGE_BLOCK_TIME(chainId) * Math.pow(1.05, retryCount - 300))
       : 18000
-  if (chainId === ChainId.TEMPO) {
-    return Math.max(MIN_RETRY_WAIT_SECONDS_TEMPO, calculated)
-  }
-  return calculated
+  return Math.max(MIN_RETRY_WAIT_SECONDS, calculated)
 }

test/unit/services/check-order-status/util.test.ts

@@ -2,7 +2,7 @@ import { ethers } from 'ethers'
 import {
   AVERAGE_BLOCK_TIME,
   calculateDutchRetryWaitSeconds,
-  MIN_RETRY_WAIT_SECONDS_TEMPO,
+  MIN_RETRY_WAIT_SECONDS,
   timestampToBlockNumber,
 } from '../../../../lib/handlers/check-order-status/util'
 import { ChainId } from '../../../../lib/util/chain'
@@ -24,34 +24,31 @@ describe('calculateDutchRetryWaitSeconds', () => {
     expect(response).toEqual(18000)
   })
 
-  describe('Tempo floor', () => {
-    it('floors first-hour polling waits at MIN_RETRY_WAIT_SECONDS_TEMPO (Tempo block time = 0.5s)', () => {
-      // Without the floor, AVERAGE_BLOCK_TIME(TEMPO) = 0.5 would round down
-      // to 0 in Step Functions Wait granularity.
+  describe('sub-second-block floor', () => {
+    it(`floors sub-second block-time chains at MIN_RETRY_WAIT_SECONDS (${1}s)`, () => {
+      // AVERAGE_BLOCK_TIME(TEMPO) = 0.5 would round down to 0 in Step
+      // Functions Wait granularity without the floor.
       for (const retryCount of [1, 50, 150, 299, 300]) {
-        const response = calculateDutchRetryWaitSeconds(ChainId.TEMPO, retryCount)
-        expect(response).toBeGreaterThanOrEqual(MIN_RETRY_WAIT_SECONDS_TEMPO)
+        expect(calculateDutchRetryWaitSeconds(ChainId.TEMPO, retryCount)).toEqual(MIN_RETRY_WAIT_SECONDS)
       }
     })
 
     it('keeps the floor across the exponential backoff range', () => {
       for (const retryCount of [301, 350, 400, 450, 500]) {
         const response = calculateDutchRetryWaitSeconds(ChainId.TEMPO, retryCount)
-        expect(response).toBeGreaterThanOrEqual(MIN_RETRY_WAIT_SECONDS_TEMPO)
+        expect(response).toBeGreaterThanOrEqual(MIN_RETRY_WAIT_SECONDS)
       }
     })
   })
 
-  describe('non-Tempo chains are unaffected by the Tempo floor', () => {
-    // The Tempo floor must NOT change behavior for chains whose AVERAGE_BLOCK_TIME
-    // is already >= 1s. These expectations match the pre-floor base math.
-    it('returns AVERAGE_BLOCK_TIME for Arbitrum during the first-hour polling phase (1s, not 2s)', () => {
+  describe('chains with AVERAGE_BLOCK_TIME >= floor are unaffected', () => {
+    it('returns AVERAGE_BLOCK_TIME for Arbitrum during the first-hour polling phase (1s)', () => {
       for (const retryCount of [1, 50, 150, 299, 300]) {
         expect(calculateDutchRetryWaitSeconds(ChainId.ARBITRUM_ONE, retryCount)).toEqual(1)
       }
     })
 
-    it('returns AVERAGE_BLOCK_TIME for Unichain during the first-hour polling phase (1s, not 2s)', () => {
+    it('returns AVERAGE_BLOCK_TIME for Unichain during the first-hour polling phase (1s)', () => {
       for (const retryCount of [1, 50, 150, 299, 300]) {
         expect(calculateDutchRetryWaitSeconds(ChainId.UNICHAIN, retryCount)).toEqual(1)
       }