Address cursor bot review findings

- swapter: buffer each page and only advance latestIsoDate on clean completion, so
  a mid-page throw no longer re-appends rows (duplicate orderIds / Couch _id conflicts)
  and an error-driven exit keeps the pre-run progress marker instead of skipping older
  unfetched pages (High + Medium).
- swapter: relax strict cleaners on fields that never feed StandardTx (info.type/link,
  deposit/withdraw.network, the partner block) to asMaybe so an unexpected encoding
  degrades that field instead of aborting the page (Medium).
- swapter: add the missing demo partners.ts entry so getPartnerIds surfaces it (Medium).
- nexchange: switch non-critical cleaners (address, txid, countryCode, nextCursor,
  network, contract_address) from asOptional to asMaybe so a single odd encoding
  degrades that field rather than aborting the query block (Medium).
- nym: make apiKey optional and return [] on a null/empty key so an unprovisioned
  partner entry no-ops like the other couch plugins instead of erroring every cycle (Medium).
- nym test: replace live-derived addresses and txids with clearly-synthetic placeholders;
  only field structure and amount math are load-bearing (High, privacy).

Author: j0ntz

src/demo/partners.ts

@@ -133,6 +133,10 @@ export default {
     type: 'swap',
     color: '#E35852'
   },
+  swapter: {
+    type: 'swap',
+    color: '#00C9A7'
+  },
   swapuz: {
     type: 'swap',
     color: '#56BD7C'

src/partners/nexchange.ts

@@ -2,6 +2,7 @@ import {
   asArray,
   asBoolean,
   asEither,
+  asMaybe,
   asNull,
   asObject,
   asOptional,
@@ -30,8 +31,8 @@ const CURRENCY_URL = 'https://api.n.exchange/en/api/v2/currency/'
 const asNexchangeTransfer = asObject({
   currency: asString,
   amount: asString,
-  address: asOptional(asEither(asString, asNull), null),
-  txid: asOptional(asEither(asString, asNull), null)
+  address: asMaybe(asEither(asString, asNull), null),
+  txid: asMaybe(asEither(asString, asNull), null)
 })
 
 const asNexchangeOrder = asObject({
@@ -40,12 +41,12 @@ const asNexchangeOrder = asObject({
   createdAt: asString,
   deposit: asNexchangeTransfer,
   payout: asNexchangeTransfer,
-  countryCode: asOptional(asEither(asString, asNull), null)
+  countryCode: asMaybe(asEither(asString, asNull), null)
 })
 
 const asNexchangeOrdersResponse = asObject({
   orders: asArray(asUnknown),
-  nextCursor: asOptional(asEither(asString, asNull), null),
+  nextCursor: asMaybe(asEither(asString, asNull), null),
   hasMore: asBoolean
 })
 
@@ -55,9 +56,9 @@ const asNexchangeOrdersResponse = asObject({
 const asNexchangeCurrencyMeta = asObject({
   code: asString,
   is_fiat: asOptional(asBoolean, false),
-  network: asOptional(asEither(asString, asNull), null),
-  contract_address: asOptional(asEither(asString, asNull), null),
-  common_symbol: asOptional(asEither(asString, asNull), null)
+  network: asMaybe(asEither(asString, asNull), null),
+  contract_address: asMaybe(asEither(asString, asNull), null),
+  common_symbol: asMaybe(asEither(asString, asNull), null)
 })
 
 const asNexchangeCurrencyList = asArray(asNexchangeCurrencyMeta)

src/partners/nym.ts

@@ -85,7 +85,9 @@ export const asNymPluginParams = asObject({
   apiKeys: asObject({
     // Partner-issued reporting key, human/ops-set in production CouchDB
     // (reports_apps partnerIds.nymswap.apiKeys). Never fetched or set by code.
-    apiKey: asString
+    // Optional so an unprovisioned partner entry no-ops (returns []) instead of
+    // throwing every query cycle, matching the other couch plugins.
+    apiKey: asMaybe(asString)
   })
 })
 
@@ -206,6 +208,13 @@ export async function queryNym(
   const { apiKey } = apiKeys
   let { latestIsoDate } = settings
 
+  // A null/empty apiKey means the partner entry is unprovisioned. Skip silently
+  // (return no transactions) rather than erroring, so an unconfigured nymswap
+  // key does not fail every query cycle.
+  if (apiKey == null || apiKey === '') {
+    return { settings: { latestIsoDate }, transactions: [] }
+  }
+
   // Progress persisted before this run. Only advanced past when the full cursor
   // walk COMPLETES (nextCursor null); on an error-driven early exit we keep this
   // value so a partial fetch never skips orders we did not page through. This

src/partners/swapter.ts

@@ -33,25 +33,30 @@ const asSwapterStatus = asMaybe(
   'other'
 )
 
+// Only the fields consumed by processSwapterTx are required strictly. Fields
+// that never feed StandardTx (info.type, info.link, deposit/withdraw.network,
+// the partner block) use asMaybe so an unexpected encoding degrades that field
+// instead of throwing out of the whole page (which would abort or, with the
+// retry loop, re-fetch the page).
 const asSwapterTx = asObject({
   info: asObject({
     uid: asString,
     status: asSwapterStatus,
-    type: asString,
-    link: asString,
+    type: asMaybe(asString),
+    link: asMaybe(asString),
     equivalent: asNumber
   }),
   deposit: asObject({
     coin: asString,
-    network: asString,
+    network: asMaybe(asString),
     amount: asNumber,
     actual: asMaybe(asNumber),
     address: asString,
     memo: asMaybe(asString)
   }),
   withdraw: asObject({
     coin: asString,
-    network: asString,
+    network: asMaybe(asString),
     amount: asNumber,
     address: asString,
     memo: asMaybe(asString)
@@ -64,13 +69,17 @@ const asSwapterTx = asObject({
     success: asMaybe(asNumber),
     overdue: asMaybe(asNumber)
   }),
-  partner: asObject({
-    name: asString,
-    profit: asObject({
-      amount: asNumber,
-      percent: asNumber
+  partner: asMaybe(
+    asObject({
+      name: asMaybe(asString),
+      profit: asMaybe(
+        asObject({
+          amount: asMaybe(asNumber),
+          percent: asMaybe(asNumber)
+        })
+      )
     })
-  })
+  )
 })
 
 const asSwapterResult = asObject({
@@ -105,7 +114,7 @@ export const querySwapter = async (
   const { log } = pluginParams
   const { settings, apiKeys } = asStandardPluginParams(pluginParams)
   const { apiKey } = apiKeys
-  let latestIsoDate =
+  const latestIsoDate =
     typeof settings.latestIsoDate === 'string'
       ? settings.latestIsoDate
       : new Date(0).toISOString()
@@ -115,6 +124,13 @@ export const querySwapter = async (
   }
 
   const standardTxs: StandardTx[] = []
+  // Preserve the pre-run progress marker. latestIsoDate only advances once
+  // pagination completes cleanly; if retries are exhausted mid-run we return
+  // the original marker so the next cycle re-fetches the unfinished window
+  // rather than skipping older, never-fetched pages.
+  const startIsoDate = latestIsoDate
+  let newLatestIsoDate = latestIsoDate
+  let completed = false
 
   let previousTimestamp = new Date(latestIsoDate).getTime() - QUERY_LOOKBACK
   if (previousTimestamp < 0) previousTimestamp = 0
@@ -150,22 +166,32 @@ export const querySwapter = async (
       const result = asSwapterResult(await response.json())
       const txs = result.data
 
-      if (txs.length === 0) break
+      if (txs.length === 0) {
+        completed = true
+        break
+      }
 
+      // Buffer this page so a mid-page throw is retried idempotently: the
+      // buffer is discarded on error, so already-processed rows are never
+      // appended twice (which would create duplicate orderIds and Couch _id
+      // conflicts on bulk insert).
+      const pageTxs: StandardTx[] = []
       for (const rawTx of txs) {
         const standardTx = processSwapterTx(rawTx, pluginParams)
-
-        standardTxs.push(standardTx)
-
-        if (standardTx.isoDate > latestIsoDate) {
-          latestIsoDate = standardTx.isoDate
+        pageTxs.push(standardTx)
+        if (standardTx.isoDate > newLatestIsoDate) {
+          newLatestIsoDate = standardTx.isoDate
         }
       }
+      standardTxs.push(...pageTxs)
 
-      log(`Swapter page ${page} latestIsoDate ${latestIsoDate}`)
+      log(`Swapter page ${page} latestIsoDate ${newLatestIsoDate}`)
 
       const loaded = page * LIMIT
-      if (loaded >= result.total) break
+      if (loaded >= result.total) {
+        completed = true
+        break
+      }
 
       page++
       retry = 0
@@ -183,7 +209,7 @@ export const querySwapter = async (
   }
 
   return {
-    settings: { latestIsoDate },
+    settings: { latestIsoDate: completed ? newLatestIsoDate : startIsoDate },
     transactions: standardTxs
   }
 }

test/nym.test.ts

@@ -3,10 +3,13 @@ import { describe, it } from 'mocha'
 
 import { processNymTx } from '../src/partners/nym'
 
-// Fixtures mirror real EdgeTransactionRecord payloads captured from NYM's live
-// GET /api/partner/v1/reports/transactions endpoint. Amounts are native-unit
-// strings; processNymTx converts them to major units via the asset decimals
-// (DEFAULT_DECIMALS when no live map is passed).
+// Fixtures follow the shape of NYM's GET /api/partner/v1/reports/transactions
+// payloads. Addresses and txids are SYNTHETIC placeholders (never live
+// user-linked identifiers); only the field structure and the native-unit amount
+// math are load-bearing. processNymTx converts native-unit amount strings to
+// major units via the asset decimals (DEFAULT_DECIMALS when no live map is
+// passed). The USDT contract address in the decimals-map case is the public
+// canonical USDT token contract, not user data.
 describe('processNymTx', function() {
   it('maps a completed order to a StandardTx with major-unit amounts', function() {
     const rawTx = {
@@ -25,12 +28,12 @@ describe('processNymTx', function() {
       destinationCurrencyCode: 'NYM',
       destinationAmount: '1633042311', // 1633.042311 NYM (6 decimals)
       destinationEvmChainId: null,
-      payinAddress: '0x84F2089CBa3c9680F301bEd56C82e108a6Ab416a',
-      payoutAddress: 'n1fj7fapafrrjxgf8p8qpk0sles7nt8230clvamt',
+      payinAddress: '0x1111111111111111111111111111111111111111',
+      payoutAddress: 'n1exampledepositaddr00000000000000000000',
       payinTxid:
-        '0xb78ecf0e0a9e44afd030d2f74cbc9f8e3a10fef09559794363b328fac90702df',
+        '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
       payoutTxid:
-        'DAB0D9F9531464D687C3E5993B1A5D7645622CAF055CEB96BDFDA1283CF29151'
+        'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB'
     }
 
     const standardTx = processNymTx(rawTx)
@@ -41,13 +44,13 @@ describe('processNymTx', function() {
     expect(standardTx.depositCurrency).to.equal('ETH')
     expect(standardTx.depositAmount).to.equal(0.0158998)
     expect(standardTx.depositAddress).to.equal(
-      '0x84F2089CBa3c9680F301bEd56C82e108a6Ab416a'
+      '0x1111111111111111111111111111111111111111'
     )
     expect(standardTx.depositTxid).to.equal(rawTx.payinTxid)
     expect(standardTx.payoutCurrency).to.equal('NYM')
     expect(standardTx.payoutAmount).to.equal(1633.042311)
     expect(standardTx.payoutAddress).to.equal(
-      'n1fj7fapafrrjxgf8p8qpk0sles7nt8230clvamt'
+      'n1exampledepositaddr00000000000000000000'
     )
     expect(standardTx.payoutTxid).to.equal(rawTx.payoutTxid)
     // Timestamp keys off createdDate (completedDate is null here).
@@ -66,12 +69,12 @@ describe('processNymTx', function() {
         sourceCurrencyCode: 'USDT',
         sourceTokenId: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
         sourceAmount: '32468489', // 32.468489 USDT (6 decimals)
-        payinAddress: '0x84F2089CBa3c9680F301bEd56C82e108a6Ab416a',
+        payinAddress: '0x1111111111111111111111111111111111111111',
         payinTxid: null,
         destinationCurrencyCode: 'NYM',
         destinationTokenId: null,
         destinationAmount: '1901660695', // 1901.660695 NYM (6 decimals)
-        payoutAddress: 'n1uyqr62rpsn5wjxux74h8lrdypt6pnxgqltds2g',
+        payoutAddress: 'n1examplepayoutaddr000000000000000000000',
         payoutTxid: null
       },
       {