Advance Sideshift cursor past skipped orders to prevent stall

Author: j0ntz

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Unreleased
 
 - changed: Query both old and new Sideshift affiliate accounts and merge completed orders to preserve full shift history across an affiliate-account rotation
+- changed: Sideshift orders that fail processing (e.g. unmapped coin or network) are now skipped and logged with their full raw payload instead of stalling the account; a skipped order is not re-fetched once the cursor advances past it
 - changed: Add signature header support to Exolix
 - changed: Add index for orderId
 - changed: Add EVM chainId, pluginId, and tokenId fields to StandardTx

src/partners/sideshift.ts

@@ -275,6 +275,17 @@ export function getSideshiftAccounts(
     }
   ]
 
+  // A half-configured pair means the operator intended a second account but
+  // it would be silently skipped, so fail loudly instead.
+  if (
+    (sideshiftAffiliateIdNew != null) !==
+    (sideshiftAffiliateSecretNew != null)
+  ) {
+    throw new Error(
+      'Sideshift config error: sideshiftAffiliateIdNew and sideshiftAffiliateSecretNew must both be set'
+    )
+  }
+
   if (
     sideshiftAffiliateIdNew != null &&
     sideshiftAffiliateSecretNew != null &&
@@ -309,6 +320,26 @@ 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
+  try {
+    return smartIsoDateFromTimestamp(parsed.createdAt).isoDate
+  } catch {
+    // This helper runs inside the skip handler after processOrder already
+    // threw. If createdAt itself is the unparseable part, throwing here again
+    // would escape the skip logic and stall the account on this order forever,
+    // so treat it the same as a missing createdAt.
+    return undefined
+  }
+}
+
 // 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 +378,34 @@ 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.
-          log.warn(
-            `${account.affiliateId} skipping unprocessable order: ${String(e)}`
+          // 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.
+          // Once the cursor advances past a skipped order it is never
+          // re-fetched (orders are queried with since=cursor), so include the
+          // full raw order in the log: it is the only surviving copy from
+          // which the record can be recovered after the mapping is fixed.
+          log.error(
+            `${account.affiliateId} skipping unprocessable order: ${String(
+              e
+            )} raw=${JSON.stringify(rawTx)}`
           )
+          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

@@ -15,6 +15,9 @@ interface FakeAccount {
 interface RawOrder {
   orderId: string
   isoDate: string
+  // Only set by tests exercising the skip handler's cursor advance, which
+  // reads createdAt from the raw order the way the live API shapes it.
+  createdAt?: string
 }
 interface Captured {
   affiliateId: string
@@ -129,6 +132,27 @@ describe('getSideshiftAccounts', function() {
       { affiliateId: 'SAME', affiliateSecret: 'sprimary' }
     ])
   })
+
+  it('throws when only one of the added-account fields is configured', function() {
+    // A half-configured pair means the operator intended a second account.
+    // Silently querying only the primary would hide the misconfiguration.
+    expect(() =>
+      getSideshiftAccounts({
+        sideshiftAffiliateId: 'PRIMARY',
+        sideshiftAffiliateSecret: 'sprimary',
+        sideshiftAffiliateIdNew: 'ADDED',
+        sideshiftAffiliateSecretNew: undefined
+      })
+    ).to.throw('Sideshift config error')
+    expect(() =>
+      getSideshiftAccounts({
+        sideshiftAffiliateId: 'PRIMARY',
+        sideshiftAffiliateSecret: 'sprimary',
+        sideshiftAffiliateIdNew: undefined,
+        sideshiftAffiliateSecretNew: 'sadded'
+      })
+    ).to.throw('Sideshift config error')
+  })
 })
 
 describe('querySideshift dual-account merge', function() {
@@ -299,4 +323,94 @@ 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
+    )
+  })
+
+  it('skips an order whose createdAt is unparseable instead of stalling', async function() {
+    // When processOrder throws BECAUSE createdAt is malformed, the skip
+    // handler re-reads createdAt to advance the cursor. That second read must
+    // not throw again, or the error escapes the skip logic into the retry
+    // path and the account stalls on this order forever.
+    const { fetchOrders } = makeFakeFetcher({
+      PRIMARY: [
+        { orderId: 'good1', isoDate: '2025-06-01T00:00:00.000Z' },
+        {
+          orderId: 'bad-date',
+          isoDate: 'not-a-real-date',
+          createdAt: 'not-a-real-date'
+        },
+        { orderId: 'good2', isoDate: '2025-06-03T00:00:00.000Z' }
+      ]
+    })
+    const dateStrictProcess = async (rawTx: unknown): Promise<StandardTx> => {
+      const order = rawTx as RawOrder
+      const time = new Date(order.isoDate).getTime()
+      if (Number.isNaN(time)) {
+        throw new Error(`Invalid createdAt: ${order.isoDate}`)
+      }
+      return makeTx(order.orderId, order.isoDate)
+    }
+    const result = await querySideshift(
+      {
+        apiKeys: {
+          sideshiftAffiliateId: 'PRIMARY',
+          sideshiftAffiliateSecret: 'sprimary'
+        },
+        settings: {},
+        log: noopLog
+      },
+      fetchOrders,
+      dateStrictProcess
+    )
+
+    expect(result.transactions.map(tx => tx.orderId)).to.deep.equal([
+      'good1',
+      'good2'
+    ])
+    expect(result.settings.accounts.PRIMARY).to.equal(
+      '2025-06-03T00:00:00.000Z'
+    )
+  })
 })