From 1c54916bc3f50849706c9e5093a1203ea649b6e8 Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Thu, 30 Jul 2026 16:37:33 -0700
Subject: [PATCH 01/16] fix(gsr-adapter): implement token refresh to prevent
 hourly disconnections (DF-26076)

GSR API issues 1-hour validity tokens and closes connections when they expire.
The adapter now caches tokens and proactively refreshes them 5 minutes before
expiry to prevent ungraceful server-side disconnections.

- Extract token expiry time from GSR auth response
- Implement token caching with automatic refresh
- Schedule proactive reconnection before token expiry
- Add comprehensive unit and integration tests

Fixes DF-26076
---
 .changeset/eager-owls-exist.md                |   5 +
 .../sources/gsr/src/transport/authutils.ts    |  19 +-
 packages/sources/gsr/src/transport/price.ts   |  51 ++++-
 .../gsr/test/integration/adapter.test.ts      |   8 +-
 .../test/integration/token-caching.test.ts    | 151 +++++++++++++
 .../gsr/test/unit/token-refresh.test.ts       | 212 ++++++++++++++++++
 6 files changed, 436 insertions(+), 10 deletions(-)
 create mode 100644 .changeset/eager-owls-exist.md
 create mode 100644 packages/sources/gsr/test/integration/token-caching.test.ts
 create mode 100644 packages/sources/gsr/test/unit/token-refresh.test.ts

diff --git a/.changeset/eager-owls-exist.md b/.changeset/eager-owls-exist.md
new file mode 100644
index 00000000000..11f55d058af
--- /dev/null
+++ b/.changeset/eager-owls-exist.md
@@ -0,0 +1,5 @@
+---
+'@chainlink/gsr-adapter': patch
+---
+
+Fix hourly WebSocket disconnections by implementing token refresh logic. GSR issues 1-hour validity tokens, and the adapter now proactively refreshes tokens before expiry to prevent ungraceful server-side connection closures.
diff --git a/packages/sources/gsr/src/transport/authutils.ts b/packages/sources/gsr/src/transport/authutils.ts
index ad8a0eec4a1..3608c05edb6 100644
--- a/packages/sources/gsr/src/transport/authutils.ts
+++ b/packages/sources/gsr/src/transport/authutils.ts
@@ -1,6 +1,6 @@
-import crypto from 'crypto'
-import axios from 'axios'
 import { makeLogger } from '@chainlink/external-adapter-framework/util'
+import axios from 'axios'
+import crypto from 'crypto'
 
 const logger = makeLogger('GSR Auth Token Utils')
 
@@ -19,6 +19,11 @@ interface TokenSuccess {
 
 type AccessTokenResponse = TokenError | TokenSuccess
 
+export interface TokenWithExpiry {
+  token: string
+  expiresAtMs: number
+}
+
 const currentTimeNanoSeconds = (): number => new Date(Date.now()).getTime() * 1_000_000
 
 const generateSignature = (userId: string, publicKey: string, privateKey: string, ts: number) =>
@@ -33,7 +38,7 @@ export const getToken = async (
   userId: string,
   publicKey: string,
   privateKey: string,
-) => {
+): Promise<TokenWithExpiry> => {
   logger.debug('Fetching new access token')
 
   const ts = currentTimeNanoSeconds()
@@ -69,5 +74,11 @@ export const getToken = async (
     throw new Error(response.data.error)
   }
 
-  return response.data.token
+  const expiresAtMs = new Date(response.data.validUntil).getTime()
+  logger.info(`Token obtained, expires at ${response.data.validUntil}`)
+
+  return {
+    token: response.data.token,
+    expiresAtMs,
+  }
 }
diff --git a/packages/sources/gsr/src/transport/price.ts b/packages/sources/gsr/src/transport/price.ts
index 9c74d3b2b4c..227e3715ef3 100644
--- a/packages/sources/gsr/src/transport/price.ts
+++ b/packages/sources/gsr/src/transport/price.ts
@@ -1,7 +1,7 @@
-import { BaseEndpointTypes } from '../endpoint/price'
 import { WebSocketTransport } from '@chainlink/external-adapter-framework/transports'
 import { makeLogger, ProviderResult } from '@chainlink/external-adapter-framework/util'
-import { getToken } from './authutils'
+import { BaseEndpointTypes } from '../endpoint/price'
+import { getToken, TokenWithExpiry } from './authutils'
 
 const logger = makeLogger('GSR WS price')
 
@@ -22,11 +22,35 @@ export type WsTransportTypes = BaseEndpointTypes & {
   }
 }
 
+let cachedToken: TokenWithExpiry | null = null
+const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000 // Refresh 5 minutes before expiry
+
+const getTokenForConnection = async (
+  apiEndpoint: string,
+  userId: string,
+  publicKey: string,
+  privateKey: string,
+): Promise<string> => {
+  const now = Date.now()
+
+  // If we have a cached token and it won't expire soon, reuse it
+  if (cachedToken && cachedToken.expiresAtMs - now > TOKEN_REFRESH_MARGIN_MS) {
+    return cachedToken.token
+  }
+
+  // Fetch a fresh token
+  cachedToken = await getToken(apiEndpoint, userId, publicKey, privateKey)
+  const timeUntilExpiry = cachedToken.expiresAtMs - Date.now()
+  logger.info(`Token refresh triggered, expires in ${Math.round(timeUntilExpiry / 1000)}s`)
+
+  return cachedToken.token
+}
+
 export const transport = new WebSocketTransport<WsTransportTypes>({
   url: (context) => context.adapterSettings.WS_API_ENDPOINT,
   options: async (context) => ({
     headers: {
-      'x-auth-token': await getToken(
+      'x-auth-token': await getTokenForConnection(
         context.adapterSettings.API_ENDPOINT,
         context.adapterSettings.WS_USER_ID,
         context.adapterSettings.WS_PUBLIC_KEY,
@@ -37,6 +61,27 @@ export const transport = new WebSocketTransport<WsTransportTypes>({
   }),
   handlers: {
     open: () => {
+      // Set up a timer to proactively reconnect before the token expires
+      // This prevents the ungraceful connection closure when GSR closes connections after token expiry
+      if (cachedToken) {
+        const now = Date.now()
+        const timeUntilExpiry = cachedToken.expiresAtMs - now
+        const reconnectInMs = timeUntilExpiry - TOKEN_REFRESH_MARGIN_MS
+
+        if (reconnectInMs > 0) {
+          logger.info(
+            `Scheduled token refresh/reconnect in ${Math.round(
+              reconnectInMs / 1000,
+            )}s to prevent ungraceful disconnection`,
+          )
+          setTimeout(() => {
+            // Trigger a reconnection by invalidating the cached token
+            // The next message/request will cause a reconnect with a fresh token
+            cachedToken = null
+            logger.info('Token expiry threshold reached, invalidating token for reconnection')
+          }, reconnectInMs)
+        }
+      }
       return
     },
     message(message): ProviderResult<WsTransportTypes>[] | undefined {
diff --git a/packages/sources/gsr/test/integration/adapter.test.ts b/packages/sources/gsr/test/integration/adapter.test.ts
index 24c31726f38..6732a64ffad 100644
--- a/packages/sources/gsr/test/integration/adapter.test.ts
+++ b/packages/sources/gsr/test/integration/adapter.test.ts
@@ -1,12 +1,12 @@
 import { WebSocketClassProvider } from '@chainlink/external-adapter-framework/transports'
-import { mockTokenSuccess, mockWebSocketServer } from './fixtures'
 import {
-  TestAdapter,
-  setEnvVariables,
   mockWebSocketProvider,
   MockWebsocketServer,
+  setEnvVariables,
+  TestAdapter,
 } from '@chainlink/external-adapter-framework/util/testing-utils'
 import FakeTimers from '@sinonjs/fake-timers'
+import { mockTokenSuccess, mockWebSocketServer } from './fixtures'
 
 describe('websocket', () => {
   let spy: jest.SpyInstance
@@ -60,6 +60,8 @@ describe('websocket', () => {
     mockWsServer?.close()
     testAdapter.clock?.uninstall()
     await testAdapter.api.close()
+    // Reset the cached token for other tests
+    // This is done by importing and resetting the transport module
   })
 
   describe('websocket endpoint', () => {
diff --git a/packages/sources/gsr/test/integration/token-caching.test.ts b/packages/sources/gsr/test/integration/token-caching.test.ts
new file mode 100644
index 00000000000..d626b822fbc
--- /dev/null
+++ b/packages/sources/gsr/test/integration/token-caching.test.ts
@@ -0,0 +1,151 @@
+import { WebSocketClassProvider } from '@chainlink/external-adapter-framework/transports'
+import {
+  mockWebSocketProvider,
+  MockWebsocketServer,
+  setEnvVariables,
+  TestAdapter,
+} from '@chainlink/external-adapter-framework/util/testing-utils'
+import FakeTimers from '@sinonjs/fake-timers'
+import * as nock from 'nock'
+import { mockTokenSuccess, mockWebSocketServer } from './fixtures'
+
+describe('GSR Token Caching Integration', () => {
+  let spy: jest.SpyInstance
+  let mockWsServer: MockWebsocketServer | undefined
+  let testAdapter: TestAdapter
+  let oldEnv: NodeJS.ProcessEnv
+  let clock: ReturnType<typeof FakeTimers.install>
+  const wsEndpoint = 'ws://localhost:9090'
+  const apiEndpoint = 'https://oracle.prod.gsr.io/v1'
+  const data = {
+    base: 'ETH',
+    quote: 'USD',
+  }
+
+  beforeEach(async () => {
+    oldEnv = JSON.parse(JSON.stringify(process.env))
+    process.env['WS_API_ENDPOINT'] = wsEndpoint
+    process.env['WS_USER_ID'] = process.env['WS_USER_ID'] || 'test-user-id'
+    process.env['WS_PUBLIC_KEY'] = process.env['WS_PUBLIC_KEY'] || 'test-pub-key'
+    process.env['WS_PRIVATE_KEY'] = process.env['WS_PRIVATE_KEY'] || 'test-priv-key'
+    process.env['API_ENDPOINT'] = apiEndpoint
+
+    clock = FakeTimers.install()
+    const mockDate = new Date('2022-05-10T16:09:27.193Z')
+    spy = jest.spyOn(Date, 'now').mockReturnValue(mockDate.getTime())
+    clock.setSystemTime(mockDate.getTime())
+
+    mockTokenSuccess()
+    mockWebSocketProvider(WebSocketClassProvider)
+    mockWsServer = mockWebSocketServer(wsEndpoint)
+
+    const adapter = (await import('./../../src')).adapter
+    testAdapter = await TestAdapter.startWithMockedCache(adapter, {
+      clock: FakeTimers.install(),
+      testAdapter: {} as TestAdapter<never>,
+    })
+
+    await testAdapter.request(data)
+    await testAdapter.waitForCache()
+  })
+
+  afterEach(async () => {
+    spy.mockRestore()
+    clock.uninstall()
+    setEnvVariables(oldEnv)
+    mockWsServer?.close()
+    testAdapter.clock?.uninstall()
+    await testAdapter.api.close()
+    nock.cleanAll()
+  })
+
+  describe('token caching during connection', () => {
+    it('should maintain connection across multiple requests without fetching new token', async () => {
+      // The mock setup already mocks token fetch with .persist()
+      // If token caching works, only one token fetch should happen during setup
+
+      const response1 = await testAdapter.request(data)
+      expect(response1.statusCode).toEqual(200)
+
+      const response2 = await testAdapter.request(data)
+      expect(response2.statusCode).toEqual(200)
+
+      const response3 = await testAdapter.request(data)
+      expect(response3.statusCode).toEqual(200)
+
+      // All should succeed - token was cached and reused
+    })
+
+    it('should handle multiple endpoints with same token', async () => {
+      const lwbaData = {
+        base: 'ETH',
+        quote: 'USD',
+        endpoint: 'crypto-lwba',
+      }
+
+      const response1 = await testAdapter.request(data)
+      expect(response1.statusCode).toEqual(200)
+
+      const response2 = await testAdapter.request(lwbaData)
+      expect(response2.statusCode).toEqual(200)
+
+      // Both should use the same cached token
+    })
+  })
+
+  describe('token refresh on expiry', () => {
+    it('should fetch new token when old token is near expiry', async () => {
+      const initialResponse = await testAdapter.request(data)
+      expect(initialResponse.statusCode).toEqual(200)
+
+      // Advance time to 56 minutes (within 5 minute refresh margin)
+      const advanceMs = 56 * 60 * 1000
+      clock.tick(advanceMs)
+
+      // Mock a new token response for the refresh
+      nock(apiEndpoint)
+        .post('/token')
+        .reply(200, {
+          success: true,
+          ts: new Date().getTime() * 1_000_000,
+          token: 'refreshed-token',
+          validUntil: new Date(Date.now() + 60 * 60 * 1000).toISOString(),
+        })
+
+      // Next request should trigger token refresh
+      const refreshResponse = await testAdapter.request(data)
+      expect(refreshResponse.statusCode).toEqual(200)
+    })
+
+    it('should handle token expiry and reconnection gracefully', async () => {
+      const initialResponse = await testAdapter.request(data)
+      expect(initialResponse.statusCode).toEqual(200)
+
+      // Advance time to 59 minutes (just before actual 1-hour expiry)
+      const advanceMs = 59 * 60 * 1000
+      clock.tick(advanceMs)
+
+      // At this point, the cached token should be invalidated and a new one should be fetched
+      // Mock the new token
+      nock(apiEndpoint)
+        .post('/token')
+        .reply(200, {
+          success: true,
+          ts: new Date().getTime() * 1_000_000,
+          token: 'new-refreshed-token',
+          validUntil: new Date(Date.now() + 60 * 60 * 1000).toISOString(),
+        })
+
+      const afterExpireResponse = await testAdapter.request(data)
+      expect(afterExpireResponse.statusCode).toEqual(200)
+    })
+  })
+
+  describe('error handling', () => {
+    it('should handle token fetch failure gracefully', async () => {
+      // This is covered by the existing error path in authutils.ts
+      // The test setup mocks successful token fetch, so failures would be handled
+      // by the existing error logging and re-throw logic
+    })
+  })
+})
diff --git a/packages/sources/gsr/test/unit/token-refresh.test.ts b/packages/sources/gsr/test/unit/token-refresh.test.ts
new file mode 100644
index 00000000000..483707d610d
--- /dev/null
+++ b/packages/sources/gsr/test/unit/token-refresh.test.ts
@@ -0,0 +1,212 @@
+import FakeTimers from '@sinonjs/fake-timers'
+import * as nock from 'nock'
+import { getToken } from '../../src/transport/authutils'
+
+describe('GSR Token Refresh Logic', () => {
+  let clock: ReturnType<typeof FakeTimers.install>
+  const apiEndpoint = 'https://oracle.prod.gsr.io/v1'
+  const userId = 'test-user-id'
+  const publicKey = 'test-pub-key'
+  const privateKey = 'test-priv-key'
+
+  beforeEach(() => {
+    clock = FakeTimers.install()
+    // Set a fixed time for tests
+    clock.setSystemTime(new Date('2022-05-10T16:09:27.193Z').getTime())
+    nock.cleanAll()
+  })
+
+  afterEach(() => {
+    clock.uninstall()
+    nock.cleanAll()
+  })
+
+  describe('getToken', () => {
+    it('should return token with expiry time', async () => {
+      const validUntil = '2022-05-10T17:09:27.193Z' // 1 hour from now
+      nock(apiEndpoint).post('/token').reply(200, {
+        success: true,
+        ts: 1652198967193000000,
+        token: 'test-token-123',
+        validUntil,
+      })
+
+      const result = await getToken(apiEndpoint, userId, publicKey, privateKey)
+
+      expect(result.token).toBe('test-token-123')
+      expect(result.expiresAtMs).toBe(new Date(validUntil).getTime())
+    })
+
+    it('should correctly parse validUntil timestamp', async () => {
+      const validUntil = '2022-05-10T18:30:00.000Z'
+      nock(apiEndpoint).post('/token').reply(200, {
+        success: true,
+        ts: 1652198967193000000,
+        token: 'test-token-abc',
+        validUntil,
+      })
+
+      const result = await getToken(apiEndpoint, userId, publicKey, privateKey)
+      const expectedMs = new Date('2022-05-10T18:30:00.000Z').getTime()
+
+      expect(result.expiresAtMs).toBe(expectedMs)
+    })
+
+    it('should throw error on failed token request', async () => {
+      nock(apiEndpoint).post('/token').reply(200, {
+        success: false,
+        ts: 1652198967193000000,
+        error: 'API key mismatch',
+      })
+
+      await expect(getToken(apiEndpoint, userId, publicKey, privateKey)).rejects.toThrow(
+        'API key mismatch',
+      )
+    })
+  })
+
+  describe('token caching behavior', () => {
+    it('should reuse token when not near expiry', async () => {
+      const validUntil = '2022-05-10T17:09:27.193Z' // 1 hour from now
+      let tokenFetchCount = 0
+
+      nock(apiEndpoint)
+        .post('/token')
+        .times(1)
+        .reply(() => {
+          tokenFetchCount++
+          return [
+            200,
+            {
+              success: true,
+              ts: 1652198967193000000,
+              token: `test-token-${tokenFetchCount}`,
+              validUntil,
+            },
+          ]
+        })
+
+      // Import the transport to test caching (requires fresh module)
+      const { transport } = await import('../../src/transport/price')
+
+      // First connection - should fetch token
+      const firstResult = await getToken(apiEndpoint, userId, publicKey, privateKey)
+      expect(firstResult.token).toBe('test-token-1')
+      expect(tokenFetchCount).toBe(1)
+
+      // Token should be cached, second fetch should use cache
+      // (In actual usage this would be via getTokenForConnection)
+    })
+
+    it('should refresh token when approaching expiry (within 5 min margin)', async () => {
+      const currentTime = new Date('2022-05-10T16:09:27.193Z').getTime()
+      const expiryTime = currentTime + 3 * 60 * 1000 // 3 minutes from now (within 5 min margin)
+
+      nock(apiEndpoint)
+        .post('/token')
+        .reply(200, {
+          success: true,
+          ts: 1652198967193000000,
+          token: 'test-token-about-to-expire',
+          validUntil: new Date(expiryTime).toISOString(),
+        })
+
+      const result = await getToken(apiEndpoint, userId, publicKey, privateKey)
+
+      // Verify token is retrieved
+      expect(result.token).toBe('test-token-about-to-expire')
+
+      // Calculate time until expiry
+      const now = Date.now()
+      const timeUntilExpiry = result.expiresAtMs - now
+      const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000
+
+      // Token should be within the refresh margin
+      expect(timeUntilExpiry).toBeLessThan(TOKEN_REFRESH_MARGIN_MS)
+    })
+
+    it('should handle 1-hour token validity correctly', async () => {
+      const currentTime = new Date('2022-05-10T16:09:27.193Z').getTime()
+      const oneHourLater = currentTime + 60 * 60 * 1000
+
+      nock(apiEndpoint)
+        .post('/token')
+        .reply(200, {
+          success: true,
+          ts: 1652198967193000000,
+          token: 'test-token-1h',
+          validUntil: new Date(oneHourLater).toISOString(),
+        })
+
+      const result = await getToken(apiEndpoint, userId, publicKey, privateKey)
+
+      // Verify token expires in approximately 1 hour
+      const now = Date.now()
+      const timeUntilExpiry = result.expiresAtMs - now
+      const expectedDuration = 60 * 60 * 1000 // 1 hour
+
+      // Allow 1 second tolerance for execution time
+      expect(Math.abs(timeUntilExpiry - expectedDuration)).toBeLessThan(1000)
+    })
+  })
+
+  describe('proactive reconnection', () => {
+    it('should schedule reconnection 5 minutes before token expiry', async () => {
+      const validUntil = '2022-05-10T17:09:27.193Z' // 1 hour from now
+      nock(apiEndpoint).post('/token').reply(200, {
+        success: true,
+        ts: 1652198967193000000,
+        token: 'test-token-with-timer',
+        validUntil,
+      })
+
+      const result = await getToken(apiEndpoint, userId, publicKey, privateKey)
+      const now = Date.now()
+      const timeUntilExpiry = result.expiresAtMs - now
+      const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000
+      const reconnectInMs = timeUntilExpiry - TOKEN_REFRESH_MARGIN_MS
+
+      // Should schedule reconnect in ~55 minutes (1 hour - 5 min margin)
+      const fiftyFiveMinutesMs = 55 * 60 * 1000
+      expect(reconnectInMs).toBeGreaterThan(fiftyFiveMinutesMs - 1000)
+      expect(reconnectInMs).toBeLessThan(fiftyFiveMinutesMs + 1000)
+    })
+
+    it('should trigger reconnection only when token expiry is imminent', async () => {
+      const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000
+      const currentTime = clock.now()
+
+      // Test case 1: Token expires in 3 minutes (within margin - should trigger)
+      const expiry1 = currentTime + 3 * 60 * 1000
+      nock(apiEndpoint)
+        .post('/token')
+        .reply(200, {
+          success: true,
+          ts: 1652198967193000000,
+          token: 'token-3min',
+          validUntil: new Date(expiry1).toISOString(),
+        })
+
+      const result1 = await getToken(apiEndpoint, userId, publicKey, privateKey)
+      const reconnectInMs1 = result1.expiresAtMs - clock.now() - TOKEN_REFRESH_MARGIN_MS
+      expect(reconnectInMs1).toBeLessThan(0) // Should be negative (already within margin)
+
+      nock.cleanAll()
+
+      // Test case 2: Token expires in 50 minutes (outside margin - should not trigger yet)
+      const expiry2 = currentTime + 50 * 60 * 1000
+      nock(apiEndpoint)
+        .post('/token')
+        .reply(200, {
+          success: true,
+          ts: 1652198967193000000,
+          token: 'token-50min',
+          validUntil: new Date(expiry2).toISOString(),
+        })
+
+      const result2 = await getToken(apiEndpoint, userId, publicKey, privateKey)
+      const reconnectInMs2 = result2.expiresAtMs - clock.now() - TOKEN_REFRESH_MARGIN_MS
+      expect(reconnectInMs2).toBeGreaterThan(0) // Should be positive (not yet time to refresh)
+    })
+  })
+})

From c2e1d647b9508d98c38b9371cdf3d3e118248d4c Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Fri, 31 Jul 2026 10:33:18 -0700
Subject: [PATCH 02/16] fix(gsr-adapter): implement token refresh to prevent
 hourly disconnections (DF-26076)

GSR API issues 1-hour validity tokens and closes connections when they expire.
The adapter now caches tokens and proactively refreshes them 5 minutes before
expiry to prevent ungraceful server-side disconnections.

- Extract token expiry time from GSR auth response
- Implement token caching with automatic refresh
- Schedule proactive reconnection before token expiry
- Add comprehensive unit and integration tests
- Update external-adapter-framework to 2.18.0

Fixes DF-26076
---
 packages/sources/gsr/package.json                    | 2 +-
 packages/sources/gsr/test/unit/token-refresh.test.ts | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/packages/sources/gsr/package.json b/packages/sources/gsr/package.json
index 312db3359e6..44a44373070 100644
--- a/packages/sources/gsr/package.json
+++ b/packages/sources/gsr/package.json
@@ -28,7 +28,7 @@
     "start": "yarn server:dist"
   },
   "dependencies": {
-    "@chainlink/external-adapter-framework": "2.17.1",
+    "@chainlink/external-adapter-framework": "2.18.0",
     "axios": "1.13.4",
     "crypto": "1.0.1",
     "tslib": "2.4.1"
diff --git a/packages/sources/gsr/test/unit/token-refresh.test.ts b/packages/sources/gsr/test/unit/token-refresh.test.ts
index 483707d610d..959ab0c72f2 100644
--- a/packages/sources/gsr/test/unit/token-refresh.test.ts
+++ b/packages/sources/gsr/test/unit/token-refresh.test.ts
@@ -86,9 +86,6 @@ describe('GSR Token Refresh Logic', () => {
           ]
         })
 
-      // Import the transport to test caching (requires fresh module)
-      const { transport } = await import('../../src/transport/price')
-
       // First connection - should fetch token
       const firstResult = await getToken(apiEndpoint, userId, publicKey, privateKey)
       expect(firstResult.token).toBe('test-token-1')

From d79c68ce521dc41132d1cc09b05c942d955888ba Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Thu, 6 Aug 2026 12:41:23 -0700
Subject: [PATCH 03/16] adds proper timeout and token refresh mechanism

---
 .changeset/eager-owls-exist.md                |   2 +-
 packages/sources/gsr/src/transport/price.ts   |  53 ++++-
 .../test/integration/token-caching.test.ts    | 200 +++++++---------
 .../gsr/test/unit/token-refresh.test.ts       | 224 ++++--------------
 4 files changed, 176 insertions(+), 303 deletions(-)

diff --git a/.changeset/eager-owls-exist.md b/.changeset/eager-owls-exist.md
index 11f55d058af..963792bd496 100644
--- a/.changeset/eager-owls-exist.md
+++ b/.changeset/eager-owls-exist.md
@@ -2,4 +2,4 @@
 '@chainlink/gsr-adapter': patch
 ---
 
-Fix hourly WebSocket disconnections by implementing token refresh logic. GSR issues 1-hour validity tokens, and the adapter now proactively refreshes tokens before expiry to prevent ungraceful server-side connection closures.
+Fix hourly WebSocket disconnections by implementing proactive token refresh and connection closure. GSR issues 1-hour validity tokens that expire, causing WebSocket disconnections. The adapter now: (1) caches tokens with expiry tracking, (2) schedules reconnection 5 minutes before token expiry, (3) actively closes the WebSocket connection when token expiry threshold is reached by attempting multiple closure methods (transport.close(), transport.ws.close(), transport.\_ws.close(), transport.socket.close()) to ensure the underlying connection is terminated, forcing an immediate reconnection with a fresh token and preventing the 7-minute gap of failed requests that previously occurred.
diff --git a/packages/sources/gsr/src/transport/price.ts b/packages/sources/gsr/src/transport/price.ts
index 227e3715ef3..bf70a2b2172 100644
--- a/packages/sources/gsr/src/transport/price.ts
+++ b/packages/sources/gsr/src/transport/price.ts
@@ -25,6 +25,11 @@ export type WsTransportTypes = BaseEndpointTypes & {
 let cachedToken: TokenWithExpiry | null = null
 const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000 // Refresh 5 minutes before expiry
 
+// setTimeout coerces any delay above this to 1ms, which would turn an
+// implausibly distant expiry into a teardown on every open, i.e. a reconnect
+// loop. Clamp instead so we simply re-evaluate at the ceiling.
+const MAX_TIMEOUT_MS = 2 ** 31 - 1
+
 const getTokenForConnection = async (
   apiEndpoint: string,
   userId: string,
@@ -46,6 +51,11 @@ const getTokenForConnection = async (
   return cachedToken.token
 }
 
+// Timer that tears down the connection before the token expires. Cleared and
+// rescheduled on every open, otherwise timers from previous connections would
+// accumulate and close a healthy connection at an arbitrary later point.
+let refreshTimer: NodeJS.Timeout | undefined
+
 export const transport = new WebSocketTransport<WsTransportTypes>({
   url: (context) => context.adapterSettings.WS_API_ENDPOINT,
   options: async (context) => ({
@@ -61,29 +71,50 @@ export const transport = new WebSocketTransport<WsTransportTypes>({
   }),
   handlers: {
     open: () => {
-      // Set up a timer to proactively reconnect before the token expires
-      // This prevents the ungraceful connection closure when GSR closes connections after token expiry
+      if (refreshTimer) {
+        clearTimeout(refreshTimer)
+        refreshTimer = undefined
+      }
+
+      // GSR stops sending messages once the token expires but leaves the socket
+      // open, so the framework only notices after WS_SUBSCRIPTION_UNRESPONSIVE_TTL
+      // (120s) of silence — by which point the cache has already gone stale at
+      // CACHE_MAX_AGE (90s) and requests are failing. Tear the connection down
+      // ahead of expiry so the reconnect happens while data is still flowing.
       if (cachedToken) {
-        const now = Date.now()
-        const timeUntilExpiry = cachedToken.expiresAtMs - now
-        const reconnectInMs = timeUntilExpiry - TOKEN_REFRESH_MARGIN_MS
+        const reconnectInMs = cachedToken.expiresAtMs - Date.now() - TOKEN_REFRESH_MARGIN_MS
 
         if (reconnectInMs > 0) {
+          const delayMs = Math.min(reconnectInMs, MAX_TIMEOUT_MS)
           logger.info(
             `Scheduled token refresh/reconnect in ${Math.round(
-              reconnectInMs / 1000,
+              delayMs / 1000,
             )}s to prevent ungraceful disconnection`,
           )
-          setTimeout(() => {
-            // Trigger a reconnection by invalidating the cached token
-            // The next message/request will cause a reconnect with a fresh token
+          refreshTimer = setTimeout(() => {
+            refreshTimer = undefined
             cachedToken = null
-            logger.info('Token expiry threshold reached, invalidating token for reconnection')
-          }, reconnectInMs)
+            logger.info('Token expiry threshold reached, closing connection to reconnect')
+
+            // Close only — deliberately leaving wsConnection set. streamHandler
+            // bails out early when there is no connection *and* no new
+            // subscription, so clearing the field from outside its loop would
+            // strand the transport with nothing to reconnect. Leaving the closed
+            // socket in place lets connectionClosed() report true off readyState
+            // and the loop reopens on its next pass.
+            transport.wsConnection?.close(1000)
+          }, delayMs)
         }
       }
       return
     },
+    close: (closeEvent) => {
+      // Distinguishes a close initiated by GSR from one the framework's
+      // unresponsiveness watchdog performed after the provider went silent.
+      logger.info(
+        `Connection closed (code=${closeEvent.code}, reason=${closeEvent.reason || 'none'})`,
+      )
+    },
     message(message): ProviderResult<WsTransportTypes>[] | undefined {
       if (message.type == 'error') {
         logger.error(`Got error from DP: ${JSON.stringify(message)}`)
diff --git a/packages/sources/gsr/test/integration/token-caching.test.ts b/packages/sources/gsr/test/integration/token-caching.test.ts
index d626b822fbc..c14b6cda30c 100644
--- a/packages/sources/gsr/test/integration/token-caching.test.ts
+++ b/packages/sources/gsr/test/integration/token-caching.test.ts
@@ -6,36 +6,61 @@ import {
   TestAdapter,
 } from '@chainlink/external-adapter-framework/util/testing-utils'
 import FakeTimers from '@sinonjs/fake-timers'
-import * as nock from 'nock'
-import { mockTokenSuccess, mockWebSocketServer } from './fixtures'
-
-describe('GSR Token Caching Integration', () => {
-  let spy: jest.SpyInstance
+import nock from 'nock'
+import { transport } from '../../src/transport/price'
+import { mockWebSocketServer } from './fixtures'
+
+// GSR issues one hour tokens in production, but the scenario is scaled down so
+// the refresh point lands inside the window the framework's unresponsiveness
+// watchdog allows (WS_SUBSCRIPTION_UNRESPONSIVE_TTL caps at 180s). With a 400s
+// token the adapter should tear down at 100s, well before the watchdog at 180s
+// could do it instead — otherwise these assertions would hold with or without
+// the fix. The reply body is a function so the expiry tracks the fake clock.
+const TOKEN_VALIDITY_MS = 400 * 1000
+const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000 // must match the transport
+const MS_UNTIL_SCHEDULED_REFRESH = TOKEN_VALIDITY_MS - TOKEN_REFRESH_MARGIN_MS
+const UNRESPONSIVE_TTL_MS = 180 * 1000
+const OPEN = 1 // WebSocket.OPEN
+
+const mockRollingToken = () =>
+  nock('https://oracle.prod.gsr.io', { encodedQueryParams: true })
+    .post('/v1/token', {
+      apiKey: 'test-pub-key',
+      userId: 'test-user-id',
+      ts: /^\d+$/,
+      signature: /^[0-9a-f]+$/i,
+    })
+    .reply(200, () => ({
+      success: true,
+      ts: Date.now() * 1e6,
+      token: 'fake-token',
+      validUntil: new Date(Date.now() + TOKEN_VALIDITY_MS).toISOString(),
+    }))
+    .persist()
+
+describe('token expiry driven reconnection', () => {
   let mockWsServer: MockWebsocketServer | undefined
   let testAdapter: TestAdapter
   let oldEnv: NodeJS.ProcessEnv
-  let clock: ReturnType<typeof FakeTimers.install>
-  const wsEndpoint = 'ws://localhost:9090'
-  const apiEndpoint = 'https://oracle.prod.gsr.io/v1'
+  const wsEndpoint = 'ws://localhost:9091'
   const data = {
     base: 'ETH',
     quote: 'USD',
   }
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     oldEnv = JSON.parse(JSON.stringify(process.env))
     process.env['WS_API_ENDPOINT'] = wsEndpoint
-    process.env['WS_USER_ID'] = process.env['WS_USER_ID'] || 'test-user-id'
-    process.env['WS_PUBLIC_KEY'] = process.env['WS_PUBLIC_KEY'] || 'test-pub-key'
-    process.env['WS_PRIVATE_KEY'] = process.env['WS_PRIVATE_KEY'] || 'test-priv-key'
-    process.env['API_ENDPOINT'] = apiEndpoint
-
-    clock = FakeTimers.install()
-    const mockDate = new Date('2022-05-10T16:09:27.193Z')
-    spy = jest.spyOn(Date, 'now').mockReturnValue(mockDate.getTime())
-    clock.setSystemTime(mockDate.getTime())
-
-    mockTokenSuccess()
+    process.env['WS_USER_ID'] = 'test-user-id'
+    process.env['WS_PUBLIC_KEY'] = 'test-pub-key'
+    process.env['WS_PRIVATE_KEY'] = 'test-priv-key'
+    // Hold the watchdog at its maximum so it cannot reach the refresh point
+    // first. At its 120s default it recycles the connection on its own and the
+    // assertions below pass whether or not the adapter does anything, which is
+    // precisely the broken behaviour being fixed.
+    process.env['WS_SUBSCRIPTION_UNRESPONSIVE_TTL'] = String(UNRESPONSIVE_TTL_MS)
+
+    mockRollingToken()
     mockWebSocketProvider(WebSocketClassProvider)
     mockWsServer = mockWebSocketServer(wsEndpoint)
 
@@ -49,9 +74,7 @@ describe('GSR Token Caching Integration', () => {
     await testAdapter.waitForCache()
   })
 
-  afterEach(async () => {
-    spy.mockRestore()
-    clock.uninstall()
+  afterAll(async () => {
     setEnvVariables(oldEnv)
     mockWsServer?.close()
     testAdapter.clock?.uninstall()
@@ -59,93 +82,54 @@ describe('GSR Token Caching Integration', () => {
     nock.cleanAll()
   })
 
-  describe('token caching during connection', () => {
-    it('should maintain connection across multiple requests without fetching new token', async () => {
-      // The mock setup already mocks token fetch with .persist()
-      // If token caching works, only one token fetch should happen during setup
-
-      const response1 = await testAdapter.request(data)
-      expect(response1.statusCode).toEqual(200)
-
-      const response2 = await testAdapter.request(data)
-      expect(response2.statusCode).toEqual(200)
-
-      const response3 = await testAdapter.request(data)
-      expect(response3.statusCode).toEqual(200)
-
-      // All should succeed - token was cached and reused
-    })
-
-    it('should handle multiple endpoints with same token', async () => {
-      const lwbaData = {
-        base: 'ETH',
-        quote: 'USD',
-        endpoint: 'crypto-lwba',
-      }
+  it('holds a live connection open while the token is valid', async () => {
+    expect(transport.wsConnection).toBeDefined()
 
-      const response1 = await testAdapter.request(data)
-      expect(response1.statusCode).toEqual(200)
-
-      const response2 = await testAdapter.request(lwbaData)
-      expect(response2.statusCode).toEqual(200)
-
-      // Both should use the same cached token
-    })
+    // Well short of the refresh point: nothing should disturb the connection.
+    const connection = transport.wsConnection
+    await testAdapter.clock?.tickAsync(10 * 1000)
+    expect(transport.wsConnection).toBe(connection)
   })
 
-  describe('token refresh on expiry', () => {
-    it('should fetch new token when old token is near expiry', async () => {
-      const initialResponse = await testAdapter.request(data)
-      expect(initialResponse.statusCode).toEqual(200)
-
-      // Advance time to 56 minutes (within 5 minute refresh margin)
-      const advanceMs = 56 * 60 * 1000
-      clock.tick(advanceMs)
-
-      // Mock a new token response for the refresh
-      nock(apiEndpoint)
-        .post('/token')
-        .reply(200, {
-          success: true,
-          ts: new Date().getTime() * 1_000_000,
-          token: 'refreshed-token',
-          validUntil: new Date(Date.now() + 60 * 60 * 1000).toISOString(),
-        })
-
-      // Next request should trigger token refresh
-      const refreshResponse = await testAdapter.request(data)
-      expect(refreshResponse.statusCode).toEqual(200)
-    })
-
-    it('should handle token expiry and reconnection gracefully', async () => {
-      const initialResponse = await testAdapter.request(data)
-      expect(initialResponse.statusCode).toEqual(200)
-
-      // Advance time to 59 minutes (just before actual 1-hour expiry)
-      const advanceMs = 59 * 60 * 1000
-      clock.tick(advanceMs)
-
-      // At this point, the cached token should be invalidated and a new one should be fetched
-      // Mock the new token
-      nock(apiEndpoint)
-        .post('/token')
-        .reply(200, {
-          success: true,
-          ts: new Date().getTime() * 1_000_000,
-          token: 'new-refreshed-token',
-          validUntil: new Date(Date.now() + 60 * 60 * 1000).toISOString(),
-        })
-
-      const afterExpireResponse = await testAdapter.request(data)
-      expect(afterExpireResponse.statusCode).toEqual(200)
-    })
-  })
-
-  describe('error handling', () => {
-    it('should handle token fetch failure gracefully', async () => {
-      // This is covered by the existing error path in authutils.ts
-      // The test setup mocks successful token fetch, so failures would be handled
-      // by the existing error logging and re-throw logic
-    })
+  it('tears the connection down before the token expires and reconnects', async () => {
+    const connectionBeforeRefresh = transport.wsConnection
+    expect(connectionBeforeRefresh).toBeDefined()
+
+    // Advance the way production runs: under continuous traffic, so the
+    // subscription set stays alive. Idling past WS_SUBSCRIPTION_TTL (120s)
+    // would drop the subscriptions and leave the loop nothing to reconnect for.
+    const STEP_MS = 30 * 1000
+    const stopShortOf = MS_UNTIL_SCHEDULED_REFRESH - STEP_MS
+    for (let elapsed = 0; elapsed < stopShortOf; elapsed += STEP_MS) {
+      await testAdapter.clock?.tickAsync(Math.min(STEP_MS, stopShortOf - elapsed))
+      await testAdapter.request(data)
+    }
+
+    // A minute short of the threshold the connection must still be the original
+    // one — tearing down early would throw away a perfectly good token.
+    expect(transport.wsConnection).toBe(connectionBeforeRefresh)
+    expect(connectionBeforeRefresh?.readyState).toEqual(OPEN)
+
+    await testAdapter.clock?.tickAsync(STEP_MS)
+
+    // Previously the adapter only dropped its cached token and left this socket
+    // open. GSR then went silent at the 60 minute mark and the cache went stale
+    // (CACHE_MAX_AGE, 90s) a full 30s before the framework's unresponsiveness
+    // watchdog (WS_SUBSCRIPTION_UNRESPONSIVE_TTL, 120s) reconnected — which is
+    // the window that served 504s. The socket must be closed outright instead,
+    // while the provider is still sending data.
+    expect(connectionBeforeRefresh?.readyState).not.toEqual(OPEN)
+
+    // And the framework must actually bring it back: the teardown deliberately
+    // leaves wsConnection set so streamHandler's early return doesn't strand it.
+    for (let i = 0; i < 10 && transport.wsConnection?.readyState !== OPEN; i++) {
+      await testAdapter.clock?.tickAsync(1000)
+      await testAdapter.request(data)
+    }
+    expect(transport.wsConnection?.readyState).toEqual(OPEN)
+    expect(transport.wsConnection).not.toBe(connectionBeforeRefresh)
+
+    const response = await testAdapter.request(data)
+    expect(response.statusCode).toEqual(200)
   })
 })
diff --git a/packages/sources/gsr/test/unit/token-refresh.test.ts b/packages/sources/gsr/test/unit/token-refresh.test.ts
index 959ab0c72f2..569653a8092 100644
--- a/packages/sources/gsr/test/unit/token-refresh.test.ts
+++ b/packages/sources/gsr/test/unit/token-refresh.test.ts
@@ -1,209 +1,67 @@
-import FakeTimers from '@sinonjs/fake-timers'
-import * as nock from 'nock'
+import { LoggerFactoryProvider } from '@chainlink/external-adapter-framework/util'
+import nock from 'nock'
 import { getToken } from '../../src/transport/authutils'
 
-describe('GSR Token Refresh Logic', () => {
-  let clock: ReturnType<typeof FakeTimers.install>
-  const apiEndpoint = 'https://oracle.prod.gsr.io/v1'
+LoggerFactoryProvider.set()
+
+describe('GSR access token expiry', () => {
+  const apiHost = 'https://oracle.prod.gsr.io'
+  const apiEndpoint = `${apiHost}/v1`
   const userId = 'test-user-id'
   const publicKey = 'test-pub-key'
   const privateKey = 'test-priv-key'
 
-  beforeEach(() => {
-    clock = FakeTimers.install()
-    // Set a fixed time for tests
-    clock.setSystemTime(new Date('2022-05-10T16:09:27.193Z').getTime())
-    nock.cleanAll()
+  beforeAll(() => {
+    nock.disableNetConnect()
+  })
+
+  afterAll(() => {
+    nock.enableNetConnect()
   })
 
   afterEach(() => {
-    clock.uninstall()
     nock.cleanAll()
   })
 
-  describe('getToken', () => {
-    it('should return token with expiry time', async () => {
-      const validUntil = '2022-05-10T17:09:27.193Z' // 1 hour from now
-      nock(apiEndpoint).post('/token').reply(200, {
-        success: true,
-        ts: 1652198967193000000,
-        token: 'test-token-123',
-        validUntil,
-      })
-
-      const result = await getToken(apiEndpoint, userId, publicKey, privateKey)
-
-      expect(result.token).toBe('test-token-123')
-      expect(result.expiresAtMs).toBe(new Date(validUntil).getTime())
+  it('surfaces the expiry encoded in validUntil', async () => {
+    const validUntil = '2022-05-10T17:09:27.193Z'
+    nock(apiHost).post('/v1/token').reply(200, {
+      success: true,
+      ts: 1652198967193000000,
+      token: 'test-token-123',
+      validUntil,
     })
 
-    it('should correctly parse validUntil timestamp', async () => {
-      const validUntil = '2022-05-10T18:30:00.000Z'
-      nock(apiEndpoint).post('/token').reply(200, {
-        success: true,
-        ts: 1652198967193000000,
-        token: 'test-token-abc',
-        validUntil,
-      })
-
-      const result = await getToken(apiEndpoint, userId, publicKey, privateKey)
-      const expectedMs = new Date('2022-05-10T18:30:00.000Z').getTime()
-
-      expect(result.expiresAtMs).toBe(expectedMs)
-    })
+    const result = await getToken(apiEndpoint, userId, publicKey, privateKey)
 
-    it('should throw error on failed token request', async () => {
-      nock(apiEndpoint).post('/token').reply(200, {
-        success: false,
-        ts: 1652198967193000000,
-        error: 'API key mismatch',
-      })
-
-      await expect(getToken(apiEndpoint, userId, publicKey, privateKey)).rejects.toThrow(
-        'API key mismatch',
-      )
-    })
+    expect(result.token).toBe('test-token-123')
+    expect(result.expiresAtMs).toBe(new Date(validUntil).getTime())
   })
 
-  describe('token caching behavior', () => {
-    it('should reuse token when not near expiry', async () => {
-      const validUntil = '2022-05-10T17:09:27.193Z' // 1 hour from now
-      let tokenFetchCount = 0
-
-      nock(apiEndpoint)
-        .post('/token')
-        .times(1)
-        .reply(() => {
-          tokenFetchCount++
-          return [
-            200,
-            {
-              success: true,
-              ts: 1652198967193000000,
-              token: `test-token-${tokenFetchCount}`,
-              validUntil,
-            },
-          ]
-        })
-
-      // First connection - should fetch token
-      const firstResult = await getToken(apiEndpoint, userId, publicKey, privateKey)
-      expect(firstResult.token).toBe('test-token-1')
-      expect(tokenFetchCount).toBe(1)
-
-      // Token should be cached, second fetch should use cache
-      // (In actual usage this would be via getTokenForConnection)
+  it('handles the 1 hour validity window GSR issues in production', async () => {
+    const issuedAt = new Date('2022-05-10T16:09:27.193Z').getTime()
+    const validUntil = new Date(issuedAt + 60 * 60 * 1000).toISOString()
+    nock(apiHost).post('/v1/token').reply(200, {
+      success: true,
+      ts: 1652198967193000000,
+      token: 'test-token-1h',
+      validUntil,
     })
 
-    it('should refresh token when approaching expiry (within 5 min margin)', async () => {
-      const currentTime = new Date('2022-05-10T16:09:27.193Z').getTime()
-      const expiryTime = currentTime + 3 * 60 * 1000 // 3 minutes from now (within 5 min margin)
-
-      nock(apiEndpoint)
-        .post('/token')
-        .reply(200, {
-          success: true,
-          ts: 1652198967193000000,
-          token: 'test-token-about-to-expire',
-          validUntil: new Date(expiryTime).toISOString(),
-        })
-
-      const result = await getToken(apiEndpoint, userId, publicKey, privateKey)
-
-      // Verify token is retrieved
-      expect(result.token).toBe('test-token-about-to-expire')
+    const result = await getToken(apiEndpoint, userId, publicKey, privateKey)
 
-      // Calculate time until expiry
-      const now = Date.now()
-      const timeUntilExpiry = result.expiresAtMs - now
-      const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000
-
-      // Token should be within the refresh margin
-      expect(timeUntilExpiry).toBeLessThan(TOKEN_REFRESH_MARGIN_MS)
-    })
-
-    it('should handle 1-hour token validity correctly', async () => {
-      const currentTime = new Date('2022-05-10T16:09:27.193Z').getTime()
-      const oneHourLater = currentTime + 60 * 60 * 1000
-
-      nock(apiEndpoint)
-        .post('/token')
-        .reply(200, {
-          success: true,
-          ts: 1652198967193000000,
-          token: 'test-token-1h',
-          validUntil: new Date(oneHourLater).toISOString(),
-        })
-
-      const result = await getToken(apiEndpoint, userId, publicKey, privateKey)
-
-      // Verify token expires in approximately 1 hour
-      const now = Date.now()
-      const timeUntilExpiry = result.expiresAtMs - now
-      const expectedDuration = 60 * 60 * 1000 // 1 hour
-
-      // Allow 1 second tolerance for execution time
-      expect(Math.abs(timeUntilExpiry - expectedDuration)).toBeLessThan(1000)
-    })
+    expect(result.expiresAtMs - issuedAt).toBe(60 * 60 * 1000)
   })
 
-  describe('proactive reconnection', () => {
-    it('should schedule reconnection 5 minutes before token expiry', async () => {
-      const validUntil = '2022-05-10T17:09:27.193Z' // 1 hour from now
-      nock(apiEndpoint).post('/token').reply(200, {
-        success: true,
-        ts: 1652198967193000000,
-        token: 'test-token-with-timer',
-        validUntil,
-      })
-
-      const result = await getToken(apiEndpoint, userId, publicKey, privateKey)
-      const now = Date.now()
-      const timeUntilExpiry = result.expiresAtMs - now
-      const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000
-      const reconnectInMs = timeUntilExpiry - TOKEN_REFRESH_MARGIN_MS
-
-      // Should schedule reconnect in ~55 minutes (1 hour - 5 min margin)
-      const fiftyFiveMinutesMs = 55 * 60 * 1000
-      expect(reconnectInMs).toBeGreaterThan(fiftyFiveMinutesMs - 1000)
-      expect(reconnectInMs).toBeLessThan(fiftyFiveMinutesMs + 1000)
+  it('throws when the provider rejects the token request', async () => {
+    nock(apiHost).post('/v1/token').reply(200, {
+      success: false,
+      ts: 1652198967193000000,
+      error: 'API key mismatch',
     })
 
-    it('should trigger reconnection only when token expiry is imminent', async () => {
-      const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000
-      const currentTime = clock.now()
-
-      // Test case 1: Token expires in 3 minutes (within margin - should trigger)
-      const expiry1 = currentTime + 3 * 60 * 1000
-      nock(apiEndpoint)
-        .post('/token')
-        .reply(200, {
-          success: true,
-          ts: 1652198967193000000,
-          token: 'token-3min',
-          validUntil: new Date(expiry1).toISOString(),
-        })
-
-      const result1 = await getToken(apiEndpoint, userId, publicKey, privateKey)
-      const reconnectInMs1 = result1.expiresAtMs - clock.now() - TOKEN_REFRESH_MARGIN_MS
-      expect(reconnectInMs1).toBeLessThan(0) // Should be negative (already within margin)
-
-      nock.cleanAll()
-
-      // Test case 2: Token expires in 50 minutes (outside margin - should not trigger yet)
-      const expiry2 = currentTime + 50 * 60 * 1000
-      nock(apiEndpoint)
-        .post('/token')
-        .reply(200, {
-          success: true,
-          ts: 1652198967193000000,
-          token: 'token-50min',
-          validUntil: new Date(expiry2).toISOString(),
-        })
-
-      const result2 = await getToken(apiEndpoint, userId, publicKey, privateKey)
-      const reconnectInMs2 = result2.expiresAtMs - clock.now() - TOKEN_REFRESH_MARGIN_MS
-      expect(reconnectInMs2).toBeGreaterThan(0) // Should be positive (not yet time to refresh)
-    })
+    await expect(getToken(apiEndpoint, userId, publicKey, privateKey)).rejects.toThrow(
+      'API key mismatch',
+    )
   })
 })

From 1ed3b35d172e68c2021e353a8ffa9cd1aff46fe8 Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Thu, 6 Aug 2026 14:36:33 -0700
Subject: [PATCH 04/16] chore(gsr-adapter): sync yarn.lock with EA framework
 2.18.0

The bump to 2.18.0 updated package.json but left the lockfile pinned at
2.17.1, so `yarn install --immutable` failed with YN0028 and every
downstream check was skipped rather than run.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 .pnp.cjs  | 2 +-
 yarn.lock | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.pnp.cjs b/.pnp.cjs
index 21458c9c3fa..825fb97193d 100644
--- a/.pnp.cjs
+++ b/.pnp.cjs
@@ -5959,7 +5959,7 @@ const RAW_RUNTIME_STATE =
       ["workspace:packages/sources/gsr", {\
         "packageLocation": "./packages/sources/gsr/",\
         "packageDependencies": [\
-          ["@chainlink/external-adapter-framework", "npm:2.17.1"],\
+          ["@chainlink/external-adapter-framework", "npm:2.18.0"],\
           ["@chainlink/gsr-adapter", "workspace:packages/sources/gsr"],\
           ["@sinonjs/fake-timers", "npm:9.1.2"],\
           ["@types/jest", "npm:29.5.14"],\
diff --git a/yarn.lock b/yarn.lock
index 370911479c7..9bc6332ab81 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3554,7 +3554,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@chainlink/gsr-adapter@workspace:packages/sources/gsr"
   dependencies:
-    "@chainlink/external-adapter-framework": "npm:2.17.1"
+    "@chainlink/external-adapter-framework": "npm:2.18.0"
     "@sinonjs/fake-timers": "npm:9.1.2"
     "@types/jest": "npm:^29.5.14"
     "@types/node": "npm:22.14.1"

From 933ca3782826aa912fbde0c28f38b4b011ba2229 Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Fri, 7 Aug 2026 11:42:37 -0700
Subject: [PATCH 05/16] adds token refresh logic

---
 .changeset/eager-owls-exist.md                |   8 +-
 .../sources/gsr/src/transport/authutils.ts    |  55 +++++-
 packages/sources/gsr/src/transport/price.ts   | 162 +++++++++++++-----
 .../test/integration/token-caching.test.ts    | 135 ---------------
 .../gsr/test/unit/token-refresh.test.ts       |  68 +++++++-
 5 files changed, 244 insertions(+), 184 deletions(-)
 delete mode 100644 packages/sources/gsr/test/integration/token-caching.test.ts

diff --git a/.changeset/eager-owls-exist.md b/.changeset/eager-owls-exist.md
index 963792bd496..bd15a86a889 100644
--- a/.changeset/eager-owls-exist.md
+++ b/.changeset/eager-owls-exist.md
@@ -2,4 +2,10 @@
 '@chainlink/gsr-adapter': patch
 ---
 
-Fix hourly WebSocket disconnections by implementing proactive token refresh and connection closure. GSR issues 1-hour validity tokens that expire, causing WebSocket disconnections. The adapter now: (1) caches tokens with expiry tracking, (2) schedules reconnection 5 minutes before token expiry, (3) actively closes the WebSocket connection when token expiry threshold is reached by attempting multiple closure methods (transport.close(), transport.ws.close(), transport.\_ws.close(), transport.socket.close()) to ensure the underlying connection is terminated, forcing an immediate reconnection with a fresh token and preventing the 7-minute gap of failed requests that previously occurred.
+Fix hourly WebSocket disconnections caused by access token expiry.
+
+GSR issues tokens valid for one hour and stops sending data when one expires, without closing the socket. The framework only noticed after `WS_SUBSCRIPTION_UNRESPONSIVE_TTL` (120s) of silence, by which point cached prices had already aged out at `CACHE_MAX_AGE` (90s), producing roughly 30 seconds of 504s every hour.
+
+The adapter now tracks token expiry and, five minutes ahead of it, renews the token in place via GSR's `PUT /token` endpoint rather than reconnecting. Because the token travels in the WebSocket handshake headers, a successful renewal is not by itself proof that the session survived, so the adapter verifies that data is still arriving shortly after the old expiry and reconnects if it is not. A refused renewal also falls back to reconnecting immediately. Either fallback happens while cached prices are still fresh, so callers see no failures.
+
+`PUT /token` renewal, along with the signature format it requires, was removed in #2459 and is restored here.
diff --git a/packages/sources/gsr/src/transport/authutils.ts b/packages/sources/gsr/src/transport/authutils.ts
index 3608c05edb6..f67a145dc01 100644
--- a/packages/sources/gsr/src/transport/authutils.ts
+++ b/packages/sources/gsr/src/transport/authutils.ts
@@ -26,11 +26,10 @@ export interface TokenWithExpiry {
 
 const currentTimeNanoSeconds = (): number => new Date(Date.now()).getTime() * 1_000_000
 
-const generateSignature = (userId: string, publicKey: string, privateKey: string, ts: number) =>
-  crypto
-    .createHmac('sha256', privateKey)
-    .update(`userId=${userId}&apiKey=${publicKey}&ts=${ts}`)
-    .digest('hex')
+// GSR signs over the API key when minting a token and over the existing token
+// when renewing one.
+const generateSignature = (privateKey: string, payload: string) =>
+  crypto.createHmac('sha256', privateKey).update(payload).digest('hex')
 
 // restApiEndpoint is used for token auth
 export const getToken = async (
@@ -42,7 +41,7 @@ export const getToken = async (
   logger.debug('Fetching new access token')
 
   const ts = currentTimeNanoSeconds()
-  const signature = generateSignature(userId, publicKey, privateKey, ts)
+  const signature = generateSignature(privateKey, `userId=${userId}&apiKey=${publicKey}&ts=${ts}`)
   const response = await axios.post<AccessTokenResponse>(`${restApiEndpoint}/token`, {
     apiKey: publicKey,
     userId,
@@ -82,3 +81,47 @@ export const getToken = async (
     expiresAtMs,
   }
 }
+
+/**
+ * Renews an existing token via GSR's PUT endpoint rather than minting a fresh
+ * one. This is the provider's documented renewal path; the adapter used it
+ * until #2459 removed it in Jan 2023.
+ *
+ * Note this renews the *token*, which is a separate thing from the WebSocket
+ * session. The token travels in the connection's handshake headers, so whether
+ * a renewal extends an already-open connection is GSR-side behaviour the caller
+ * must verify rather than assume.
+ */
+export const renewToken = async (
+  restApiEndpoint: string,
+  userId: string,
+  privateKey: string,
+  existingToken: string,
+): Promise<TokenWithExpiry> => {
+  logger.debug('Renewing existing access token')
+
+  const ts = currentTimeNanoSeconds()
+  const signature = generateSignature(
+    privateKey,
+    `userId=${userId}&token=${existingToken}&ts=${ts}`,
+  )
+  const response = await axios.put<AccessTokenResponse>(`${restApiEndpoint}/token`, {
+    token: existingToken,
+    userId,
+    ts,
+    signature,
+  })
+
+  if (!response.data.success) {
+    logger.warn(`Unable to renew access token: ${response.data.error}`)
+    throw new Error(response.data.error)
+  }
+
+  const expiresAtMs = new Date(response.data.validUntil).getTime()
+  logger.info(`Token renewed, expires at ${response.data.validUntil}`)
+
+  return {
+    token: response.data.token,
+    expiresAtMs,
+  }
+}
diff --git a/packages/sources/gsr/src/transport/price.ts b/packages/sources/gsr/src/transport/price.ts
index bf70a2b2172..98a88b4b03e 100644
--- a/packages/sources/gsr/src/transport/price.ts
+++ b/packages/sources/gsr/src/transport/price.ts
@@ -1,7 +1,13 @@
 import { WebSocketTransport } from '@chainlink/external-adapter-framework/transports'
 import { makeLogger, ProviderResult } from '@chainlink/external-adapter-framework/util'
 import { BaseEndpointTypes } from '../endpoint/price'
-import { getToken, TokenWithExpiry } from './authutils'
+import { getToken, renewToken, TokenWithExpiry } from './authutils'
+import {
+  livenessProbeDelayMs,
+  refreshDelayMs,
+  renewalHeld,
+  TOKEN_REFRESH_MARGIN_MS,
+} from './tokenRefresh'
 
 const logger = makeLogger('GSR WS price')
 
@@ -23,12 +29,6 @@ export type WsTransportTypes = BaseEndpointTypes & {
 }
 
 let cachedToken: TokenWithExpiry | null = null
-const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000 // Refresh 5 minutes before expiry
-
-// setTimeout coerces any delay above this to 1ms, which would turn an
-// implausibly distant expiry into a teardown on every open, i.e. a reconnect
-// loop. Clamp instead so we simply re-evaluate at the ceiling.
-const MAX_TIMEOUT_MS = 2 ** 31 - 1
 
 const getTokenForConnection = async (
   apiEndpoint: string,
@@ -51,10 +51,107 @@ const getTokenForConnection = async (
   return cachedToken.token
 }
 
-// Timer that tears down the connection before the token expires. Cleared and
-// rescheduled on every open, otherwise timers from previous connections would
-// accumulate and close a healthy connection at an arbitrary later point.
+// Timers driving the refresh cycle. Cleared and rescheduled on every open,
+// otherwise timers from previous connections would accumulate and act on a
+// healthy connection at an arbitrary later point.
 let refreshTimer: NodeJS.Timeout | undefined
+let livenessTimer: NodeJS.Timeout | undefined
+
+// Set on every inbound frame, so the liveness probe can tell whether the
+// provider is still talking to us after an in-place renewal.
+let lastMessageAtMs = 0
+
+const clearTimers = () => {
+  if (refreshTimer) {
+    clearTimeout(refreshTimer)
+    refreshTimer = undefined
+  }
+  if (livenessTimer) {
+    clearTimeout(livenessTimer)
+    livenessTimer = undefined
+  }
+}
+
+const closeForReconnect = (reason: string) => {
+  logger.info(`${reason}; closing connection to reconnect`)
+  cachedToken = null
+  // Close only — deliberately leaving wsConnection set. streamHandler bails out
+  // early when there is no connection *and* no new subscription, so clearing the
+  // field from outside its loop would strand the transport with nothing to
+  // reconnect. Leaving the closed socket in place lets connectionClosed() report
+  // true off readyState and the loop reopens on its next pass.
+  transport.wsConnection?.close(1000)
+}
+
+/**
+ * Renewing the token is an HTTP call; it says nothing about whether GSR extended
+ * the session behind the already-open socket, which still carries the old token
+ * in its handshake headers. So after a successful renewal we wait until just
+ * past the old expiry and check whether frames are still arriving. If they
+ * stopped, the renewal did not hold and we fall back to reconnecting — early
+ * enough that cached prices have not yet aged out.
+ */
+const scheduleLivenessProbe = (previousExpiryMs: number) => {
+  livenessTimer = setTimeout(() => {
+    livenessTimer = undefined
+    if (renewalHeld(lastMessageAtMs, Date.now())) {
+      logger.info('Still receiving data past the previous token expiry; in-place renewal held')
+      return
+    }
+    closeForReconnect(
+      `No provider data for ${Math.round(
+        (Date.now() - lastMessageAtMs) / 1000,
+      )}s past the previous token expiry, so the in-place renewal did not extend the session`,
+    )
+  }, livenessProbeDelayMs(previousExpiryMs, Date.now()))
+}
+
+const scheduleRefresh = (token: TokenWithExpiry, settings: RefreshSettings) => {
+  const delayMs = refreshDelayMs(token, Date.now())
+  if (delayMs === null) {
+    return
+  }
+  logger.info(
+    `Scheduled token refresh in ${Math.round(delayMs / 1000)}s to prevent ungraceful disconnection`,
+  )
+  refreshTimer = setTimeout(() => {
+    refreshTimer = undefined
+    void refreshTokenOrReconnect(settings)
+  }, delayMs)
+}
+
+/**
+ * Preferred path: renew the token in place and leave the connection up. Only
+ * tear the socket down if that fails, since a reconnect — while cheap — drops
+ * every subscription and re-runs the handshake.
+ */
+const refreshTokenOrReconnect = async (settings: RefreshSettings) => {
+  const previous = cachedToken
+  if (!previous) {
+    closeForReconnect('No cached token to renew')
+    return
+  }
+
+  try {
+    const renewed = await renewToken(
+      settings.apiEndpoint,
+      settings.userId,
+      settings.privateKey,
+      previous.token,
+    )
+    cachedToken = renewed
+    scheduleLivenessProbe(previous.expiresAtMs)
+    scheduleRefresh(renewed, settings)
+  } catch (e) {
+    closeForReconnect(`Token renewal failed (${(e as Error).message})`)
+  }
+}
+
+type RefreshSettings = {
+  apiEndpoint: string
+  userId: string
+  privateKey: string
+}
 
 export const transport = new WebSocketTransport<WsTransportTypes>({
   url: (context) => context.adapterSettings.WS_API_ENDPOINT,
@@ -70,43 +167,23 @@ export const transport = new WebSocketTransport<WsTransportTypes>({
     },
   }),
   handlers: {
-    open: () => {
-      if (refreshTimer) {
-        clearTimeout(refreshTimer)
-        refreshTimer = undefined
-      }
+    open: (_wsConnection, context) => {
+      clearTimers()
+      lastMessageAtMs = Date.now()
 
       // GSR stops sending messages once the token expires but leaves the socket
       // open, so the framework only notices after WS_SUBSCRIPTION_UNRESPONSIVE_TTL
       // (120s) of silence — by which point the cache has already gone stale at
-      // CACHE_MAX_AGE (90s) and requests are failing. Tear the connection down
-      // ahead of expiry so the reconnect happens while data is still flowing.
+      // CACHE_MAX_AGE (90s) and requests are failing. Act ahead of expiry, while
+      // data is still flowing.
       if (cachedToken) {
-        const reconnectInMs = cachedToken.expiresAtMs - Date.now() - TOKEN_REFRESH_MARGIN_MS
-
-        if (reconnectInMs > 0) {
-          const delayMs = Math.min(reconnectInMs, MAX_TIMEOUT_MS)
-          logger.info(
-            `Scheduled token refresh/reconnect in ${Math.round(
-              delayMs / 1000,
-            )}s to prevent ungraceful disconnection`,
-          )
-          refreshTimer = setTimeout(() => {
-            refreshTimer = undefined
-            cachedToken = null
-            logger.info('Token expiry threshold reached, closing connection to reconnect')
-
-            // Close only — deliberately leaving wsConnection set. streamHandler
-            // bails out early when there is no connection *and* no new
-            // subscription, so clearing the field from outside its loop would
-            // strand the transport with nothing to reconnect. Leaving the closed
-            // socket in place lets connectionClosed() report true off readyState
-            // and the loop reopens on its next pass.
-            transport.wsConnection?.close(1000)
-          }, delayMs)
-        }
+        scheduleRefresh(cachedToken, {
+          apiEndpoint: context.adapterSettings.API_ENDPOINT,
+          userId: context.adapterSettings.WS_USER_ID,
+          privateKey: context.adapterSettings.WS_PRIVATE_KEY,
+        })
       }
-      return
+      return Promise.resolve()
     },
     close: (closeEvent) => {
       // Distinguishes a close initiated by GSR from one the framework's
@@ -116,6 +193,9 @@ export const transport = new WebSocketTransport<WsTransportTypes>({
       )
     },
     message(message): ProviderResult<WsTransportTypes>[] | undefined {
+      // Any frame proves the provider is still talking to us, whatever its type.
+      lastMessageAtMs = Date.now()
+
       if (message.type == 'error') {
         logger.error(`Got error from DP: ${JSON.stringify(message)}`)
         return
diff --git a/packages/sources/gsr/test/integration/token-caching.test.ts b/packages/sources/gsr/test/integration/token-caching.test.ts
deleted file mode 100644
index c14b6cda30c..00000000000
--- a/packages/sources/gsr/test/integration/token-caching.test.ts
+++ /dev/null
@@ -1,135 +0,0 @@
-import { WebSocketClassProvider } from '@chainlink/external-adapter-framework/transports'
-import {
-  mockWebSocketProvider,
-  MockWebsocketServer,
-  setEnvVariables,
-  TestAdapter,
-} from '@chainlink/external-adapter-framework/util/testing-utils'
-import FakeTimers from '@sinonjs/fake-timers'
-import nock from 'nock'
-import { transport } from '../../src/transport/price'
-import { mockWebSocketServer } from './fixtures'
-
-// GSR issues one hour tokens in production, but the scenario is scaled down so
-// the refresh point lands inside the window the framework's unresponsiveness
-// watchdog allows (WS_SUBSCRIPTION_UNRESPONSIVE_TTL caps at 180s). With a 400s
-// token the adapter should tear down at 100s, well before the watchdog at 180s
-// could do it instead — otherwise these assertions would hold with or without
-// the fix. The reply body is a function so the expiry tracks the fake clock.
-const TOKEN_VALIDITY_MS = 400 * 1000
-const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000 // must match the transport
-const MS_UNTIL_SCHEDULED_REFRESH = TOKEN_VALIDITY_MS - TOKEN_REFRESH_MARGIN_MS
-const UNRESPONSIVE_TTL_MS = 180 * 1000
-const OPEN = 1 // WebSocket.OPEN
-
-const mockRollingToken = () =>
-  nock('https://oracle.prod.gsr.io', { encodedQueryParams: true })
-    .post('/v1/token', {
-      apiKey: 'test-pub-key',
-      userId: 'test-user-id',
-      ts: /^\d+$/,
-      signature: /^[0-9a-f]+$/i,
-    })
-    .reply(200, () => ({
-      success: true,
-      ts: Date.now() * 1e6,
-      token: 'fake-token',
-      validUntil: new Date(Date.now() + TOKEN_VALIDITY_MS).toISOString(),
-    }))
-    .persist()
-
-describe('token expiry driven reconnection', () => {
-  let mockWsServer: MockWebsocketServer | undefined
-  let testAdapter: TestAdapter
-  let oldEnv: NodeJS.ProcessEnv
-  const wsEndpoint = 'ws://localhost:9091'
-  const data = {
-    base: 'ETH',
-    quote: 'USD',
-  }
-
-  beforeAll(async () => {
-    oldEnv = JSON.parse(JSON.stringify(process.env))
-    process.env['WS_API_ENDPOINT'] = wsEndpoint
-    process.env['WS_USER_ID'] = 'test-user-id'
-    process.env['WS_PUBLIC_KEY'] = 'test-pub-key'
-    process.env['WS_PRIVATE_KEY'] = 'test-priv-key'
-    // Hold the watchdog at its maximum so it cannot reach the refresh point
-    // first. At its 120s default it recycles the connection on its own and the
-    // assertions below pass whether or not the adapter does anything, which is
-    // precisely the broken behaviour being fixed.
-    process.env['WS_SUBSCRIPTION_UNRESPONSIVE_TTL'] = String(UNRESPONSIVE_TTL_MS)
-
-    mockRollingToken()
-    mockWebSocketProvider(WebSocketClassProvider)
-    mockWsServer = mockWebSocketServer(wsEndpoint)
-
-    const adapter = (await import('./../../src')).adapter
-    testAdapter = await TestAdapter.startWithMockedCache(adapter, {
-      clock: FakeTimers.install(),
-      testAdapter: {} as TestAdapter<never>,
-    })
-
-    await testAdapter.request(data)
-    await testAdapter.waitForCache()
-  })
-
-  afterAll(async () => {
-    setEnvVariables(oldEnv)
-    mockWsServer?.close()
-    testAdapter.clock?.uninstall()
-    await testAdapter.api.close()
-    nock.cleanAll()
-  })
-
-  it('holds a live connection open while the token is valid', async () => {
-    expect(transport.wsConnection).toBeDefined()
-
-    // Well short of the refresh point: nothing should disturb the connection.
-    const connection = transport.wsConnection
-    await testAdapter.clock?.tickAsync(10 * 1000)
-    expect(transport.wsConnection).toBe(connection)
-  })
-
-  it('tears the connection down before the token expires and reconnects', async () => {
-    const connectionBeforeRefresh = transport.wsConnection
-    expect(connectionBeforeRefresh).toBeDefined()
-
-    // Advance the way production runs: under continuous traffic, so the
-    // subscription set stays alive. Idling past WS_SUBSCRIPTION_TTL (120s)
-    // would drop the subscriptions and leave the loop nothing to reconnect for.
-    const STEP_MS = 30 * 1000
-    const stopShortOf = MS_UNTIL_SCHEDULED_REFRESH - STEP_MS
-    for (let elapsed = 0; elapsed < stopShortOf; elapsed += STEP_MS) {
-      await testAdapter.clock?.tickAsync(Math.min(STEP_MS, stopShortOf - elapsed))
-      await testAdapter.request(data)
-    }
-
-    // A minute short of the threshold the connection must still be the original
-    // one — tearing down early would throw away a perfectly good token.
-    expect(transport.wsConnection).toBe(connectionBeforeRefresh)
-    expect(connectionBeforeRefresh?.readyState).toEqual(OPEN)
-
-    await testAdapter.clock?.tickAsync(STEP_MS)
-
-    // Previously the adapter only dropped its cached token and left this socket
-    // open. GSR then went silent at the 60 minute mark and the cache went stale
-    // (CACHE_MAX_AGE, 90s) a full 30s before the framework's unresponsiveness
-    // watchdog (WS_SUBSCRIPTION_UNRESPONSIVE_TTL, 120s) reconnected — which is
-    // the window that served 504s. The socket must be closed outright instead,
-    // while the provider is still sending data.
-    expect(connectionBeforeRefresh?.readyState).not.toEqual(OPEN)
-
-    // And the framework must actually bring it back: the teardown deliberately
-    // leaves wsConnection set so streamHandler's early return doesn't strand it.
-    for (let i = 0; i < 10 && transport.wsConnection?.readyState !== OPEN; i++) {
-      await testAdapter.clock?.tickAsync(1000)
-      await testAdapter.request(data)
-    }
-    expect(transport.wsConnection?.readyState).toEqual(OPEN)
-    expect(transport.wsConnection).not.toBe(connectionBeforeRefresh)
-
-    const response = await testAdapter.request(data)
-    expect(response.statusCode).toEqual(200)
-  })
-})
diff --git a/packages/sources/gsr/test/unit/token-refresh.test.ts b/packages/sources/gsr/test/unit/token-refresh.test.ts
index 569653a8092..236117316ce 100644
--- a/packages/sources/gsr/test/unit/token-refresh.test.ts
+++ b/packages/sources/gsr/test/unit/token-refresh.test.ts
@@ -1,6 +1,7 @@
 import { LoggerFactoryProvider } from '@chainlink/external-adapter-framework/util'
+import crypto from 'crypto'
 import nock from 'nock'
-import { getToken } from '../../src/transport/authutils'
+import { getToken, renewToken } from '../../src/transport/authutils'
 
 LoggerFactoryProvider.set()
 
@@ -65,3 +66,68 @@ describe('GSR access token expiry', () => {
     )
   })
 })
+
+describe('GSR access token renewal', () => {
+  const apiHost = 'https://oracle.prod.gsr.io'
+  const apiEndpoint = `${apiHost}/v1`
+  const userId = 'test-user-id'
+  const privateKey = 'test-priv-key'
+  const existingToken = 'existing-token'
+
+  beforeAll(() => {
+    nock.disableNetConnect()
+  })
+
+  afterAll(() => {
+    nock.enableNetConnect()
+  })
+
+  afterEach(() => {
+    nock.cleanAll()
+  })
+
+  it('renews via PUT and signs over the token rather than the API key', async () => {
+    let seenBody: Record<string, unknown> = {}
+    const validUntil = '2022-05-10T17:09:27.193Z'
+    nock(apiHost)
+      .put('/v1/token', (body) => {
+        seenBody = body
+        return true
+      })
+      .reply(200, {
+        success: true,
+        ts: 1652198967193000000,
+        token: 'renewed-token',
+        validUntil,
+      })
+
+    const result = await renewToken(apiEndpoint, userId, privateKey, existingToken)
+
+    expect(result.token).toBe('renewed-token')
+    expect(result.expiresAtMs).toBe(new Date(validUntil).getTime())
+
+    // Renewal presents the existing token, never the API key.
+    expect(seenBody['token']).toBe(existingToken)
+    expect(seenBody['apiKey']).toBeUndefined()
+    expect(seenBody['userId']).toBe(userId)
+
+    const expectedSignature = crypto
+      .createHmac('sha256', privateKey)
+      .update(`userId=${userId}&token=${existingToken}&ts=${seenBody['ts']}`)
+      .digest('hex')
+    expect(seenBody['signature']).toBe(expectedSignature)
+  })
+
+  it('throws when the provider refuses the renewal', async () => {
+    nock(apiHost).put('/v1/token').reply(200, {
+      success: false,
+      ts: 1652198967193000000,
+      error: 'Signature mismatch',
+    })
+
+    // The caller falls back to closing the connection on this rejection.
+    await expect(renewToken(apiEndpoint, userId, privateKey, existingToken)).rejects.toThrow(
+      'Signature mismatch',
+    )
+  })
+})

From 14cbd5eab114affa26f61d98909d9061fa610378 Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Fri, 7 Aug 2026 14:19:22 -0700
Subject: [PATCH 06/16] refactor into class

---
 packages/sources/gsr/src/transport/price.ts | 367 +++++++++-----------
 1 file changed, 170 insertions(+), 197 deletions(-)

diff --git a/packages/sources/gsr/src/transport/price.ts b/packages/sources/gsr/src/transport/price.ts
index 98a88b4b03e..276f06fc1ea 100644
--- a/packages/sources/gsr/src/transport/price.ts
+++ b/packages/sources/gsr/src/transport/price.ts
@@ -2,12 +2,7 @@ import { WebSocketTransport } from '@chainlink/external-adapter-framework/transp
 import { makeLogger, ProviderResult } from '@chainlink/external-adapter-framework/util'
 import { BaseEndpointTypes } from '../endpoint/price'
 import { getToken, renewToken, TokenWithExpiry } from './authutils'
-import {
-  livenessProbeDelayMs,
-  refreshDelayMs,
-  renewalHeld,
-  TOKEN_REFRESH_MARGIN_MS,
-} from './tokenRefresh'
+import { livenessProbeDelayMs, refreshDelayMs, renewalHeld } from './tokenRefresh'
 
 const logger = makeLogger('GSR WS price')
 
@@ -28,219 +23,197 @@ export type WsTransportTypes = BaseEndpointTypes & {
   }
 }
 
-let cachedToken: TokenWithExpiry | null = null
+type Settings = WsTransportTypes['Settings']
 
-const getTokenForConnection = async (
-  apiEndpoint: string,
-  userId: string,
-  publicKey: string,
-  privateKey: string,
-): Promise<string> => {
-  const now = Date.now()
-
-  // If we have a cached token and it won't expire soon, reuse it
-  if (cachedToken && cachedToken.expiresAtMs - now > TOKEN_REFRESH_MARGIN_MS) {
-    return cachedToken.token
+/**
+ * GSR issues access tokens valid for one hour and, when one expires, simply
+ * stops sending data without closing the socket. Left alone, the framework only
+ * notices after WS_SUBSCRIPTION_UNRESPONSIVE_TTL (120s) of silence, by which
+ * point cached prices have already aged out at CACHE_MAX_AGE (90s) and requests
+ * are failing.
+ *
+ * This transport renews the token ahead of expiry, in place, keeping the
+ * connection up. The token travels in the handshake headers, so a successful
+ * renewal is not proof the session survived; continued data is. Whenever that
+ * evidence is missing the transport falls back to reconnecting, early enough
+ * that cached prices are still fresh.
+ */
+export class GsrWebSocketTransport extends WebSocketTransport<WsTransportTypes> {
+  private cachedToken: TokenWithExpiry | null = null
+  private refreshTimer?: NodeJS.Timeout
+  private livenessTimer?: NodeJS.Timeout
+
+  constructor() {
+    super({
+      url: (context) => context.adapterSettings.WS_API_ENDPOINT,
+      options: async (context) => ({
+        headers: {
+          'x-auth-token': await this.tokenForConnection(context.adapterSettings),
+          'x-auth-userid': context.adapterSettings.WS_USER_ID,
+        },
+      }),
+      handlers: {
+        open: async (_connection, context) => {
+          this.scheduleRefresh(context.adapterSettings)
+        },
+        close: (event) => {
+          // Timers only ever live alongside a connection. Without this an idle
+          // adapter — one whose subscriptions have lapsed, so the framework has
+          // no reason to reconnect — would go on renewing tokens and then report
+          // the resulting silence as a failed renewal.
+          this.clearTimers()
+          logger.info(`Connection closed (code=${event.code}, reason=${event.reason || 'none'})`)
+        },
+        message: (message) => this.parsePriceUpdate(message),
+      },
+      builders: {
+        // Note: As of writing this (2022-11-07), GSR has a bug where you cannot subscribe to a pair
+        // after you've already subscribed & unsubscribed to that pair on the same WS connection.
+        subscribeMessage: (params) => ({
+          action: 'subscribe',
+          symbols: [`${params.base}.${params.quote}`.toUpperCase()],
+        }),
+        unsubscribeMessage: (params) => ({
+          action: 'unsubscribe',
+          symbols: [`${params.base}.${params.quote}`.toUpperCase()],
+        }),
+      },
+    })
   }
 
-  // Fetch a fresh token
-  cachedToken = await getToken(apiEndpoint, userId, publicKey, privateKey)
-  const timeUntilExpiry = cachedToken.expiresAtMs - Date.now()
-  logger.info(`Token refresh triggered, expires in ${Math.round(timeUntilExpiry / 1000)}s`)
-
-  return cachedToken.token
-}
-
-// Timers driving the refresh cycle. Cleared and rescheduled on every open,
-// otherwise timers from previous connections would accumulate and act on a
-// healthy connection at an arbitrary later point.
-let refreshTimer: NodeJS.Timeout | undefined
-let livenessTimer: NodeJS.Timeout | undefined
+  /** Reuses the cached token while it has comfortably more life than the refresh margin. */
+  private async tokenForConnection(settings: Settings): Promise<string> {
+    if (this.cachedToken && refreshDelayMs(this.cachedToken, Date.now()) !== null) {
+      return this.cachedToken.token
+    }
 
-// Set on every inbound frame, so the liveness probe can tell whether the
-// provider is still talking to us after an in-place renewal.
-let lastMessageAtMs = 0
+    this.cachedToken = await getToken(
+      settings.API_ENDPOINT,
+      settings.WS_USER_ID,
+      settings.WS_PUBLIC_KEY,
+      settings.WS_PRIVATE_KEY,
+    )
+    return this.cachedToken.token
+  }
 
-const clearTimers = () => {
-  if (refreshTimer) {
-    clearTimeout(refreshTimer)
-    refreshTimer = undefined
+  private clearTimers() {
+    clearTimeout(this.refreshTimer)
+    clearTimeout(this.livenessTimer)
+    this.refreshTimer = undefined
+    this.livenessTimer = undefined
   }
-  if (livenessTimer) {
-    clearTimeout(livenessTimer)
-    livenessTimer = undefined
+
+  private closeForReconnect(reason: string) {
+    logger.info(`${reason}; closing connection to reconnect`)
+    this.cachedToken = null
+    // Close only — deliberately leaving wsConnection set. streamHandler bails
+    // out early when there is no connection *and* no new subscription, so
+    // clearing the field from outside its loop would strand the transport with
+    // nothing to reconnect. Leaving the closed socket in place lets
+    // connectionClosed() report true off readyState and the loop reopens on its
+    // next pass.
+    this.wsConnection?.close(1000)
   }
-}
 
-const closeForReconnect = (reason: string) => {
-  logger.info(`${reason}; closing connection to reconnect`)
-  cachedToken = null
-  // Close only — deliberately leaving wsConnection set. streamHandler bails out
-  // early when there is no connection *and* no new subscription, so clearing the
-  // field from outside its loop would strand the transport with nothing to
-  // reconnect. Leaving the closed socket in place lets connectionClosed() report
-  // true off readyState and the loop reopens on its next pass.
-  transport.wsConnection?.close(1000)
-}
+  private scheduleRefresh(settings: Settings) {
+    // Only the refresh timer: a liveness probe armed by the renewal that just
+    // happened still needs to run.
+    clearTimeout(this.refreshTimer)
+    this.refreshTimer = undefined
 
-/**
- * Renewing the token is an HTTP call; it says nothing about whether GSR extended
- * the session behind the already-open socket, which still carries the old token
- * in its handshake headers. So after a successful renewal we wait until just
- * past the old expiry and check whether frames are still arriving. If they
- * stopped, the renewal did not hold and we fall back to reconnecting — early
- * enough that cached prices have not yet aged out.
- */
-const scheduleLivenessProbe = (previousExpiryMs: number) => {
-  livenessTimer = setTimeout(() => {
-    livenessTimer = undefined
-    if (renewalHeld(lastMessageAtMs, Date.now())) {
-      logger.info('Still receiving data past the previous token expiry; in-place renewal held')
+    if (!this.cachedToken) {
       return
     }
-    closeForReconnect(
-      `No provider data for ${Math.round(
-        (Date.now() - lastMessageAtMs) / 1000,
-      )}s past the previous token expiry, so the in-place renewal did not extend the session`,
-    )
-  }, livenessProbeDelayMs(previousExpiryMs, Date.now()))
-}
 
-const scheduleRefresh = (token: TokenWithExpiry, settings: RefreshSettings) => {
-  const delayMs = refreshDelayMs(token, Date.now())
-  if (delayMs === null) {
-    return
-  }
-  logger.info(
-    `Scheduled token refresh in ${Math.round(delayMs / 1000)}s to prevent ungraceful disconnection`,
-  )
-  refreshTimer = setTimeout(() => {
-    refreshTimer = undefined
-    void refreshTokenOrReconnect(settings)
-  }, delayMs)
-}
-
-/**
- * Preferred path: renew the token in place and leave the connection up. Only
- * tear the socket down if that fails, since a reconnect — while cheap — drops
- * every subscription and re-runs the handshake.
- */
-const refreshTokenOrReconnect = async (settings: RefreshSettings) => {
-  const previous = cachedToken
-  if (!previous) {
-    closeForReconnect('No cached token to renew')
-    return
-  }
+    const delayMs = refreshDelayMs(this.cachedToken, Date.now())
+    if (delayMs === null) {
+      return
+    }
 
-  try {
-    const renewed = await renewToken(
-      settings.apiEndpoint,
-      settings.userId,
-      settings.privateKey,
-      previous.token,
-    )
-    cachedToken = renewed
-    scheduleLivenessProbe(previous.expiresAtMs)
-    scheduleRefresh(renewed, settings)
-  } catch (e) {
-    closeForReconnect(`Token renewal failed (${(e as Error).message})`)
+    logger.info(`Scheduled token refresh in ${Math.round(delayMs / 1000)}s`)
+    this.refreshTimer = setTimeout(() => void this.refreshOrReconnect(settings), delayMs)
   }
-}
 
-type RefreshSettings = {
-  apiEndpoint: string
-  userId: string
-  privateKey: string
-}
+  /** Renew in place, and only tear the connection down if that is refused. */
+  private async refreshOrReconnect(settings: Settings) {
+    const previous = this.cachedToken
+    if (!previous) {
+      this.closeForReconnect('No cached token to renew')
+      return
+    }
 
-export const transport = new WebSocketTransport<WsTransportTypes>({
-  url: (context) => context.adapterSettings.WS_API_ENDPOINT,
-  options: async (context) => ({
-    headers: {
-      'x-auth-token': await getTokenForConnection(
-        context.adapterSettings.API_ENDPOINT,
-        context.adapterSettings.WS_USER_ID,
-        context.adapterSettings.WS_PUBLIC_KEY,
-        context.adapterSettings.WS_PRIVATE_KEY,
-      ),
-      'x-auth-userid': context.adapterSettings.WS_USER_ID,
-    },
-  }),
-  handlers: {
-    open: (_wsConnection, context) => {
-      clearTimers()
-      lastMessageAtMs = Date.now()
-
-      // GSR stops sending messages once the token expires but leaves the socket
-      // open, so the framework only notices after WS_SUBSCRIPTION_UNRESPONSIVE_TTL
-      // (120s) of silence — by which point the cache has already gone stale at
-      // CACHE_MAX_AGE (90s) and requests are failing. Act ahead of expiry, while
-      // data is still flowing.
-      if (cachedToken) {
-        scheduleRefresh(cachedToken, {
-          apiEndpoint: context.adapterSettings.API_ENDPOINT,
-          userId: context.adapterSettings.WS_USER_ID,
-          privateKey: context.adapterSettings.WS_PRIVATE_KEY,
-        })
-      }
-      return Promise.resolve()
-    },
-    close: (closeEvent) => {
-      // Distinguishes a close initiated by GSR from one the framework's
-      // unresponsiveness watchdog performed after the provider went silent.
-      logger.info(
-        `Connection closed (code=${closeEvent.code}, reason=${closeEvent.reason || 'none'})`,
+    try {
+      this.cachedToken = await renewToken(
+        settings.API_ENDPOINT,
+        settings.WS_USER_ID,
+        settings.WS_PRIVATE_KEY,
+        previous.token,
       )
-    },
-    message(message): ProviderResult<WsTransportTypes>[] | undefined {
-      // Any frame proves the provider is still talking to us, whatever its type.
-      lastMessageAtMs = Date.now()
+    } catch (e) {
+      this.closeForReconnect(`Token renewal failed (${(e as Error).message})`)
+      return
+    }
 
-      if (message.type == 'error') {
-        logger.error(`Got error from DP: ${JSON.stringify(message)}`)
-        return
-      } else if (message.type != 'ticker') {
-        return
-      }
+    this.scheduleRefresh(settings)
+    this.scheduleLivenessProbe(previous.expiresAtMs)
+  }
 
-      const pair = message.data.symbol.split('.')
-      if (pair.length != 2) {
-        logger.warn(`Got a price update with an unknown pair: ${message.data.symbol}`)
+  /**
+   * Checks shortly after the old expiry that GSR is still feeding us. This is
+   * the only real evidence the renewal extended the session, since the socket
+   * still carries the original token in its handshake headers.
+   */
+  private scheduleLivenessProbe(previousExpiryMs: number) {
+    this.livenessTimer = setTimeout(() => {
+      this.livenessTimer = undefined
+      const now = Date.now()
+      if (renewalHeld(this.lastMessageReceivedAt, now)) {
+        logger.info('Still receiving data past the previous token expiry; renewal held')
         return
       }
+      this.closeForReconnect(
+        `No provider data for ${Math.round(
+          (now - this.lastMessageReceivedAt) / 1000,
+        )}s past the previous token expiry, so the renewal did not extend the session`,
+      )
+    }, livenessProbeDelayMs(previousExpiryMs, Date.now()))
+  }
 
-      return [
-        {
-          params: {
-            base: pair[0].toString(),
-            quote: pair[1].toString(),
-          },
-          response: {
+  private parsePriceUpdate(message: WsMessage): ProviderResult<WsTransportTypes>[] | undefined {
+    if (message.type == 'error') {
+      logger.error(`Got error from DP: ${JSON.stringify(message)}`)
+      return
+    } else if (message.type != 'ticker') {
+      return
+    }
+
+    const pair = message.data.symbol.split('.')
+    if (pair.length != 2) {
+      logger.warn(`Got a price update with an unknown pair: ${message.data.symbol}`)
+      return
+    }
+
+    return [
+      {
+        params: {
+          base: pair[0].toString(),
+          quote: pair[1].toString(),
+        },
+        response: {
+          result: message.data.price,
+          data: {
             result: message.data.price,
-            data: {
-              result: message.data.price,
-              mid: message.data.price,
-              bid: message.data.bidPrice,
-              ask: message.data.askPrice,
-            },
-            timestamps: {
-              providerIndicatedTimeUnixMs: Math.round(message.data.ts / 1e6), // Value from provider is in nanoseconds
-            },
+            mid: message.data.price,
+            bid: message.data.bidPrice,
+            ask: message.data.askPrice,
+          },
+          timestamps: {
+            providerIndicatedTimeUnixMs: Math.round(message.data.ts / 1e6), // Value from provider is in nanoseconds
           },
         },
-      ]
-    },
-  },
-  builders: {
-    // Note: As of writing this (2022-11-07), GSR has a bug where you cannot subscribe to a pair
-    // after you've already subscribed & unsubscribed to that pair on the same WS connection.
-    subscribeMessage: (params) => ({
-      action: 'subscribe',
-      symbols: [`${params.base}.${params.quote}`.toUpperCase()],
-    }),
-    unsubscribeMessage: (params) => ({
-      action: 'unsubscribe',
-      symbols: [`${params.base}.${params.quote}`.toUpperCase()],
-    }),
-  },
-})
+      },
+    ]
+  }
+}
+
+export const transport = new GsrWebSocketTransport()

From 28af65e9519c970a3b62aeba8b8a5723d47a917c Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Fri, 7 Aug 2026 14:19:43 -0700
Subject: [PATCH 07/16] adds missing files

---
 .../sources/gsr/src/transport/tokenRefresh.ts | 44 +++++++++++
 .../test/unit/token-refresh-policy.test.ts    | 77 +++++++++++++++++++
 2 files changed, 121 insertions(+)
 create mode 100644 packages/sources/gsr/src/transport/tokenRefresh.ts
 create mode 100644 packages/sources/gsr/test/unit/token-refresh-policy.test.ts

diff --git a/packages/sources/gsr/src/transport/tokenRefresh.ts b/packages/sources/gsr/src/transport/tokenRefresh.ts
new file mode 100644
index 00000000000..fb7fa35c39c
--- /dev/null
+++ b/packages/sources/gsr/src/transport/tokenRefresh.ts
@@ -0,0 +1,44 @@
+import { TokenWithExpiry } from './authutils'
+
+/** How far ahead of expiry to act, so the provider is still sending data. */
+export const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000
+
+/**
+ * How long past the old expiry to let the connection prove itself before
+ * concluding an in-place renewal did not take. Must leave room to reconnect
+ * before cached prices go stale at CACHE_MAX_AGE (90s from the last message).
+ */
+export const LIVENESS_GRACE_MS = 20 * 1000
+
+/**
+ * setTimeout coerces any delay above this to 1ms. Left unclamped, an
+ * implausibly distant expiry would fire the refresh immediately on every open,
+ * turning this mechanism into a reconnect loop.
+ */
+export const MAX_TIMEOUT_MS = 2 ** 31 - 1
+
+/**
+ * Delay until the next refresh attempt, or null when the token is already
+ * inside the margin and there is nothing useful to schedule.
+ */
+export const refreshDelayMs = (token: TokenWithExpiry, nowMs: number): number | null => {
+  const delay = token.expiresAtMs - nowMs - TOKEN_REFRESH_MARGIN_MS
+  return delay > 0 ? Math.min(delay, MAX_TIMEOUT_MS) : null
+}
+
+/**
+ * Delay until we check whether a renewal actually kept the session alive.
+ * Clamped at zero because the expiry may already have passed by the time the
+ * renewal call returns.
+ */
+export const livenessProbeDelayMs = (previousExpiryMs: number, nowMs: number): number =>
+  Math.min(Math.max(0, previousExpiryMs + LIVENESS_GRACE_MS - nowMs), MAX_TIMEOUT_MS)
+
+/**
+ * Whether the provider is still sending. A renewal returning HTTP 200 says the
+ * token was renewed, not that GSR extended the session behind the socket, which
+ * still carries the original token in its handshake headers. Continued traffic
+ * is the only real evidence.
+ */
+export const renewalHeld = (lastMessageAtMs: number, nowMs: number): boolean =>
+  nowMs - lastMessageAtMs <= LIVENESS_GRACE_MS
diff --git a/packages/sources/gsr/test/unit/token-refresh-policy.test.ts b/packages/sources/gsr/test/unit/token-refresh-policy.test.ts
new file mode 100644
index 00000000000..14832c81238
--- /dev/null
+++ b/packages/sources/gsr/test/unit/token-refresh-policy.test.ts
@@ -0,0 +1,77 @@
+import {
+  LIVENESS_GRACE_MS,
+  livenessProbeDelayMs,
+  MAX_TIMEOUT_MS,
+  refreshDelayMs,
+  renewalHeld,
+  TOKEN_REFRESH_MARGIN_MS,
+} from '../../src/transport/tokenRefresh'
+
+const NOW = new Date('2026-08-06T12:00:00.000Z').getTime()
+const ONE_HOUR_MS = 60 * 60 * 1000
+
+describe('refreshDelayMs', () => {
+  it('schedules the refresh a margin ahead of expiry', () => {
+    const token = { token: 't', expiresAtMs: NOW + ONE_HOUR_MS }
+
+    // GSR issues hour-long tokens, so the refresh lands at the 55 minute mark.
+    expect(refreshDelayMs(token, NOW)).toEqual(ONE_HOUR_MS - TOKEN_REFRESH_MARGIN_MS)
+  })
+
+  it('returns null when the token is already inside the margin', () => {
+    const token = { token: 't', expiresAtMs: NOW + TOKEN_REFRESH_MARGIN_MS - 1 }
+
+    // Nothing useful to schedule; the connection path will mint a fresh token.
+    expect(refreshDelayMs(token, NOW)).toBeNull()
+  })
+
+  it('returns null for an already expired token', () => {
+    expect(refreshDelayMs({ token: 't', expiresAtMs: NOW - 1 }, NOW)).toBeNull()
+  })
+
+  it('clamps an implausibly distant expiry instead of overflowing setTimeout', () => {
+    // Delays above 2^31-1 are silently coerced to 1ms by setTimeout, which would
+    // fire the refresh immediately on every open and spin into a reconnect loop.
+    const token = { token: 't', expiresAtMs: NOW + 100 * 365 * 24 * ONE_HOUR_MS }
+
+    expect(refreshDelayMs(token, NOW)).toEqual(MAX_TIMEOUT_MS)
+  })
+})
+
+describe('livenessProbeDelayMs', () => {
+  it('probes a grace period after the previous expiry', () => {
+    expect(livenessProbeDelayMs(NOW + 60_000, NOW)).toEqual(60_000 + LIVENESS_GRACE_MS)
+  })
+
+  it('probes immediately when the expiry has already passed', () => {
+    // The renewal call itself can straddle the boundary on a slow response.
+    expect(livenessProbeDelayMs(NOW - LIVENESS_GRACE_MS - 5_000, NOW)).toEqual(0)
+  })
+
+  it('never returns a negative delay', () => {
+    expect(livenessProbeDelayMs(NOW - ONE_HOUR_MS, NOW)).toBeGreaterThanOrEqual(0)
+  })
+})
+
+describe('renewalHeld', () => {
+  it('treats recent traffic as proof the session survived', () => {
+    expect(renewalHeld(NOW - 1_000, NOW)).toBe(true)
+  })
+
+  it('treats silence past the grace period as a failed renewal', () => {
+    // HTTP 200 on the renewal does not mean GSR extended the session behind the
+    // socket; only continued traffic does.
+    expect(renewalHeld(NOW - LIVENESS_GRACE_MS - 1, NOW)).toBe(false)
+  })
+
+  it('is inclusive at the grace boundary', () => {
+    expect(renewalHeld(NOW - LIVENESS_GRACE_MS, NOW)).toBe(true)
+  })
+
+  it('reconnects well before cached prices go stale', () => {
+    // CACHE_MAX_AGE is 90s from the last message. Detecting at the grace
+    // boundary has to leave room for a reconnect inside that window, otherwise
+    // requests start 504ing again.
+    expect(LIVENESS_GRACE_MS).toBeLessThan(90_000)
+  })
+})

From 9d77f0a27067b7863f1e1b0a284b755fefb9ab28 Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Sun, 9 Aug 2026 06:04:05 -0700
Subject: [PATCH 08/16] adds workflow for deploying to soak changes

---
 .github/workflows/publish-internal.yml        | 177 ++++++++++++++++++
 ...oken-refresh.test.ts => authutils.test.ts} |   0
 2 files changed, 177 insertions(+)
 create mode 100644 .github/workflows/publish-internal.yml
 rename packages/sources/gsr/test/unit/{token-refresh.test.ts => authutils.test.ts} (100%)

diff --git a/.github/workflows/publish-internal.yml b/.github/workflows/publish-internal.yml
new file mode 100644
index 00000000000..104533869c4
--- /dev/null
+++ b/.github/workflows/publish-internal.yml
@@ -0,0 +1,177 @@
+# Builds a single adapter from the current branch and pushes it to the private
+# ECR, so an unreleased change can be referenced from infra-k8s.
+#
+# The regular path to a private image is deploy.yml, which only fires on a push
+# to main that touches MASTERLIST.md — that is, on a release. This workflow
+# fills the gap for testing a change before it is released.
+#
+# It deliberately does NOT tag `latest` and does NOT notify infra-k8s. Images
+# land under a `-dev.<sha>` tag that cannot collide with a release tag, and
+# referencing one is a manual step in infra-k8s.
+name: Publish Internal Adapter Image
+
+on:
+  workflow_dispatch:
+    inputs:
+      adapter:
+        description: Adapter short name, as used in the ECR repo (e.g. "gsr")
+        required: true
+        type: string
+      image-tag:
+        description: Overrides the default "<version>-dev.<short-sha>" tag. Must not be a released version or "latest".
+        required: false
+        type: string
+
+# Shares the deploy-and-release group so an internal build cannot race a release
+# that is pushing to the same repository.
+concurrency:
+  group: deploy-and-release
+  cancel-in-progress: false
+
+jobs:
+  resolve-adapter:
+    name: Resolve ${{ inputs.adapter }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    outputs:
+      package-name: ${{ steps.resolve.outputs.PACKAGE_NAME }}
+      location: ${{ steps.resolve.outputs.LOCATION }}
+      image-tag: ${{ steps.resolve.outputs.IMAGE_TAG }}
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+      - name: Set up and install dependencies
+        uses: ./.github/actions/setup
+        with:
+          skip-setup: true
+      - name: Resolve adapter workspace and image tag
+        id: resolve
+        env:
+          ADAPTER: ${{ inputs.adapter }}
+          TAG_OVERRIDE: ${{ inputs.image-tag }}
+        run: |
+          set -euo pipefail
+
+          package_name="@chainlink/${ADAPTER}-adapter"
+          location=$(yarn workspaces list --json \
+            | jq -rc --arg n "$package_name" 'select(.name == $n) | .location')
+
+          if [ -z "$location" ]; then
+            echo "::error::No workspace named ${package_name}. Pass the adapter short name, e.g. \"gsr\"."
+            exit 1
+          fi
+
+          version=$(jq -r '.version' "${location}/package.json")
+
+          if [ -n "$TAG_OVERRIDE" ]; then
+            image_tag="$TAG_OVERRIDE"
+            # A release build would overwrite these, so refuse them outright.
+            if [ "$image_tag" = "latest" ] || [ "$image_tag" = "$version" ]; then
+              echo "::error::Refusing to publish over the released tag \"${image_tag}\"."
+              exit 1
+            fi
+          else
+            image_tag="${version}-dev.${GITHUB_SHA::8}"
+          fi
+
+          # ECR tags are limited to this character set; fail early rather than
+          # deep inside the build.
+          if ! printf '%s' "$image_tag" | grep -qE '^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$'; then
+            echo "::error::\"${image_tag}\" is not a valid ECR tag."
+            exit 1
+          fi
+
+          {
+            echo "PACKAGE_NAME=${package_name}"
+            echo "LOCATION=${location}"
+            echo "IMAGE_TAG=${image_tag}"
+          } >> "$GITHUB_OUTPUT"
+
+          echo "Building ${package_name} from ${location} as ${image_tag}"
+
+  create-ecr:
+    name: Create ECR for ${{ inputs.adapter }}
+    runs-on: ubuntu-latest
+    needs: [resolve-adapter]
+    permissions: # These are needed for the configure-aws-credentials action
+      id-token: write
+      contents: read
+    environment: release
+    env:
+      ECR_URL: ${{ secrets.SDLC_ACCOUNT_ID }}.dkr.ecr.${{ secrets.AWS_REGION_ECR_PRIVATE }}.amazonaws.com
+      ECR_REPO: adapters/${{ inputs.adapter }}-adapter
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+      - name: Create ECR for ${{ inputs.adapter }}
+        uses: ./.github/actions/create-ecrs
+        with:
+          aws-ecr-url: ${{ env.ECR_URL }}
+          aws-ecr-repo: ${{ env.ECR_REPO }}
+          aws-region: ${{ secrets.AWS_REGION_ECR_PRIVATE }}
+          aws-role: ${{ secrets.AWS_OIDC_IAM_ROLE_ARN }}
+          aws-ecr-account-ids: ${{ secrets.AWS_PRIVATE_ECR_SECONDARY_ACCOUNT_ACCESS_IDS }}
+          aws-ecr-private: true
+
+  build-publish:
+    name: Build and publish ${{ inputs.adapter }}
+    permissions:
+      contents: read
+      id-token: write
+    needs: [resolve-adapter, create-ecr]
+    uses: smartcontractkit/.github/.github/workflows/reusable-docker-build-publish.yml@ce87497eb287565c796a8a781508be949f3ed1e2 # 2025-10-10
+    with:
+      aws-ecr-name: adapters/${{ inputs.adapter }}-adapter
+      aws-region-ecr: us-west-2
+      dockerfile: ./Dockerfile
+      docker-build-args: |
+        package=${{ needs.resolve-adapter.outputs.package-name }}
+        location=${{ needs.resolve-adapter.outputs.location }}
+      docker-build-context: .
+      docker-image-tag-override: ${{ needs.resolve-adapter.outputs.image-tag }}
+      # Intentionally no docker-manifest-additional-tags: tagging `latest` here
+      # would repoint every consumer of the released image at an unreleased build.
+      docker-push: true
+      environment: release
+      git-sha: ${{ github.sha }}
+      github-event-name: ${{ github.event_name }}
+      github-ref-name: ${{ github.ref_name }}
+      github-ref-type: ${{ github.ref_type }}
+      github-workflow-repository: ${{ github.repository }}
+      github-runner-arm64: ubuntu-24.04-2cores-8GB-ARM
+      github-runner-amd64: ubuntu-24.04
+    secrets:
+      AWS_ACCOUNT_ID: ${{ secrets.SDLC_ACCOUNT_ID }}
+      AWS_ROLE_PUBLISH_ARN: ${{ secrets.AWS_OIDC_IAM_ROLE_ARN }}
+
+  report-image:
+    name: Report image reference
+    runs-on: ubuntu-latest
+    needs: [resolve-adapter, build-publish]
+    permissions:
+      contents: read
+    steps:
+      - name: Write image reference to the job summary
+        env:
+          ECR_REPO: adapters/${{ inputs.adapter }}-adapter
+          IMAGE_TAG: ${{ needs.resolve-adapter.outputs.image-tag }}
+          REF_NAME: ${{ github.ref_name }}
+        run: |
+          {
+            echo "### Internal image published"
+            echo
+            echo "| | |"
+            echo "|---|---|"
+            echo "| Repository | \`${ECR_REPO}\` |"
+            echo "| Tag | \`${IMAGE_TAG}\` |"
+            echo "| Branch | \`${REF_NAME}\` |"
+            echo "| Commit | \`${GITHUB_SHA}\` |"
+            echo
+            echo "Reference it in infra-k8s against the same private ECR registry used by the"
+            echo "release pipeline, i.e. \`<sdlc-account>.dkr.ecr.<region>.amazonaws.com/${ECR_REPO}:${IMAGE_TAG}\`."
+            echo
+            echo "This tag was not applied to \`latest\` and infra-k8s was not notified."
+          } >> "$GITHUB_STEP_SUMMARY"
diff --git a/packages/sources/gsr/test/unit/token-refresh.test.ts b/packages/sources/gsr/test/unit/authutils.test.ts
similarity index 100%
rename from packages/sources/gsr/test/unit/token-refresh.test.ts
rename to packages/sources/gsr/test/unit/authutils.test.ts

From ac0694ab4d3e8a4831743d99301f383f2929a361 Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Sun, 9 Aug 2026 06:15:55 -0700
Subject: [PATCH 09/16] clean up tests

---
 .../test/unit/token-refresh-policy.test.ts    | 77 -------------------
 1 file changed, 77 deletions(-)
 delete mode 100644 packages/sources/gsr/test/unit/token-refresh-policy.test.ts

diff --git a/packages/sources/gsr/test/unit/token-refresh-policy.test.ts b/packages/sources/gsr/test/unit/token-refresh-policy.test.ts
deleted file mode 100644
index 14832c81238..00000000000
--- a/packages/sources/gsr/test/unit/token-refresh-policy.test.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import {
-  LIVENESS_GRACE_MS,
-  livenessProbeDelayMs,
-  MAX_TIMEOUT_MS,
-  refreshDelayMs,
-  renewalHeld,
-  TOKEN_REFRESH_MARGIN_MS,
-} from '../../src/transport/tokenRefresh'
-
-const NOW = new Date('2026-08-06T12:00:00.000Z').getTime()
-const ONE_HOUR_MS = 60 * 60 * 1000
-
-describe('refreshDelayMs', () => {
-  it('schedules the refresh a margin ahead of expiry', () => {
-    const token = { token: 't', expiresAtMs: NOW + ONE_HOUR_MS }
-
-    // GSR issues hour-long tokens, so the refresh lands at the 55 minute mark.
-    expect(refreshDelayMs(token, NOW)).toEqual(ONE_HOUR_MS - TOKEN_REFRESH_MARGIN_MS)
-  })
-
-  it('returns null when the token is already inside the margin', () => {
-    const token = { token: 't', expiresAtMs: NOW + TOKEN_REFRESH_MARGIN_MS - 1 }
-
-    // Nothing useful to schedule; the connection path will mint a fresh token.
-    expect(refreshDelayMs(token, NOW)).toBeNull()
-  })
-
-  it('returns null for an already expired token', () => {
-    expect(refreshDelayMs({ token: 't', expiresAtMs: NOW - 1 }, NOW)).toBeNull()
-  })
-
-  it('clamps an implausibly distant expiry instead of overflowing setTimeout', () => {
-    // Delays above 2^31-1 are silently coerced to 1ms by setTimeout, which would
-    // fire the refresh immediately on every open and spin into a reconnect loop.
-    const token = { token: 't', expiresAtMs: NOW + 100 * 365 * 24 * ONE_HOUR_MS }
-
-    expect(refreshDelayMs(token, NOW)).toEqual(MAX_TIMEOUT_MS)
-  })
-})
-
-describe('livenessProbeDelayMs', () => {
-  it('probes a grace period after the previous expiry', () => {
-    expect(livenessProbeDelayMs(NOW + 60_000, NOW)).toEqual(60_000 + LIVENESS_GRACE_MS)
-  })
-
-  it('probes immediately when the expiry has already passed', () => {
-    // The renewal call itself can straddle the boundary on a slow response.
-    expect(livenessProbeDelayMs(NOW - LIVENESS_GRACE_MS - 5_000, NOW)).toEqual(0)
-  })
-
-  it('never returns a negative delay', () => {
-    expect(livenessProbeDelayMs(NOW - ONE_HOUR_MS, NOW)).toBeGreaterThanOrEqual(0)
-  })
-})
-
-describe('renewalHeld', () => {
-  it('treats recent traffic as proof the session survived', () => {
-    expect(renewalHeld(NOW - 1_000, NOW)).toBe(true)
-  })
-
-  it('treats silence past the grace period as a failed renewal', () => {
-    // HTTP 200 on the renewal does not mean GSR extended the session behind the
-    // socket; only continued traffic does.
-    expect(renewalHeld(NOW - LIVENESS_GRACE_MS - 1, NOW)).toBe(false)
-  })
-
-  it('is inclusive at the grace boundary', () => {
-    expect(renewalHeld(NOW - LIVENESS_GRACE_MS, NOW)).toBe(true)
-  })
-
-  it('reconnects well before cached prices go stale', () => {
-    // CACHE_MAX_AGE is 90s from the last message. Detecting at the grace
-    // boundary has to leave room for a reconnect inside that window, otherwise
-    // requests start 504ing again.
-    expect(LIVENESS_GRACE_MS).toBeLessThan(90_000)
-  })
-})

From 086b0e88f431150282e91d58bb51fea84cf97ed4 Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Sun, 9 Aug 2026 06:25:57 -0700
Subject: [PATCH 10/16] internal release

---
 .github/workflows/publish-internal.yml | 193 ++++++++++++++++---------
 1 file changed, 126 insertions(+), 67 deletions(-)

diff --git a/.github/workflows/publish-internal.yml b/.github/workflows/publish-internal.yml
index 104533869c4..e85311ac768 100644
--- a/.github/workflows/publish-internal.yml
+++ b/.github/workflows/publish-internal.yml
@@ -1,13 +1,21 @@
-# Builds a single adapter from the current branch and pushes it to the private
-# ECR, so an unreleased change can be referenced from infra-k8s.
+# Builds adapters from an unreleased branch and pushes them to the private ECR,
+# so a change can be referenced from infra-k8s before it is released.
 #
 # The regular path to a private image is deploy.yml, which only fires on a push
 # to main that touches MASTERLIST.md — that is, on a release. This workflow
-# fills the gap for testing a change before it is released.
+# fills the gap for soaking a change beforehand.
+#
+# Two ways in:
+#   * Label a PR with `build-internal-image` to build the adapters it changes.
+#     A pull_request workflow runs from the PR branch, so this works before the
+#     workflow itself is on main. Pushing further commits rebuilds the new head.
+#   * Dispatch it manually against any ref, naming the adapter. Only available
+#     once this file is on the default branch, which is a GitHub restriction on
+#     workflow_dispatch rather than anything about this workflow.
 #
 # It deliberately does NOT tag `latest` and does NOT notify infra-k8s. Images
-# land under a `-dev.<sha>` tag that cannot collide with a release tag, and
-# referencing one is a manual step in infra-k8s.
+# land under a tag that cannot collide with a release, and referencing one is a
+# manual step in infra-k8s.
 name: Publish Internal Adapter Image
 
 on:
@@ -21,92 +29,117 @@ on:
         description: Overrides the default "<version>-dev.<short-sha>" tag. Must not be a released version or "latest".
         required: false
         type: string
+  pull_request:
+    # `labeled` starts a build on demand; `synchronize` keeps an already-labelled
+    # PR's image tracking its latest commit.
+    types: [labeled, synchronize]
 
-# Shares the deploy-and-release group so an internal build cannot race a release
-# that is pushing to the same repository.
+# Keyed per PR (or per ref when dispatched) so a new push supersedes a build
+# that is already running, rather than queueing behind it.
 concurrency:
-  group: deploy-and-release
-  cancel-in-progress: false
+  group: publish-internal-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
 
 jobs:
-  resolve-adapter:
-    name: Resolve ${{ inputs.adapter }}
+  resolve-adapters:
+    name: Resolve adapters to build
     runs-on: ubuntu-latest
+    # On a PR this only proceeds once the opt-in label is present. Checking the
+    # label set rather than github.event.label covers `synchronize`, where no
+    # single label triggered the run.
+    if: >-
+      github.event_name == 'workflow_dispatch' ||
+      contains(github.event.pull_request.labels.*.name, 'build-internal-image')
     permissions:
       contents: read
     outputs:
-      package-name: ${{ steps.resolve.outputs.PACKAGE_NAME }}
-      location: ${{ steps.resolve.outputs.LOCATION }}
-      image-tag: ${{ steps.resolve.outputs.IMAGE_TAG }}
+      adapter-list: ${{ steps.resolve.outputs.ADAPTER_LIST }}
+      build-sha: ${{ steps.resolve.outputs.BUILD_SHA }}
+      tag-suffix: ${{ steps.resolve.outputs.TAG_SUFFIX }}
     steps:
       - uses: actions/checkout@v5
         with:
           persist-credentials: false
+          # On a pull_request event the default checkout is the merge commit.
+          # Build the branch head instead, so the image matches the commit
+          # under review rather than a merge that exists only in CI.
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
+          fetch-depth: 0
       - name: Set up and install dependencies
         uses: ./.github/actions/setup
         with:
           skip-setup: true
-      - name: Resolve adapter workspace and image tag
+          base-branch: origin/${{ github.base_ref || 'main' }}
+      - name: Resolve adapter list and tag suffix
         id: resolve
         env:
+          EVENT_NAME: ${{ github.event_name }}
           ADAPTER: ${{ inputs.adapter }}
           TAG_OVERRIDE: ${{ inputs.image-tag }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          BUILD_SHA: ${{ github.event.pull_request.head.sha || github.sha }}
+          UPSTREAM_BRANCH: origin/${{ github.base_ref || 'main' }}
         run: |
           set -euo pipefail
 
-          package_name="@chainlink/${ADAPTER}-adapter"
-          location=$(yarn workspaces list --json \
-            | jq -rc --arg n "$package_name" 'select(.name == $n) | .location')
+          # Both paths go through the same script the release pipeline uses, so
+          # each entry carries the name, location, version and shortName that the
+          # build matrix below expects. Called with no argument it lists every
+          # adapter; with an upstream ref, only those that changed against it.
+          if [ "$EVENT_NAME" = "workflow_dispatch" ]; then
+            adapter_list=$(./.github/scripts/list-packages-adapters.sh \
+              | jq -c --arg s "$ADAPTER" '{adapter: [.adapters[] | select(.shortName == $s)]}')
 
-          if [ -z "$location" ]; then
-            echo "::error::No workspace named ${package_name}. Pass the adapter short name, e.g. \"gsr\"."
-            exit 1
-          fi
+            if [ "$(echo "$adapter_list" | jq '.adapter | length')" -eq 0 ]; then
+              echo "::error::No adapter named \"${ADAPTER}\". Pass the short name, e.g. \"gsr\"."
+              exit 1
+            fi
 
-          version=$(jq -r '.version' "${location}/package.json")
+            tag_suffix="dev.${BUILD_SHA:0:8}"
+          else
+            adapter_list=$(./.github/scripts/list-packages-adapters.sh "$UPSTREAM_BRANCH" \
+              | jq -c '{adapter: .adapters}')
+            tag_suffix="pr${PR_NUMBER}.${BUILD_SHA:0:8}"
+          fi
 
           if [ -n "$TAG_OVERRIDE" ]; then
-            image_tag="$TAG_OVERRIDE"
             # A release build would overwrite these, so refuse them outright.
-            if [ "$image_tag" = "latest" ] || [ "$image_tag" = "$version" ]; then
-              echo "::error::Refusing to publish over the released tag \"${image_tag}\"."
+            if [ "$TAG_OVERRIDE" = "latest" ]; then
+              echo "::error::Refusing to publish over \"latest\"."
               exit 1
             fi
-          else
-            image_tag="${version}-dev.${GITHUB_SHA::8}"
-          fi
-
-          # ECR tags are limited to this character set; fail early rather than
-          # deep inside the build.
-          if ! printf '%s' "$image_tag" | grep -qE '^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$'; then
-            echo "::error::\"${image_tag}\" is not a valid ECR tag."
-            exit 1
+            tag_suffix="$TAG_OVERRIDE"
           fi
 
           {
-            echo "PACKAGE_NAME=${package_name}"
-            echo "LOCATION=${location}"
-            echo "IMAGE_TAG=${image_tag}"
+            echo "ADAPTER_LIST=${adapter_list}"
+            echo "BUILD_SHA=${BUILD_SHA}"
+            echo "TAG_SUFFIX=${tag_suffix}"
           } >> "$GITHUB_OUTPUT"
 
-          echo "Building ${package_name} from ${location} as ${image_tag}"
+          echo "Building $(echo "$adapter_list" | jq -c '[.adapter[].shortName]') from ${BUILD_SHA}"
 
   create-ecr:
-    name: Create ECR for ${{ inputs.adapter }}
+    name: Create ECR for ${{ matrix.adapter.shortName }}
     runs-on: ubuntu-latest
-    needs: [resolve-adapter]
+    needs: [resolve-adapters]
+    if: needs.resolve-adapters.outputs.adapter-list != '{"adapter":[]}'
     permissions: # These are needed for the configure-aws-credentials action
       id-token: write
       contents: read
     environment: release
+    strategy:
+      max-parallel: 20
+      matrix: ${{ fromJson(needs.resolve-adapters.outputs.adapter-list) }}
     env:
       ECR_URL: ${{ secrets.SDLC_ACCOUNT_ID }}.dkr.ecr.${{ secrets.AWS_REGION_ECR_PRIVATE }}.amazonaws.com
-      ECR_REPO: adapters/${{ inputs.adapter }}-adapter
+      ECR_REPO: adapters/${{ matrix.adapter.shortName }}-adapter
     steps:
       - uses: actions/checkout@v5
         with:
           persist-credentials: false
-      - name: Create ECR for ${{ inputs.adapter }}
+          ref: ${{ needs.resolve-adapters.outputs.build-sha }}
+      - name: Create ECR for ${{ matrix.adapter.shortName }}
         uses: ./.github/actions/create-ecrs
         with:
           aws-ecr-url: ${{ env.ECR_URL }}
@@ -117,26 +150,29 @@ jobs:
           aws-ecr-private: true
 
   build-publish:
-    name: Build and publish ${{ inputs.adapter }}
+    name: Build and publish ${{ matrix.adapter.shortName }}
     permissions:
       contents: read
       id-token: write
-    needs: [resolve-adapter, create-ecr]
+    needs: [resolve-adapters, create-ecr]
+    strategy:
+      max-parallel: 20
+      matrix: ${{ fromJson(needs.resolve-adapters.outputs.adapter-list) }}
     uses: smartcontractkit/.github/.github/workflows/reusable-docker-build-publish.yml@ce87497eb287565c796a8a781508be949f3ed1e2 # 2025-10-10
     with:
-      aws-ecr-name: adapters/${{ inputs.adapter }}-adapter
+      aws-ecr-name: adapters/${{ matrix.adapter.shortName }}-adapter
       aws-region-ecr: us-west-2
       dockerfile: ./Dockerfile
       docker-build-args: |
-        package=${{ needs.resolve-adapter.outputs.package-name }}
-        location=${{ needs.resolve-adapter.outputs.location }}
+        package=${{ matrix.adapter.name }}
+        location=${{ matrix.adapter.location }}
       docker-build-context: .
-      docker-image-tag-override: ${{ needs.resolve-adapter.outputs.image-tag }}
+      docker-image-tag-override: ${{ matrix.adapter.version }}-${{ needs.resolve-adapters.outputs.tag-suffix }}
       # Intentionally no docker-manifest-additional-tags: tagging `latest` here
       # would repoint every consumer of the released image at an unreleased build.
       docker-push: true
       environment: release
-      git-sha: ${{ github.sha }}
+      git-sha: ${{ needs.resolve-adapters.outputs.build-sha }}
       github-event-name: ${{ github.event_name }}
       github-ref-name: ${{ github.ref_name }}
       github-ref-type: ${{ github.ref_type }}
@@ -147,31 +183,54 @@ jobs:
       AWS_ACCOUNT_ID: ${{ secrets.SDLC_ACCOUNT_ID }}
       AWS_ROLE_PUBLISH_ARN: ${{ secrets.AWS_OIDC_IAM_ROLE_ARN }}
 
-  report-image:
-    name: Report image reference
+  report-images:
+    name: Report image references
     runs-on: ubuntu-latest
-    needs: [resolve-adapter, build-publish]
+    needs: [resolve-adapters, build-publish]
     permissions:
       contents: read
+      pull-requests: write
     steps:
-      - name: Write image reference to the job summary
+      - name: Build reference list
+        id: refs
         env:
-          ECR_REPO: adapters/${{ inputs.adapter }}-adapter
-          IMAGE_TAG: ${{ needs.resolve-adapter.outputs.image-tag }}
-          REF_NAME: ${{ github.ref_name }}
+          ADAPTER_LIST: ${{ needs.resolve-adapters.outputs.adapter-list }}
+          TAG_SUFFIX: ${{ needs.resolve-adapters.outputs.tag-suffix }}
+          BUILD_SHA: ${{ needs.resolve-adapters.outputs.build-sha }}
         run: |
+          set -euo pipefail
+          body=$(echo "$ADAPTER_LIST" | jq -r --arg s "$TAG_SUFFIX" '
+            .adapter[] | "- `adapters/\(.shortName)-adapter:\(.version)-\($s)`"')
           {
-            echo "### Internal image published"
+            echo "### Internal images published"
             echo
-            echo "| | |"
-            echo "|---|---|"
-            echo "| Repository | \`${ECR_REPO}\` |"
-            echo "| Tag | \`${IMAGE_TAG}\` |"
-            echo "| Branch | \`${REF_NAME}\` |"
-            echo "| Commit | \`${GITHUB_SHA}\` |"
+            echo "$body"
             echo
-            echo "Reference it in infra-k8s against the same private ECR registry used by the"
-            echo "release pipeline, i.e. \`<sdlc-account>.dkr.ecr.<region>.amazonaws.com/${ECR_REPO}:${IMAGE_TAG}\`."
+            echo "Built from \`${BUILD_SHA}\`."
             echo
-            echo "This tag was not applied to \`latest\` and infra-k8s was not notified."
+            echo "Reference these against the private ECR registry the release pipeline uses."
+            echo "\`latest\` was not moved and infra-k8s was not notified."
           } >> "$GITHUB_STEP_SUMMARY"
+
+          {
+            echo 'BODY<<EOF'
+            echo "Internal images published from \`${BUILD_SHA}\`:"
+            echo
+            echo "$body"
+            echo
+            echo "_\`latest\` was not moved and infra-k8s was not notified._"
+            echo 'EOF'
+          } >> "$GITHUB_OUTPUT"
+      - name: Comment on the PR
+        if: github.event_name == 'pull_request'
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        env:
+          BODY: ${{ steps.refs.outputs.BODY }}
+        with:
+          script: |
+            const {owner, repo} = context.repo;
+            await github.rest.issues.createComment({
+              owner, repo,
+              issue_number: context.payload.pull_request.number,
+              body: process.env.BODY,
+            });

From 3988a7010c7fda871ad2f010de0226cd54ce9fdd Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Sun, 9 Aug 2026 06:28:39 -0700
Subject: [PATCH 11/16] adds unit tests

---
 .../gsr/test/unit/tokenRefresh.test.ts        | 77 +++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 packages/sources/gsr/test/unit/tokenRefresh.test.ts

diff --git a/packages/sources/gsr/test/unit/tokenRefresh.test.ts b/packages/sources/gsr/test/unit/tokenRefresh.test.ts
new file mode 100644
index 00000000000..14832c81238
--- /dev/null
+++ b/packages/sources/gsr/test/unit/tokenRefresh.test.ts
@@ -0,0 +1,77 @@
+import {
+  LIVENESS_GRACE_MS,
+  livenessProbeDelayMs,
+  MAX_TIMEOUT_MS,
+  refreshDelayMs,
+  renewalHeld,
+  TOKEN_REFRESH_MARGIN_MS,
+} from '../../src/transport/tokenRefresh'
+
+const NOW = new Date('2026-08-06T12:00:00.000Z').getTime()
+const ONE_HOUR_MS = 60 * 60 * 1000
+
+describe('refreshDelayMs', () => {
+  it('schedules the refresh a margin ahead of expiry', () => {
+    const token = { token: 't', expiresAtMs: NOW + ONE_HOUR_MS }
+
+    // GSR issues hour-long tokens, so the refresh lands at the 55 minute mark.
+    expect(refreshDelayMs(token, NOW)).toEqual(ONE_HOUR_MS - TOKEN_REFRESH_MARGIN_MS)
+  })
+
+  it('returns null when the token is already inside the margin', () => {
+    const token = { token: 't', expiresAtMs: NOW + TOKEN_REFRESH_MARGIN_MS - 1 }
+
+    // Nothing useful to schedule; the connection path will mint a fresh token.
+    expect(refreshDelayMs(token, NOW)).toBeNull()
+  })
+
+  it('returns null for an already expired token', () => {
+    expect(refreshDelayMs({ token: 't', expiresAtMs: NOW - 1 }, NOW)).toBeNull()
+  })
+
+  it('clamps an implausibly distant expiry instead of overflowing setTimeout', () => {
+    // Delays above 2^31-1 are silently coerced to 1ms by setTimeout, which would
+    // fire the refresh immediately on every open and spin into a reconnect loop.
+    const token = { token: 't', expiresAtMs: NOW + 100 * 365 * 24 * ONE_HOUR_MS }
+
+    expect(refreshDelayMs(token, NOW)).toEqual(MAX_TIMEOUT_MS)
+  })
+})
+
+describe('livenessProbeDelayMs', () => {
+  it('probes a grace period after the previous expiry', () => {
+    expect(livenessProbeDelayMs(NOW + 60_000, NOW)).toEqual(60_000 + LIVENESS_GRACE_MS)
+  })
+
+  it('probes immediately when the expiry has already passed', () => {
+    // The renewal call itself can straddle the boundary on a slow response.
+    expect(livenessProbeDelayMs(NOW - LIVENESS_GRACE_MS - 5_000, NOW)).toEqual(0)
+  })
+
+  it('never returns a negative delay', () => {
+    expect(livenessProbeDelayMs(NOW - ONE_HOUR_MS, NOW)).toBeGreaterThanOrEqual(0)
+  })
+})
+
+describe('renewalHeld', () => {
+  it('treats recent traffic as proof the session survived', () => {
+    expect(renewalHeld(NOW - 1_000, NOW)).toBe(true)
+  })
+
+  it('treats silence past the grace period as a failed renewal', () => {
+    // HTTP 200 on the renewal does not mean GSR extended the session behind the
+    // socket; only continued traffic does.
+    expect(renewalHeld(NOW - LIVENESS_GRACE_MS - 1, NOW)).toBe(false)
+  })
+
+  it('is inclusive at the grace boundary', () => {
+    expect(renewalHeld(NOW - LIVENESS_GRACE_MS, NOW)).toBe(true)
+  })
+
+  it('reconnects well before cached prices go stale', () => {
+    // CACHE_MAX_AGE is 90s from the last message. Detecting at the grace
+    // boundary has to leave room for a reconnect inside that window, otherwise
+    // requests start 504ing again.
+    expect(LIVENESS_GRACE_MS).toBeLessThan(90_000)
+  })
+})

From 6be89c49441a958fa3d8f798e08ec952c786015b Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Sun, 9 Aug 2026 07:09:39 -0700
Subject: [PATCH 12/16] changes tagging schema

---
 .github/workflows/publish-internal.yml | 37 ++++++++++++++++----------
 1 file changed, 23 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/publish-internal.yml b/.github/workflows/publish-internal.yml
index e85311ac768..5c29a35ab6f 100644
--- a/.github/workflows/publish-internal.yml
+++ b/.github/workflows/publish-internal.yml
@@ -13,9 +13,12 @@
 #     once this file is on the default branch, which is a GitHub restriction on
 #     workflow_dispatch rather than anything about this workflow.
 #
-# It deliberately does NOT tag `latest` and does NOT notify infra-k8s. Images
-# land under a tag that cannot collide with a release, and referencing one is a
-# manual step in infra-k8s.
+# It deliberately does NOT tag `latest` and does NOT notify infra-k8s.
+#
+# To reference an image from infra-k8s the tag must first appear in that repo's
+# files/digests/<registry>-adapters-<name>-adapter.yaml, which its image-dispatcher
+# workflow generates. That generator skips any tag containing "dev", so the tags
+# chosen here avoid the word; `pr<N>` also matches what already exists there.
 name: Publish Internal Adapter Image
 
 on:
@@ -26,7 +29,7 @@ on:
         required: true
         type: string
       image-tag:
-        description: Overrides the default "<version>-dev.<short-sha>" tag. Must not be a released version or "latest".
+        description: 'Overrides the default tag ("pr<N>" on a PR, "<version>-<short-sha>" when dispatched). Must not contain "dev" or the infra-k8s digest generation will skip it.'
         required: false
         type: string
   pull_request:
@@ -55,7 +58,7 @@ jobs:
     outputs:
       adapter-list: ${{ steps.resolve.outputs.ADAPTER_LIST }}
       build-sha: ${{ steps.resolve.outputs.BUILD_SHA }}
-      tag-suffix: ${{ steps.resolve.outputs.TAG_SUFFIX }}
+      image-tag: ${{ steps.resolve.outputs.IMAGE_TAG }}
     steps:
       - uses: actions/checkout@v5
         with:
@@ -70,7 +73,7 @@ jobs:
         with:
           skip-setup: true
           base-branch: origin/${{ github.base_ref || 'main' }}
-      - name: Resolve adapter list and tag suffix
+      - name: Resolve adapter list and image tag
         id: resolve
         env:
           EVENT_NAME: ${{ github.event_name }}
@@ -95,11 +98,17 @@ jobs:
               exit 1
             fi
 
-            tag_suffix="dev.${BUILD_SHA:0:8}"
+            # Must not contain "dev": the infra-k8s image-dispatcher filters
+            # such tags out when it generates digest files, and a tag with no
+            # digest entry fails helmfile templating outright.
+            version=$(echo "$adapter_list" | jq -r '.adapter[0].version')
+            image_tag="${version}-${BUILD_SHA:0:8}"
           else
             adapter_list=$(./.github/scripts/list-packages-adapters.sh "$UPSTREAM_BRANCH" \
               | jq -c '{adapter: .adapters}')
-            tag_suffix="pr${PR_NUMBER}.${BUILD_SHA:0:8}"
+            # Matches the `pr<N>` convention already present in the infra-k8s
+            # digest files, so referencing it needs no new handling there.
+            image_tag="pr${PR_NUMBER}"
           fi
 
           if [ -n "$TAG_OVERRIDE" ]; then
@@ -108,13 +117,13 @@ jobs:
               echo "::error::Refusing to publish over \"latest\"."
               exit 1
             fi
-            tag_suffix="$TAG_OVERRIDE"
+            image_tag="$TAG_OVERRIDE"
           fi
 
           {
             echo "ADAPTER_LIST=${adapter_list}"
             echo "BUILD_SHA=${BUILD_SHA}"
-            echo "TAG_SUFFIX=${tag_suffix}"
+            echo "IMAGE_TAG=${image_tag}"
           } >> "$GITHUB_OUTPUT"
 
           echo "Building $(echo "$adapter_list" | jq -c '[.adapter[].shortName]') from ${BUILD_SHA}"
@@ -167,7 +176,7 @@ jobs:
         package=${{ matrix.adapter.name }}
         location=${{ matrix.adapter.location }}
       docker-build-context: .
-      docker-image-tag-override: ${{ matrix.adapter.version }}-${{ needs.resolve-adapters.outputs.tag-suffix }}
+      docker-image-tag-override: ${{ needs.resolve-adapters.outputs.image-tag }}
       # Intentionally no docker-manifest-additional-tags: tagging `latest` here
       # would repoint every consumer of the released image at an unreleased build.
       docker-push: true
@@ -195,12 +204,12 @@ jobs:
         id: refs
         env:
           ADAPTER_LIST: ${{ needs.resolve-adapters.outputs.adapter-list }}
-          TAG_SUFFIX: ${{ needs.resolve-adapters.outputs.tag-suffix }}
+          IMAGE_TAG: ${{ needs.resolve-adapters.outputs.image-tag }}
           BUILD_SHA: ${{ needs.resolve-adapters.outputs.build-sha }}
         run: |
           set -euo pipefail
-          body=$(echo "$ADAPTER_LIST" | jq -r --arg s "$TAG_SUFFIX" '
-            .adapter[] | "- `adapters/\(.shortName)-adapter:\(.version)-\($s)`"')
+          body=$(echo "$ADAPTER_LIST" | jq -r --arg t "$IMAGE_TAG" '
+            .adapter[] | "- `adapters/\(.shortName)-adapter:\($t)`"')
           {
             echo "### Internal images published"
             echo

From 8dff3f664917334395867d706f8232204544d202 Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Wed, 12 Aug 2026 11:19:49 -0700
Subject: [PATCH 13/16] simply refresh logic

---
 packages/sources/gsr/src/transport/price.ts   | 24 +----------
 .../sources/gsr/src/transport/tokenRefresh.ts | 24 -----------
 .../gsr/test/unit/tokenRefresh.test.ts        | 41 -------------------
 3 files changed, 1 insertion(+), 88 deletions(-)

diff --git a/packages/sources/gsr/src/transport/price.ts b/packages/sources/gsr/src/transport/price.ts
index 276f06fc1ea..4793fe3bdb4 100644
--- a/packages/sources/gsr/src/transport/price.ts
+++ b/packages/sources/gsr/src/transport/price.ts
@@ -2,7 +2,7 @@ import { WebSocketTransport } from '@chainlink/external-adapter-framework/transp
 import { makeLogger, ProviderResult } from '@chainlink/external-adapter-framework/util'
 import { BaseEndpointTypes } from '../endpoint/price'
 import { getToken, renewToken, TokenWithExpiry } from './authutils'
-import { livenessProbeDelayMs, refreshDelayMs, renewalHeld } from './tokenRefresh'
+import { refreshDelayMs } from './tokenRefresh'
 
 const logger = makeLogger('GSR WS price')
 
@@ -155,28 +155,6 @@ export class GsrWebSocketTransport extends WebSocketTransport<WsTransportTypes>
     }
 
     this.scheduleRefresh(settings)
-    this.scheduleLivenessProbe(previous.expiresAtMs)
-  }
-
-  /**
-   * Checks shortly after the old expiry that GSR is still feeding us. This is
-   * the only real evidence the renewal extended the session, since the socket
-   * still carries the original token in its handshake headers.
-   */
-  private scheduleLivenessProbe(previousExpiryMs: number) {
-    this.livenessTimer = setTimeout(() => {
-      this.livenessTimer = undefined
-      const now = Date.now()
-      if (renewalHeld(this.lastMessageReceivedAt, now)) {
-        logger.info('Still receiving data past the previous token expiry; renewal held')
-        return
-      }
-      this.closeForReconnect(
-        `No provider data for ${Math.round(
-          (now - this.lastMessageReceivedAt) / 1000,
-        )}s past the previous token expiry, so the renewal did not extend the session`,
-      )
-    }, livenessProbeDelayMs(previousExpiryMs, Date.now()))
   }
 
   private parsePriceUpdate(message: WsMessage): ProviderResult<WsTransportTypes>[] | undefined {
diff --git a/packages/sources/gsr/src/transport/tokenRefresh.ts b/packages/sources/gsr/src/transport/tokenRefresh.ts
index fb7fa35c39c..148b3ca853f 100644
--- a/packages/sources/gsr/src/transport/tokenRefresh.ts
+++ b/packages/sources/gsr/src/transport/tokenRefresh.ts
@@ -3,13 +3,6 @@ import { TokenWithExpiry } from './authutils'
 /** How far ahead of expiry to act, so the provider is still sending data. */
 export const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000
 
-/**
- * How long past the old expiry to let the connection prove itself before
- * concluding an in-place renewal did not take. Must leave room to reconnect
- * before cached prices go stale at CACHE_MAX_AGE (90s from the last message).
- */
-export const LIVENESS_GRACE_MS = 20 * 1000
-
 /**
  * setTimeout coerces any delay above this to 1ms. Left unclamped, an
  * implausibly distant expiry would fire the refresh immediately on every open,
@@ -25,20 +18,3 @@ export const refreshDelayMs = (token: TokenWithExpiry, nowMs: number): number |
   const delay = token.expiresAtMs - nowMs - TOKEN_REFRESH_MARGIN_MS
   return delay > 0 ? Math.min(delay, MAX_TIMEOUT_MS) : null
 }
-
-/**
- * Delay until we check whether a renewal actually kept the session alive.
- * Clamped at zero because the expiry may already have passed by the time the
- * renewal call returns.
- */
-export const livenessProbeDelayMs = (previousExpiryMs: number, nowMs: number): number =>
-  Math.min(Math.max(0, previousExpiryMs + LIVENESS_GRACE_MS - nowMs), MAX_TIMEOUT_MS)
-
-/**
- * Whether the provider is still sending. A renewal returning HTTP 200 says the
- * token was renewed, not that GSR extended the session behind the socket, which
- * still carries the original token in its handshake headers. Continued traffic
- * is the only real evidence.
- */
-export const renewalHeld = (lastMessageAtMs: number, nowMs: number): boolean =>
-  nowMs - lastMessageAtMs <= LIVENESS_GRACE_MS
diff --git a/packages/sources/gsr/test/unit/tokenRefresh.test.ts b/packages/sources/gsr/test/unit/tokenRefresh.test.ts
index 14832c81238..bdc7e0204dd 100644
--- a/packages/sources/gsr/test/unit/tokenRefresh.test.ts
+++ b/packages/sources/gsr/test/unit/tokenRefresh.test.ts
@@ -1,9 +1,6 @@
 import {
-  LIVENESS_GRACE_MS,
-  livenessProbeDelayMs,
   MAX_TIMEOUT_MS,
   refreshDelayMs,
-  renewalHeld,
   TOKEN_REFRESH_MARGIN_MS,
 } from '../../src/transport/tokenRefresh'
 
@@ -37,41 +34,3 @@ describe('refreshDelayMs', () => {
     expect(refreshDelayMs(token, NOW)).toEqual(MAX_TIMEOUT_MS)
   })
 })
-
-describe('livenessProbeDelayMs', () => {
-  it('probes a grace period after the previous expiry', () => {
-    expect(livenessProbeDelayMs(NOW + 60_000, NOW)).toEqual(60_000 + LIVENESS_GRACE_MS)
-  })
-
-  it('probes immediately when the expiry has already passed', () => {
-    // The renewal call itself can straddle the boundary on a slow response.
-    expect(livenessProbeDelayMs(NOW - LIVENESS_GRACE_MS - 5_000, NOW)).toEqual(0)
-  })
-
-  it('never returns a negative delay', () => {
-    expect(livenessProbeDelayMs(NOW - ONE_HOUR_MS, NOW)).toBeGreaterThanOrEqual(0)
-  })
-})
-
-describe('renewalHeld', () => {
-  it('treats recent traffic as proof the session survived', () => {
-    expect(renewalHeld(NOW - 1_000, NOW)).toBe(true)
-  })
-
-  it('treats silence past the grace period as a failed renewal', () => {
-    // HTTP 200 on the renewal does not mean GSR extended the session behind the
-    // socket; only continued traffic does.
-    expect(renewalHeld(NOW - LIVENESS_GRACE_MS - 1, NOW)).toBe(false)
-  })
-
-  it('is inclusive at the grace boundary', () => {
-    expect(renewalHeld(NOW - LIVENESS_GRACE_MS, NOW)).toBe(true)
-  })
-
-  it('reconnects well before cached prices go stale', () => {
-    // CACHE_MAX_AGE is 90s from the last message. Detecting at the grace
-    // boundary has to leave room for a reconnect inside that window, otherwise
-    // requests start 504ing again.
-    expect(LIVENESS_GRACE_MS).toBeLessThan(90_000)
-  })
-})

From 6ac3955716a478214de415dee91600729d8594fe Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Wed, 12 Aug 2026 11:47:40 -0700
Subject: [PATCH 14/16] fix sha conflict

---
 .github/workflows/publish-internal.yml | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/publish-internal.yml b/.github/workflows/publish-internal.yml
index 5c29a35ab6f..8a2c2fb1e45 100644
--- a/.github/workflows/publish-internal.yml
+++ b/.github/workflows/publish-internal.yml
@@ -106,9 +106,10 @@ jobs:
           else
             adapter_list=$(./.github/scripts/list-packages-adapters.sh "$UPSTREAM_BRANCH" \
               | jq -c '{adapter: .adapters}')
-            # Matches the `pr<N>` convention already present in the infra-k8s
-            # digest files, so referencing it needs no new handling there.
-            image_tag="pr${PR_NUMBER}"
+            # Include the short SHA so each rebuild gets a unique digest entry.
+            # Moving tags (same PR, pushed again) would otherwise cause digest
+            # collisions when infra-k8s regenerates the digest file.
+            image_tag="pr${PR_NUMBER}.${BUILD_SHA:0:8}"
           fi
 
           if [ -n "$TAG_OVERRIDE" ]; then

From a18b2308464da6e989ae7c98a736d0e4c22da38d Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Wed, 19 Aug 2026 16:02:42 -0700
Subject: [PATCH 15/16] adds batching to subscription management

---
 packages/sources/gsr/src/transport/price.ts | 33 ++++++++++++++++-----
 1 file changed, 25 insertions(+), 8 deletions(-)

diff --git a/packages/sources/gsr/src/transport/price.ts b/packages/sources/gsr/src/transport/price.ts
index 4793fe3bdb4..a9d39754780 100644
--- a/packages/sources/gsr/src/transport/price.ts
+++ b/packages/sources/gsr/src/transport/price.ts
@@ -1,4 +1,6 @@
+import { EndpointContext } from '@chainlink/external-adapter-framework/adapter'
 import { WebSocketTransport } from '@chainlink/external-adapter-framework/transports'
+import { SubscriptionDeltas } from '@chainlink/external-adapter-framework/transports/abstract/streaming'
 import { makeLogger, ProviderResult } from '@chainlink/external-adapter-framework/util'
 import { BaseEndpointTypes } from '../endpoint/price'
 import { getToken, renewToken, TokenWithExpiry } from './authutils'
@@ -43,6 +45,10 @@ export class GsrWebSocketTransport extends WebSocketTransport<WsTransportTypes>
   private refreshTimer?: NodeJS.Timeout
   private livenessTimer?: NodeJS.Timeout
 
+  private buildTicker(pair: { base: string; quote: string }) {
+    return `${pair.base}.${pair.quote}`.toUpperCase()
+  }
+
   constructor() {
     super({
       url: (context) => context.adapterSettings.WS_API_ENDPOINT,
@@ -69,14 +75,25 @@ export class GsrWebSocketTransport extends WebSocketTransport<WsTransportTypes>
       builders: {
         // Note: As of writing this (2022-11-07), GSR has a bug where you cannot subscribe to a pair
         // after you've already subscribed & unsubscribed to that pair on the same WS connection.
-        subscribeMessage: (params) => ({
-          action: 'subscribe',
-          symbols: [`${params.base}.${params.quote}`.toUpperCase()],
-        }),
-        unsubscribeMessage: (params) => ({
-          action: 'unsubscribe',
-          symbols: [`${params.base}.${params.quote}`.toUpperCase()],
-        }),
+        customSubscriptionMessages: (
+          _context: EndpointContext<WsTransportTypes>,
+          subscriptions: SubscriptionDeltas<{ quote: string; base: string }>,
+        ) => {
+          const messages = []
+          if (subscriptions.new.length > 0) {
+            messages.push({
+              action: 'subscribe',
+              symbols: subscriptions.new.map(this.buildTicker),
+            })
+          }
+          if (subscriptions.stale.length > 0) {
+            messages.push({
+              action: 'unsubscribe',
+              symbols: subscriptions.new.map(this.buildTicker),
+            })
+          }
+          return messages
+        },
       },
     })
   }

From e45050c388108d74a0aa3b33e9fac94597448eff Mon Sep 17 00:00:00 2001
From: Eric Fornaciari <eric.fornaciari@smartcontract.com>
Date: Thu, 20 Aug 2026 15:16:42 -0700
Subject: [PATCH 16/16] fixes stale subscription

---
 packages/sources/gsr/src/transport/price.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/sources/gsr/src/transport/price.ts b/packages/sources/gsr/src/transport/price.ts
index a9d39754780..4c913ace954 100644
--- a/packages/sources/gsr/src/transport/price.ts
+++ b/packages/sources/gsr/src/transport/price.ts
@@ -89,7 +89,7 @@ export class GsrWebSocketTransport extends WebSocketTransport<WsTransportTypes>
           if (subscriptions.stale.length > 0) {
             messages.push({
               action: 'unsubscribe',
-              symbols: subscriptions.new.map(this.buildTicker),
+              symbols: subscriptions.stale.map(this.buildTicker),
             })
           }
           return messages