Refactors GM-token to support Botanix and dynamic fetching of tokens (#4077)

* Refactors to add Botanix chain and dynamic fetching of tokens

Author: mohamed-mehany

.changeset/popular-otters-brush.md

@@ -0,0 +1,5 @@
+---
+'@chainlink/gm-token-adapter': minor
+---
+
+Support Botanix specific tokens

packages/composites/gm-token/src/config/index.ts

@@ -14,18 +14,57 @@ export const config = new AdapterConfig(
       required: true,
       default: 42161,
     },
+    BOTANIX_RPC_URL: {
+      description: 'RPC url of Botanix node',
+      type: 'string',
+    },
+    BOTANIX_CHAIN_ID: {
+      description: 'The chain id to connect to',
+      type: 'number',
+      default: 3637,
+    },
     DATASTORE_CONTRACT_ADDRESS: {
       description: 'Address of Data Store contract',
       type: 'string',
       required: true,
       default: '0xFD70de6b91282D8017aA4E741e9Ae325CAb992d8',
     },
+    BOTANIX_DATASTORE_CONTRACT_ADDRESS: {
+      description: 'Address of Data Store contract',
+      type: 'string',
+      required: true,
+      default: '0xA23B81a89Ab9D7D89fF8fc1b5d8508fB75Cc094d',
+    },
     READER_CONTRACT_ADDRESS: {
       description: 'Address of Reader contract',
       type: 'string',
       required: true,
       default: '0xf60becbba223EEA9495Da3f606753867eC10d139',
     },
+    BOTANIX_READER_CONTRACT_ADDRESS: {
+      description: 'Address of Reader contract',
+      type: 'string',
+      required: true,
+      default: '0xa254B60cbB85a92F6151B10E1233639F601f2F0F',
+    },
+    ARBITRUM_TOKENS_INFO_URL: {
+      description: 'URL to token meta data supported by GMX on Arbitrum',
+      type: 'string',
+      required: true,
+      default: 'https://arbitrum-api.gmxinfra.io/tokens',
+    },
+    BOTANIX_TOKENS_INFO_URL: {
+      description: 'URL to token meta data supported by GMX on Botanix',
+      type: 'string',
+      required: true,
+      default: 'https://botanix-api.gmxinfra.io/tokens',
+    },
+    GMX_TOKENS_CACHE_MS: {
+      description: 'TTL in milliseconds for GMX tokens cache',
+      type: 'number',
+      required: true,
+      default: 300_000,
+    },
     PNL_FACTOR_TYPE: {
       description:
         'PnL factor type. See https://github.com/gmx-io/gmx-synthetics#market-token-price',

packages/composites/gm-token/src/endpoint/price.ts

@@ -2,8 +2,8 @@ import { AdapterEndpoint } from '@chainlink/external-adapter-framework/adapter'
 import { InputParameters } from '@chainlink/external-adapter-framework/validation'
 import { config } from '../config'
 import { gmTokenTransport } from '../transport/price'
-import { tokenAddresses } from '../transport/utils'
-import { AdapterInputError } from '@chainlink/external-adapter-framework/validation/error'
+
+export const CHAIN_OPTIONS = ['arbitrum', 'botanix']
 
 export const inputParameters = new InputParameters(
   {
@@ -28,17 +28,26 @@ export const inputParameters = new InputParameters(
       type: 'string',
       description: 'Market address of the market pool.',
     },
+    chain: {
+      description: 'Target chain for GM market',
+      type: 'string',
+      options: [...CHAIN_OPTIONS],
+      default: 'arbitrum',
+    },
   },
   [
     {
       index: 'LINK',
       long: 'LINK',
       short: 'USDC',
       market: '0x7f1fa204bb700853D36994DA19F830b6Ad18455C',
+      chain: 'arbitrum',
     },
   ],
 )
 
+export type ChainKey = (typeof inputParameters.validated)['chain']
+
 export type BaseEndpointTypes = {
   Parameters: typeof inputParameters.definition
   Response: {
@@ -55,26 +64,4 @@ export const endpoint = new AdapterEndpoint({
   name: 'price',
   transport: gmTokenTransport,
   inputParameters,
-  customInputValidation: (req): AdapterInputError | undefined => {
-    const { index, long, short } = req.requestContext.data
-    const indexToken = tokenAddresses.arbitrum[index as keyof typeof tokenAddresses.arbitrum]
-    const longToken = tokenAddresses.arbitrum[long as keyof typeof tokenAddresses.arbitrum]
-    const shortToken = tokenAddresses.arbitrum[short as keyof typeof tokenAddresses.arbitrum]
-    let invalidTokens = ''
-    if (!indexToken) {
-      invalidTokens += 'indexToken,'
-    }
-    if (!longToken) {
-      invalidTokens += 'longToken,'
-    }
-    if (!shortToken) {
-      invalidTokens += 'shortToken,'
-    }
-    if (invalidTokens.length) {
-      throw new AdapterInputError({
-        message: `Invalid ${invalidTokens} Must be one of ${Object.keys(tokenAddresses.arbitrum)}`,
-      })
-    }
-    return
-  },
 })

packages/composites/gm-token/src/transport/price.ts

@@ -1,26 +1,19 @@
-import { TransportDependencies } from '@chainlink/external-adapter-framework/transports'
 import { ResponseCache } from '@chainlink/external-adapter-framework/cache/response'
+import { TransportDependencies } from '@chainlink/external-adapter-framework/transports'
 import { Requester } from '@chainlink/external-adapter-framework/util/requester'
 
-import { BaseEndpointTypes, inputParameters } from '../endpoint/price'
-import { ethers, utils } from 'ethers'
-import { SubscriptionTransport } from '@chainlink/external-adapter-framework/transports/abstract/subscription'
 import {
   EndpointContext,
   LwbaResponseDataFields,
 } from '@chainlink/external-adapter-framework/adapter'
+import { SubscriptionTransport } from '@chainlink/external-adapter-framework/transports/abstract/subscription'
 import { AdapterResponse, makeLogger, sleep } from '@chainlink/external-adapter-framework/util'
-import {
-  decimals,
-  toFixed,
-  median,
-  PriceData,
-  SIGNED_PRICE_DECIMALS,
-  tokenAddresses,
-  Source,
-} from './utils'
-import abi from './../config/readerAbi.json'
 import { AdapterDataProviderError } from '@chainlink/external-adapter-framework/validation/error'
+import { ethers, utils } from 'ethers'
+import { BaseEndpointTypes, ChainKey, inputParameters } from '../endpoint/price'
+import abi from './../config/readerAbi.json'
+import { TokenResolver } from './token-resolver'
+import { median, PriceData, SIGNED_PRICE_DECIMALS, Source, toFixed, unwrapAsset } from './utils'
 
 const logger = makeLogger('GMToken')
 
@@ -32,10 +25,11 @@ export class GmTokenTransport extends SubscriptionTransport<GmTokenTransportType
   name!: string
   responseCache!: ResponseCache<GmTokenTransportTypes>
   requester!: Requester
-  provider!: ethers.providers.JsonRpcProvider
-  readerContract!: ethers.Contract
   abiEncoder!: utils.AbiCoder
   settings!: GmTokenTransportTypes['Settings']
+  tokenResolver!: TokenResolver
+  private providers: Partial<Record<ChainKey, ethers.providers.JsonRpcProvider>> = {}
+  private readers: Partial<Record<ChainKey, ethers.Contract>> = {}
 
   async initialize(
     dependencies: TransportDependencies<GmTokenTransportTypes>,
@@ -45,16 +39,8 @@ export class GmTokenTransport extends SubscriptionTransport<GmTokenTransportType
   ): Promise<void> {
     await super.initialize(dependencies, adapterSettings, endpointName, transportName)
     this.settings = adapterSettings
-    this.provider = new ethers.providers.JsonRpcProvider(
-      adapterSettings.ARBITRUM_RPC_URL,
-      adapterSettings.ARBITRUM_CHAIN_ID,
-    )
-    this.readerContract = new ethers.Contract(
-      adapterSettings.READER_CONTRACT_ADDRESS,
-      abi,
-      this.provider,
-    )
     this.requester = dependencies.requester
+    this.tokenResolver = new TokenResolver(this.requester, this.settings)
   }
 
   async backgroundHandler(context: EndpointContext<BaseEndpointTypes>, entries: RequestParams[]) {
@@ -85,35 +71,40 @@ export class GmTokenTransport extends SubscriptionTransport<GmTokenTransportType
   async _handleRequest(
     param: RequestParams,
   ): Promise<AdapterResponse<GmTokenTransportTypes['Response']>> {
-    const { index, long, short, market } = param
+    const { index, long, short, market, chain } = param
 
     const assets = [index, long, short]
 
     const providerDataRequestedUnixMs = Date.now()
 
+    const [indexToken, longToken, shortToken] = await Promise.all([
+      this.tokenResolver.getToken(chain, index),
+      this.tokenResolver.getToken(chain, long),
+      this.tokenResolver.getToken(chain, short),
+    ])
+    const decimalsMap = new Map(
+      [indexToken, longToken, shortToken].map((t) => [t.symbol, t.decimals]),
+    )
+
     const {
       prices: [indexPrices, longPrices, shortPrices],
       sources,
-    } = await this.fetchPrices(assets, providerDataRequestedUnixMs)
-
-    const indexToken = tokenAddresses.arbitrum[index as keyof typeof tokenAddresses.arbitrum]
-    const longToken = tokenAddresses.arbitrum[long as keyof typeof tokenAddresses.arbitrum]
-    const shortToken = tokenAddresses.arbitrum[short as keyof typeof tokenAddresses.arbitrum]
+    } = await this.fetchPrices(assets, providerDataRequestedUnixMs, decimalsMap)
 
     const tokenPriceContractParams = [
-      this.settings.DATASTORE_CONTRACT_ADDRESS,
-      [market, indexToken, longToken, shortToken],
+      this.getDatastoreContractAddress(chain as ChainKey),
+      [market, indexToken.address, longToken.address, shortToken.address],
       [indexPrices.ask, indexPrices.bid],
       [longPrices.ask, longPrices.bid],
       [shortPrices.ask, shortPrices.bid],
       utils.keccak256(utils.defaultAbiCoder.encode(['string'], [this.settings.PNL_FACTOR_TYPE])),
     ]
-
+    const readerContract = this.getReaderContract(chain)
     // Prices have a spread from min to max. The last param (maximize-true/false) decides whether to maximize the market token price
     // or not. We get both values and return the median.
     const [[maximizedValue], [minimizedValue]] = await Promise.all([
-      this.readerContract.getMarketTokenPrice(...tokenPriceContractParams, true),
-      this.readerContract.getMarketTokenPrice(...tokenPriceContractParams, false),
+      readerContract.getMarketTokenPrice(...tokenPriceContractParams, true),
+      readerContract.getMarketTokenPrice(...tokenPriceContractParams, false),
     ])
 
     const maximizedPrice = Number(utils.formatUnits(maximizedValue, SIGNED_PRICE_DECIMALS))
@@ -136,7 +127,11 @@ export class GmTokenTransport extends SubscriptionTransport<GmTokenTransportType
   }
 
   // Fetches the lwba price info from multiple source EAs, calculates the median for bids and asks per asset and fixes the price precision
-  private async fetchPrices(assets: string[], dataRequestedTimestamp: number) {
+  private async fetchPrices(
+    assets: string[],
+    dataRequestedTimestamp: number,
+    decimals: Map<string, number>,
+  ) {
     // priceData holds raw bid/ask values per asset from source EAs response
     const priceData = {} as PriceData
 
@@ -155,7 +150,7 @@ export class GmTokenTransport extends SubscriptionTransport<GmTokenTransportType
       const source = sources[i]
 
       const assetPromises = assets.map(async (asset) => {
-        const base = this.unwrapAsset(asset)
+        const base = unwrapAsset(asset)
         const requestConfig = {
           url: source.url,
           method: 'POST',
@@ -202,11 +197,17 @@ export class GmTokenTransport extends SubscriptionTransport<GmTokenTransportType
 
     const medianValues = this.calculateMedian(assets, priceData)
 
-    const prices = medianValues.map((v) => ({
-      ...v,
-      ask: toFixed(v.ask, decimals[v.asset as keyof typeof decimals]),
-      bid: toFixed(v.bid, decimals[v.asset as keyof typeof decimals]),
-    }))
+    const prices = medianValues.map((v) => {
+      const decimal = decimals.get(v.asset)
+      if (!decimal) {
+        throw new Error(`Missing token decimals for '${v.asset}'`)
+      }
+      return {
+        ...v,
+        ask: toFixed(v.ask, decimal),
+        bid: toFixed(v.bid, decimal),
+      }
+    })
 
     return {
       prices,
@@ -223,16 +224,6 @@ export class GmTokenTransport extends SubscriptionTransport<GmTokenTransportType
     })
   }
 
-  private unwrapAsset(asset: string) {
-    if (asset === 'WBTC.b') {
-      return 'BTC'
-    }
-    if (asset === 'WETH') {
-      return 'ETH'
-    }
-    return asset
-  }
-
   /*
     For every asset check that we received responses from the required number of source EAs to accurately calculate the median price of the asset.
   */
@@ -258,7 +249,7 @@ export class GmTokenTransport extends SubscriptionTransport<GmTokenTransportType
     }
 
     assets.forEach((asset) => {
-      const base = this.unwrapAsset(asset)
+      const base = unwrapAsset(asset)
       const respondedSources = priceProviders[base]
 
       if (respondedSources.length < this.settings.MIN_REQUIRED_SOURCE_SUCCESS) {
@@ -282,6 +273,39 @@ export class GmTokenTransport extends SubscriptionTransport<GmTokenTransportType
     })
   }
 
+  private getProvider(chain: ChainKey): ethers.providers.JsonRpcProvider {
+    if (this.providers[chain]) return this.providers[chain]!
+    const p =
+      chain === 'botanix'
+        ? new ethers.providers.JsonRpcProvider(
+            this.settings.BOTANIX_RPC_URL,
+            this.settings.BOTANIX_CHAIN_ID,
+          )
+        : new ethers.providers.JsonRpcProvider(
+            this.settings.ARBITRUM_RPC_URL,
+            this.settings.ARBITRUM_CHAIN_ID,
+          )
+    this.providers[chain] = p
+    return p
+  }
+
+  private getReaderContract(chain: ChainKey): ethers.Contract {
+    if (this.readers[chain]) return this.readers[chain]!
+    const addr =
+      chain === 'botanix'
+        ? this.settings.BOTANIX_READER_CONTRACT_ADDRESS
+        : this.settings.READER_CONTRACT_ADDRESS
+    const reader = new ethers.Contract(addr, abi, this.getProvider(chain))
+    this.readers[chain] = reader
+    return reader
+  }
+
+  private getDatastoreContractAddress(chain: ChainKey): string {
+    return chain === 'botanix'
+      ? this.settings.BOTANIX_DATASTORE_CONTRACT_ADDRESS
+      : this.settings.DATASTORE_CONTRACT_ADDRESS
+  }
+
   getSubscriptionTtlFromConfig(adapterSettings: BaseEndpointTypes['Settings']): number {
     return adapterSettings.WARMUP_SUBSCRIPTION_TTL
   }

packages/composites/gm-token/src/transport/token-resolver.ts

@@ -0,0 +1,31 @@
+import { Requester } from '@chainlink/external-adapter-framework/util/requester'
+import { ChainKey } from '../endpoint/price'
+import { GmTokenTransportTypes } from './price'
+
+export type TokenMeta = { address: string; decimals: number; symbol: string }
+type TokensResp = { tokens: Array<{ symbol: string; address: string; decimals: number }> }
+
+/**
+ * Fetches token metadata (address/decimals) per chain from GMX API.
+ */
+export class TokenResolver {
+  private readonly urls: Record<ChainKey, string>
+
+  constructor(private readonly requester: Requester, settings: GmTokenTransportTypes['Settings']) {
+    this.urls = {
+      arbitrum: settings.ARBITRUM_TOKENS_INFO_URL,
+      botanix: settings.BOTANIX_TOKENS_INFO_URL,
+    }
+  }
+
+  async getToken(chain: ChainKey, symbol: string): Promise<TokenMeta> {
+    const req = { url: this.urls[chain], method: 'GET' as const }
+    const { response } = await this.requester.request<TokensResp>(JSON.stringify(req), req)
+    const target = symbol.toUpperCase()
+    const token = response.data.tokens.find((x) => x.symbol.toUpperCase() === target)
+    if (!token) {
+      throw new Error(`Token with symbol "${symbol}" not found on ${chain}`)
+    }
+    return { symbol: token.symbol, address: token.address, decimals: token.decimals }
+  }
+}