fix: preserve subscription casing on duplicate cache key to prevent feed death

  When two requests share the same normalised cache key but differ in casing
  (e.g. USDe/USD and usde/usd), ExpiringSortedSet.add() was overwriting the
  stored params with the new casing. This caused StreamingTransport's
  JSON.stringify diff to see a spurious change on the next background execute,
  triggering an unnecessary unsubscribe then resubscribe. Because sendMessages
  sends subscribes before unsubscribes, a case-insensitive provider would start
  the feed then immediately kill it — and because localSubscriptions was then set
  to desiredSubs, no diff would fire again, leaving the feed permanently dead and
  both request variants returning 504 after cache expiry.

  Fix: when a key already exists in ExpiringSortedSet, only refresh the TTL and
  keep the original value (first-writer-wins). Emit a warning when the incoming
  value differs from the stored one, as this indicates inconsistent request casing
  that may cause issues with case-sensitive providers.

Author: alecgard

src/util/subscription-set/expiring-sorted-set.ts

@@ -32,8 +32,23 @@ export class ExpiringSortedSet<T> implements SubscriptionSet<T> {
   add(value: T, ttl: number, key: string) {
     let node = this.map.get(key)
     if (node) {
+      if (JSON.stringify(value) !== JSON.stringify(node.data.value)) {
+        logger.warn(
+          `Subscription set received a value for key "${key}" that differs from the stored value. ` +
+            `Keeping the original value to avoid unnecessary subscription churn. ` +
+            `This indicates requests are using inconsistent parameter casing - ` +
+            `stored: ${JSON.stringify(node.data.value)}, incoming: ${JSON.stringify(value)}`,
+        )
+      }
       node.data = {
-        value,
+        // Preserve the existing value rather than overwriting it. The key is the
+        // normalised cache key (e.g. lowercased), so two entries that share a key
+        // represent the same logical subscription. Overwriting the value with a
+        // differently-cased variant would cause the streaming transport's
+        // JSON.stringify-based diff to see a change, triggering an
+        // unnecessary unsubscribe + resubscribe cycle that can permanently kill
+        // the provider feed. Only the TTL needs refreshing here.
+        value: node.data.value,
         expirationTimestamp: Date.now() + ttl,
       }
       this.moveToTail(node)