Merge pull request #2415 from balancer/v3-canary

publish to prod

Author: franzns

CHANGELOG.md

@@ -1,5 +1,15 @@
 # backend
 
+## 1.56.0
+
+### Minor Changes
+
+-   845effd: add coingecko pricing call proxy
+
+### Patch Changes
+
+-   8eed23a: option to skip ssl verification for apr sources
+
 ## 1.55.3
 
 ### Patch Changes

apps/api/rest-routes.ts

@@ -4,6 +4,13 @@ import {
     beetsGetCirculatingSupplySonic,
     beetsGetTotalSupplySonic,
 } from '../../modules/beets/lib/beets';
+import { latestTokenPrice } from '../../modules/token/latest-token-price';
+import config from '../../config';
+import { Chain } from '@prisma/client';
+import * as crypto from 'crypto';
+
+const isHexAddress = (addr: any) =>
+    typeof addr === 'string' && addr.length === 42 && addr.startsWith('0x') && /^[0-9a-f]{40}$/i.test(addr.slice(2));
 
 export function loadRestRoutes(app: Express) {
     app.use('/health', (_, res) => res.sendStatus(200));
@@ -22,4 +29,48 @@ export function loadRestRoutes(app: Express) {
             res.send(result);
         });
     });
+
+    app.get('/price', async (req, res) => {
+        res.type('application/json');
+
+        const chain = req.query.chain;
+        const tokens = req.query.tokens && (req.query.tokens as string).split(',');
+
+        // Validate params
+        if (typeof chain !== 'string' || !(chain in config)) {
+            res.status(400).end();
+            return;
+        }
+
+        if (!Array.isArray(tokens) || tokens.length === 0 || !tokens.every(isHexAddress) || tokens.length > 8) {
+            res.status(400).end();
+            return;
+        }
+
+        const prices = await latestTokenPrice(chain as Chain, tokens as string[]);
+
+        // Build response body
+        const responseBody = { prices };
+        const bodyString = JSON.stringify(responseBody);
+
+        // Generate strong ETag: MD5 hash of the body (fast for small JSON)
+        const etag = crypto.createHash('md5').update(bodyString).digest('hex');
+
+        // Set ETag header
+        res.set('ETag', `"${etag}"`);
+
+        // Check for conditional request
+        const clientEtag = req.get('If-None-Match');
+        if (clientEtag === `"${etag}"` || clientEtag === etag) {
+            // Handle quoted/unquoted client headers
+            res.status(304).end(); // Not modified: No body needed
+            return;
+        }
+
+        // Set caching headers (unchanged)
+        res.set('Cache-Control', 'public, max-age=600, s-maxage=600, stale-while-revalidate=30, stale-if-error=86400');
+
+        // Send full response
+        res.send(responseBody);
+    });
 }

config/mainnet.ts

@@ -405,6 +405,7 @@ export default <NetworkData>{
                     extractors: [
                         { type: 'path', token: '0x198d7387fa97a73f05b8578cdeff8f2a1f34cd1f', path: '$.wjauraApy' },
                     ],
+                    skipSSL: true,
                 },
                 {
                     url: 'https://universe.staderlabs.com/eth/apy',

modules/token-yields/examples/fetch.ts

@@ -10,6 +10,6 @@ const main = async (_chain: string) => {
 };
 
 main(process.argv[2])
-    .then(console.log)
+    .then((data) => console.log(JSON.stringify(data, null, 2)))
     .catch(console.log)
     .finally(() => process.exit(0));

modules/token-yields/handlers/sources/http-yield-handler.ts

@@ -1,14 +1,26 @@
 import { JSONPath } from 'jsonpath-plus';
 import { TokenYieldHandler, TokenYieldHttpFetchConfig } from '../../types';
 
-const fetchWithTimeout = async (url: string, options: RequestInit = {}, timeoutMs: number = 20000): Promise<any> => {
+const fetchWithTimeout = async (
+    url: string,
+    options: RequestInit = {},
+    skipSSL = false,
+    timeoutMs: number = 20000,
+): Promise<any> => {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
 
+    let previous_NODE_TLS_REJECT_UNAUTHORIZED = process.env['NODE_TLS_REJECT_UNAUTHORIZED'];
+    if (skipSSL) {
+        process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = '0';
+    }
     const fetchPromise = fetch(url, {
         ...options,
         signal: controller.signal,
     });
+    if (skipSSL) {
+        process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = previous_NODE_TLS_REJECT_UNAUTHORIZED;
+    }
 
     // Timeout promise - needed to handle bun edge case that doesn't throw when fetch is aborted
     const timeoutPromise = new Promise((_, reject) => {
@@ -65,11 +77,15 @@ const normalizeValue = (value: any, { url, average, scale }: TokenYieldHttpFetch
 };
 
 export const httpTokenYieldHandler: TokenYieldHandler = async (config: TokenYieldHttpFetchConfig) => {
-    const res = await fetchWithTimeout(config.url, {
-        method: config.method ?? (config.body ? 'POST' : 'GET'),
-        headers: config.headers,
-        ...(config.body && { body: config.body }),
-    });
+    const res = await fetchWithTimeout(
+        config.url,
+        {
+            method: config.method ?? (config.body ? 'POST' : 'GET'),
+            headers: config.headers,
+            ...(config.body && { body: config.body }),
+        },
+        config.skipSSL,
+    );
     const json = await res.json();
 
     return transform(extract(json, config), config);

modules/token-yields/types.ts

@@ -37,6 +37,7 @@ export interface TokenYieldHttpFetchConfig {
     body?: string;
     scale?: number;
     average?: boolean;
+    skipSSL?: boolean;
     extractors: readonly EntryExtractor[];
 }
 

modules/token/latest-token-price.ts

@@ -0,0 +1,41 @@
+import { prisma } from '../../prisma/prisma-client';
+import { Chain } from '@prisma/client';
+import { CoingeckoDataService } from './lib/coingecko-data.service';
+
+export const latestTokenPrice = async (chain: Chain, tokenAddresses: string[]) => {
+    const lowerCaseAddresses = tokenAddresses.map((a) => a.toLowerCase());
+    const prices = await prisma.prismaTokenCurrentPrice
+        .findMany({
+            where: {
+                chain,
+                tokenAddress: {
+                    in: lowerCaseAddresses,
+                },
+            },
+        })
+        .then((arr) =>
+            arr.reduce(
+                (obj, item) => {
+                    obj[item.tokenAddress] = item.price;
+
+                    return obj;
+                },
+                {} as Record<string, number>,
+            ),
+        );
+
+    const missingPrices = lowerCaseAddresses.filter((tokenAddress) => !prices[tokenAddress]);
+
+    if (missingPrices.length > 0) {
+        const cg = new CoingeckoDataService();
+        const coingeckoPrices = await cg.tokenPrice(chain, missingPrices);
+
+        for (const token of Object.keys(coingeckoPrices)) {
+            const price = coingeckoPrices[token];
+
+            prices[token] = price.usd;
+        }
+    }
+
+    return prices;
+};

modules/token/lib/coingecko-data.service.ts

@@ -100,15 +100,18 @@ export class CoingeckoDataService {
                 .filter(([chain, _]) => chain !== 'SEPOLIA') // Sepolia is not in CG
                 .map(([chain, chainConfig]) => [chainConfig.coingecko.platformId, chain]),
         );
-        const coinMap = coinIds.reduce((acc, coin) => {
-            for (const [platform, address] of Object.entries(coin.platforms)) {
-                if (platformToChain[platform]) {
-                    // tokenAddress-chain
-                    acc[`${address.toLowerCase()}-${platformToChain[platform]}`] = coin.id;
+        const coinMap = coinIds.reduce(
+            (acc, coin) => {
+                for (const [platform, address] of Object.entries(coin.platforms)) {
+                    if (platformToChain[platform]) {
+                        // tokenAddress-chain
+                        acc[`${address.toLowerCase()}-${platformToChain[platform]}`] = coin.id;
+                    }
                 }
-            }
-            return acc;
-        }, {} as Record<string, string>);
+                return acc;
+            },
+            {} as Record<string, string>,
+        );
 
         const updates = allTokens
             .map((token) => {
@@ -154,6 +157,13 @@ export class CoingeckoDataService {
     //     }));
     // }
 
+    async tokenPrice(chain: Chain, tokens: string[]) {
+        const platformId = config[chain].coingecko.platformId;
+        const endpoint = `/simple/token_price/${platformId}?vs_currencies=usd&contract_addresses=${tokens.join(',')}`;
+
+        return this.get<{ [token: string]: { usd: number } }>(endpoint);
+    }
+
     public async getMarketDataForTokenIds(tokenIds: string[]): Promise<CoingeckoTokenMarketData[]> {
         const endpoint = `/coins/markets?vs_currency=${this.fiatParam}&ids=${tokenIds}&per_page=250&page=1&sparkline=false&price_change_percentage=1h%2C24h%2C7d%2C14d%2C30d`;
 
@@ -168,17 +178,17 @@ export class CoingeckoDataService {
     private async get<T>(endpoint: string): Promise<T> {
         const remainingRequests = await requestRateLimiter.removeTokens(1);
         console.log('Remaining coingecko requests', remainingRequests);
-        
+
         const response = await fetch(this.baseUrl + endpoint + this.apiKeyParam);
-        
+
         if (!response.ok) {
             if (response.status === 429) {
                 throw Error(`Coingecko ratelimit: ${response.status} ${response.statusText}`);
             }
             throw Error(`Coingecko API error: ${response.status} ${response.statusText}`);
         }
-        
-        return await response.json() as T;
+
+        return (await response.json()) as T;
     }
 }
 

package.json

@@ -1,6 +1,6 @@
 {
     "name": "backend",
-    "version": "1.55.3",
+    "version": "1.56.0",
     "description": "Backend service for Beethoven X and Balancer",
     "repository": "https://github.com/balancer/backend",
     "author": "Beethoven X",