Advance Sideshift cursor past skipped orders to prevent stall

Author: j0ntz

src/partners/sideshift.ts

@@ -309,6 +309,18 @@ const defaultFetchSideshiftOrders: FetchSideshiftOrders = async (
   return asSideshiftResult(jsonObj)
 }
 
+// Reads only the timestamp from a raw order. Used to advance an account's
+// cursor past an order that processOrder rejects (e.g. an unmapped coin or
+// network), so a page of only unprocessable orders can never stall the query
+// window. Returns undefined when the raw order has no usable createdAt.
+const asRawOrderDate = asMaybe(asObject({ createdAt: asString }))
+
+const rawOrderIsoDate = (rawTx: unknown): string | undefined => {
+  const parsed = asRawOrderDate(rawTx)
+  if (parsed == null) return undefined
+  return smartIsoDateFromTimestamp(parsed.createdAt).isoDate
+}
+
 // Queries the completed orders for a single affiliate account, advancing its
 // own cursor. Mirrors the original per-account query/signature/retry/time-block
 // behavior exactly; only the fetch + per-order processing are abstracted so the
@@ -347,18 +359,28 @@ async function querySideshiftAccount(
           // the plugin maps) must not stall the account. Without skipping, the
           // throw aborts the page, the cursor never advances past it, and the
           // account retries-then-gives-up every cycle forever. Log the gap so
-          // it can be mapped, then move on.
+          // it can be mapped, then advance the cursor past this order's own
+          // timestamp so the window still moves forward even when an entire
+          // page is unprocessable.
           log.warn(
             `${account.affiliateId} skipping unprocessable order: ${String(e)}`
           )
+          const skippedIsoDate = rawOrderIsoDate(rawTx)
+          if (skippedIsoDate != null && skippedIsoDate > latestIsoDate) {
+            latestIsoDate = skippedIsoDate
+          }
           continue
         }
         standardTxs.push(standardTx)
         if (standardTx.isoDate > latestIsoDate) {
           latestIsoDate = standardTx.isoDate
         }
       }
-      startTime = new Date(latestIsoDate).getTime()
+      const advancedTime = new Date(latestIsoDate).getTime()
+      // Guarantee forward progress even if every order in this block was skipped
+      // without a usable timestamp, so the window can never spin on the same
+      // startTime until the engine timeout.
+      startTime = advancedTime > startTime ? advancedTime : endTime
       log(`${account.affiliateId} latestIsoDate ${latestIsoDate}`)
       if (endTime > now) {
         break

test/sideshift.test.ts

@@ -299,4 +299,48 @@ describe('querySideshift dual-account merge', function() {
       '2025-06-03T00:00:00.000Z'
     )
   })
+
+  it('advances past a page of only unprocessable orders instead of spinning forever', async function() {
+    // Mirrors the live API re-serving the same window: a page containing ONLY
+    // unprocessable orders keeps coming back until the cursor advances past
+    // their timestamps. Without advancing the cursor on skip, the loop spins on
+    // the same startTime until the engine timeout. makeFakeFetcher cannot model
+    // this (it serves once then empty), so use a startTime-gated fetcher that
+    // aborts loudly if the loop fails to terminate.
+    const badDate = '2025-04-10T00:00:00.000Z'
+    const badTime = new Date(badDate).getTime()
+    let fetchCount = 0
+    const fetchOrders = async (
+      account: FakeAccount,
+      startTime: number
+    ): Promise<unknown[]> => {
+      fetchCount++
+      if (fetchCount > 50) throw new Error('query loop did not terminate')
+      if (startTime <= badTime) return [{ id: 'bad', createdAt: badDate }]
+      return []
+    }
+    const alwaysThrows = async (): Promise<StandardTx> => {
+      throw new Error('Unknown coin: FOO on network bar')
+    }
+
+    const result = await querySideshift(
+      {
+        apiKeys: {
+          sideshiftAffiliateId: 'PRIMARY',
+          sideshiftAffiliateSecret: 'sprimary'
+        },
+        settings: {},
+        log: noopLog
+      },
+      fetchOrders,
+      alwaysThrows
+    )
+
+    // No orders are reportable, but the account still advances its cursor past
+    // the unprocessable window and the loop terminates.
+    expect(result.transactions).to.deep.equal([])
+    expect(new Date(result.settings.accounts.PRIMARY).getTime()).to.be.at.least(
+      badTime
+    )
+  })
 })