Harden Sideshift order processing against unmapped coins

Map bsv (Bitcoin SV) to the bitcoinsv plugin id and add BSV-bsv to the
delisted coins map so historical BSV orders resolve instead of throwing
"Unknown network: bsv".

Also skip and log a single unprocessable order rather than letting it
abort the page. A throw left the per-account cursor stuck before the bad
order, so the account retried then gave up every cycle forever. The
dual-account change makes from-epoch backfills routine, which makes
hitting such an order far more likely.

Author: j0ntz

src/partners/sideshift.ts

@@ -36,6 +36,7 @@ const SIDESHIFT_NETWORK_TO_PLUGIN_ID: ChainNameToPluginIdMapping = {
   bitcoin: 'bitcoin',
   bitcoincash: 'bitcoincash',
   bsc: 'binancesmartchain',
+  bsv: 'bitcoinsv',
   cardano: 'cardano',
   cosmos: 'cosmoshub',
   dash: 'dash',
@@ -72,6 +73,7 @@ const ASSET_NAME_OVERRIDES: Record<string, string> = {
 // Delisted coins that are no longer in the SideShift API
 // Map: `${coin}-${network}` -> contract address (null for native gas tokens)
 const DELISTED_COINS: Record<string, string | null> = {
+  'BSV-bsv': null, // Native gas token
   'BUSD-bsc': '0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56',
   'FTM-fantom': null, // Native gas token
   'MATIC-ethereum': '0x7d1afa7b718fb893db30a3abc0cfc608aacfebb0',
@@ -337,7 +339,20 @@ async function querySideshiftAccount(
         break
       }
       for (const rawTx of orders) {
-        const standardTx = await processOrder(rawTx)
+        let standardTx: StandardTx
+        try {
+          standardTx = await processOrder(rawTx)
+        } catch (e) {
+          // A single unprocessable order (e.g. a coin or network missing from
+          // 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)}`
+          )
+          continue
+        }
         standardTxs.push(standardTx)
         if (standardTx.isoDate > latestIsoDate) {
           latestIsoDate = standardTx.isoDate

test/sideshift.test.ts

@@ -259,4 +259,44 @@ describe('querySideshift dual-account merge', function() {
       new Date('2025-03-01T00:00:00.000Z').getTime() - QUERY_LOOKBACK
     )
   })
+
+  it('skips an unprocessable order instead of stalling the account', async function() {
+    // A coin or network missing from the plugin maps makes processing throw.
+    // The account must drop that order, keep the rest, and advance its cursor
+    // past the bad order rather than retrying-then-giving-up forever.
+    const { fetchOrders } = makeFakeFetcher({
+      PRIMARY: [
+        { orderId: 'good1', isoDate: '2025-06-01T00:00:00.000Z' },
+        { orderId: 'bad', isoDate: '2025-06-02T00:00:00.000Z' },
+        { orderId: 'good2', isoDate: '2025-06-03T00:00:00.000Z' }
+      ]
+    })
+    const throwingProcess = async (rawTx: unknown): Promise<StandardTx> => {
+      const order = rawTx as RawOrder
+      if (order.orderId === 'bad') throw new Error('Unknown network: bsv')
+      return makeTx(order.orderId, order.isoDate)
+    }
+    const result = await querySideshift(
+      {
+        apiKeys: {
+          sideshiftAffiliateId: 'PRIMARY',
+          sideshiftAffiliateSecret: 'sprimary'
+        },
+        settings: {},
+        log: noopLog
+      },
+      fetchOrders,
+      throwingProcess
+    )
+
+    // The bad order is dropped; the good ones survive.
+    expect(result.transactions.map(tx => tx.orderId)).to.deep.equal([
+      'good1',
+      'good2'
+    ])
+    // Cursor advanced to the newest good order, not stuck before 'bad'.
+    expect(result.settings.accounts.PRIMARY).to.equal(
+      '2025-06-03T00:00:00.000Z'
+    )
+  })
 })