9775961080

Committed 03 Jul 2024 08:18AM UTC coverage: 48.543% (-0.04%) from 48.584%

Build # 9775961080

Build Type

push

github

Committed by

web-flow

Commit Message

Make Chain.pricesProvider nullable (#1717)

Makes Chain.pricesProvider optional.

Run Details

416 of 2539 branches covered (16.38%)

Branch coverage included in aggregate %.

0 of 6 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

4215 of 7001 relevant lines covered (60.21%)

13.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

22.39

/src/datasources/balances-api/coingecko-api.service.ts

import { Inject, Injectable } from '@nestjs/common';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { IPricesApi } from '@/datasources/balances-api/prices-api.interface';
import {
  AssetPrice,
  AssetPriceSchema,
} from '@/datasources/balances-api/entities/asset-price.entity';
import { CacheFirstDataSource } from '../cache/cache.first.data.source';
import { CacheRouter } from '../cache/cache.router';
import { DataSourceError } from '@/domain/errors/data-source.error';
import {
  CacheService,
  ICacheService,
} from '@/datasources/cache/cache.service.interface';
import {
  NetworkService,
  INetworkService,
} from '@/datasources/network/network.service.interface';
import { difference, get, random } from 'lodash';
import { LoggingService, ILoggingService } from '@/logging/logging.interface';
import { NetworkResponseError } from '@/datasources/network/entities/network.error.entity';
import { asError } from '@/logging/utils';
import { Chain } from '@/domain/chains/entities/chain.entity';

@Injectable()
export class CoingeckoApi implements IPricesApi {
  /**
   *  Coingecko API Key header name. To be included in http requests when using a paid subscription.
   */
  private static readonly COINGECKO_API_HEADER: string = 'x-cg-pro-api-key';
  /**
   * Coingecko API maximum amount of token addresses being requested in the same call.
   */
  private static readonly MAX_BATCH_SIZE: number = 100;
  /**
   * Time range in seconds used to get a random value when calculating a TTL for not-found token prices.
   */
  static readonly NOT_FOUND_TTL_RANGE_SECONDS: number = 600; // 10 minutes
  private readonly apiKey: string | undefined;
  private readonly baseUrl: string;
  private readonly defaultExpirationTimeInSeconds: number;
  private readonly defaultNotFoundExpirationTimeSeconds: number;
  private readonly pricesTtlSeconds: number;
  /**
   * TTL in seconds for native coin prices.
   */
  private readonly nativeCoinPricesTtlSeconds: number;
  /**
   * TTL in seconds for a not found token price.
   */
  private readonly notFoundPriceTtlSeconds: number;
  /**
   * Token addresses that will be cached with a highRefreshRateTokensTtlSeconds TTL.
   */
  private readonly highRefreshRateTokens: string[];
  /**
   * TTL in seconds for high-rate refresh token prices.
   */
  private readonly highRefreshRateTokensTtlSeconds: number;

  constructor(
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    private readonly dataSource: CacheFirstDataSource,
    @Inject(NetworkService) private readonly networkService: INetworkService,
    @Inject(CacheService) private readonly cacheService: ICacheService,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
  ) {
    this.apiKey = this.configurationService.get<string>(
      'balances.providers.safe.prices.apiKey',
    );
    this.baseUrl = this.configurationService.getOrThrow<string>(
      'balances.providers.safe.prices.baseUri',
    );
    this.defaultExpirationTimeInSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.default',
      );
    this.pricesTtlSeconds = this.configurationService.getOrThrow<number>(
      'balances.providers.safe.prices.pricesTtlSeconds',
    );
    this.nativeCoinPricesTtlSeconds =
      this.configurationService.getOrThrow<number>(
        'balances.providers.safe.prices.nativeCoinPricesTtlSeconds',
      );
    this.notFoundPriceTtlSeconds = this.configurationService.getOrThrow<number>(
      'balances.providers.safe.prices.notFoundPriceTtlSeconds',
    );
    this.defaultNotFoundExpirationTimeSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.notFound.default',
      );
    // Coingecko expects the token addresses to be lowercase, so lowercase addresses are enforced here.
    this.highRefreshRateTokens = this.configurationService
      .getOrThrow<
        string[]
      >('balances.providers.safe.prices.highRefreshRateTokens')
      .map((tokenAddress) => tokenAddress.toLowerCase());

    this.highRefreshRateTokensTtlSeconds =
      this.configurationService.getOrThrow<number>(
        'balances.providers.safe.prices.highRefreshRateTokensTtlSeconds',
      );
  }

  /**
   * Gets prices for a chain's native coin, trying to get it from cache first.
   * If it's not found in the cache, it tries to retrieve it from the Coingecko API.
   *
   * @param args.chain Chain entity containing the chain-specific configuration
   * @param args.fiatCode
   * @returns number representing the native coin price, or null if not found.
   */
  async getNativeCoinPrice(args: {
    chain: Chain;
    fiatCode: string;
  }): Promise<number | null> {
    try {
      const nativeCoinId = args.chain.pricesProvider.nativeCoin;
      if (nativeCoinId == null) {
        throw new DataSourceError('pricesProvider.nativeCoinId is not defined');
      }
      const lowerCaseFiatCode = args.fiatCode.toLowerCase();
      const cacheDir = CacheRouter.getNativeCoinPriceCacheDir({
        nativeCoinId,
        fiatCode: lowerCaseFiatCode,
      });
      const url = `${this.baseUrl}/simple/price`;
      const result = await this.dataSource.get<AssetPrice>({
        cacheDir,
        url,
        networkRequest: {
          params: {
            vs_currencies: lowerCaseFiatCode,
            ids: nativeCoinId,
          },
          ...(this.apiKey && {
            headers: {
              [CoingeckoApi.COINGECKO_API_HEADER]: this.apiKey,
            },
          }),
        },
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        expireTimeSeconds: this.nativeCoinPricesTtlSeconds,
      });
      return result?.[nativeCoinId]?.[lowerCaseFiatCode];
    } catch (error) {
      // Error at this level are logged out, but not thrown to the upper layers.
      // The service won't throw an error if a single coin price retrieval fails.
      this.loggingService.error(
        `Error getting native coin price: ${asError(error)} `,
      );
      return null;
    }
  }

  /**
   * Gets prices for a set of token addresses, trying to get them from cache first.
   * For those not found in the cache, it tries to retrieve them from the Coingecko API.
   *
   * @param args.chain Chain entity containing the chain-specific configuration
   * @param args.tokenAddresses Array of token addresses which prices are being retrieved
   * @param args.fiatCode
   * @returns Array of {@link AssetPrice}
   */
  async getTokenPrices(args: {
    chain: Chain;
    tokenAddresses: string[];
    fiatCode: string;
  }): Promise<AssetPrice[]> {
    try {
      const chainName = args.chain.pricesProvider.chainName;
      if (chainName == null) {
        throw new DataSourceError('pricesProvider.chainName is not defined');
      }
      const lowerCaseFiatCode = args.fiatCode.toLowerCase();
      const lowerCaseTokenAddresses = args.tokenAddresses.map((address) =>
        address.toLowerCase(),
      );
      const pricesFromCache = await this._getTokenPricesFromCache({
        chainName,
        tokenAddresses: lowerCaseTokenAddresses,
        fiatCode: lowerCaseFiatCode,
      });
      const notCachedTokenPrices = difference(
        lowerCaseTokenAddresses,
        pricesFromCache.map((assetPrice) => Object.keys(assetPrice)).flat(),
      );
      const pricesFromNetwork = notCachedTokenPrices.length
        ? await this._getTokenPricesFromNetwork({
            chainName,
            fiatCode: lowerCaseFiatCode,
            tokenAddresses: notCachedTokenPrices,
          })
        : [];

      return [pricesFromCache, pricesFromNetwork].flat();
    } catch (error) {
      // Error at this level are logged out, but not thrown to the upper layers.
      // The service won't throw an error if a single token price retrieval fails.
      this.loggingService.error(
        `Error getting token prices: ${asError(error)} `,
      );
      return [];
    }
  }

  async getFiatCodes(): Promise<string[]> {
    try {
      const cacheDir = CacheRouter.getPriceFiatCodesCacheDir();
      const url = `${this.baseUrl}/simple/supported_vs_currencies`;
      const result = await this.dataSource.get<string[]>({
        cacheDir,
        url,
        networkRequest: {
          ...(this.apiKey && {
            headers: {
              [CoingeckoApi.COINGECKO_API_HEADER]: this.apiKey,
            },
          }),
        },
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        expireTimeSeconds: this.defaultExpirationTimeInSeconds,
      });
      return result.map((item) => item.toUpperCase());
    } catch (error) {
      this.loggingService.error(
        `CoinGecko error getting fiat codes: ${asError(error)} `,
      );
      return [];
    }
  }

  private _mapProviderError(error: unknown): string {
    const errorCode =
      error instanceof NetworkResponseError && get(error, 'data.error_code');
    return errorCode ? ` [status: ${errorCode}]` : '';
  }

  /**
   * For an array of token addresses, gets the prices available from cache.
   */
  private async _getTokenPricesFromCache(args: {
    chainName: string;
    tokenAddresses: string[];
    fiatCode: string;
  }): Promise<AssetPrice[]> {
    const result: AssetPrice[] = [];
    for (const tokenAddress of args.tokenAddresses) {
      const cacheDir = CacheRouter.getTokenPriceCacheDir({
        ...args,
        tokenAddress,
      });
      const cached = await this.cacheService.get(cacheDir);
      const { key, field } = cacheDir;
      if (cached != null) {
        this.loggingService.debug({ type: 'cache_hit', key, field });
        const cachedAssetPrice = AssetPriceSchema.parse(JSON.parse(cached));
        result.push(cachedAssetPrice);
      } else {
        this.loggingService.debug({ type: 'cache_miss', key, field });
      }
    }
    return result;
  }

  /**
   * For an array of token addresses, gets the prices available from the CoinGecko API.
   * Stores both retrieved prices and not-found prices in cache.
   */
  private async _getTokenPricesFromNetwork(args: {
    chainName: string;
    tokenAddresses: string[];
    fiatCode: string;
  }): Promise<AssetPrice[]> {
    const prices = await this._requestPricesFromNetwork({
      ...args,
      tokenAddresses: args.tokenAddresses.slice(0, CoingeckoApi.MAX_BATCH_SIZE),
    });

    return Promise.all(
      args.tokenAddresses.map(async (tokenAddress) => {
        const validPrice = prices[tokenAddress]?.[args.fiatCode];
        const price: AssetPrice = validPrice
          ? { [tokenAddress]: { [args.fiatCode]: validPrice } }
          : { [tokenAddress]: { [args.fiatCode]: null } };
        await this.cacheService.set(
          CacheRouter.getTokenPriceCacheDir({ ...args, tokenAddress }),
          JSON.stringify(price),
          this._getTtl(validPrice, tokenAddress),
        );
        return price;
      }),
    );
  }

  /**
   * Gets the cache TTL for storing the price value.
   * If the token address is included in {@link highRefreshRateTokens} (defaults to []),
   * then {@link highRefreshRateTokensTtlSeconds} is used (defaults to 30 seconds).
   * If the price cannot ve retrieved (or it's zero) {@link _getRandomNotFoundTokenPriceTtl} is called.
   * Else {@link pricesTtlSeconds} is used (defaults to 300 seconds).
   */
  private _getTtl(
    price: number | null | undefined,
    tokenAddress: string,
  ): number {
    if (this.highRefreshRateTokens.includes(tokenAddress)) {
      return this.highRefreshRateTokensTtlSeconds;
    }

    return !price
      ? this._getRandomNotFoundTokenPriceTtl()
      : this.pricesTtlSeconds;
  }

  /**
   * Requests the token prices provided by the CoinGecko API, using the {@link NetworkService}.
   */
  private async _requestPricesFromNetwork(args: {
    chainName: string;
    tokenAddresses: string[];
    fiatCode: string;
  }): Promise<AssetPrice> {
    try {
      const url = `${this.baseUrl}/simple/token_price/${args.chainName}`;
      const { data } = await this.networkService.get<AssetPrice>({
        url,
        networkRequest: {
          params: {
            vs_currencies: args.fiatCode,
            contract_addresses: args.tokenAddresses.join(','),
          },
          ...(this.apiKey && {
            headers: {
              [CoingeckoApi.COINGECKO_API_HEADER]: this.apiKey,
            },
          }),
        },
      });
      return data;
    } catch (error) {
      throw new DataSourceError(
        `Error getting ${
          args.tokenAddresses
        } price from provider${this._mapProviderError(error)}`,
      );
    }
  }

  /**
   * Gets a random integer value between notFoundPriceTtlSeconds and (notFoundPriceTtlSeconds + notFoundTtlRangeSeconds).
   * The minimum result will be greater than notFoundTtlRangeSeconds to avoid having a negative TTL.
   */
  private _getRandomNotFoundTokenPriceTtl(): number {
    return random(
      this.notFoundPriceTtlSeconds,
      this.notFoundPriceTtlSeconds + CoingeckoApi.NOT_FOUND_TTL_RANGE_SECONDS,
    );
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	16✔
2	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
3	import { IPricesApi } from '@/datasources/balances-api/prices-api.interface';
4	import {	16✔
5	AssetPrice,
6	AssetPriceSchema,
7	} from '@/datasources/balances-api/entities/asset-price.entity';
8	import { CacheFirstDataSource } from '../cache/cache.first.data.source';	16✔
9	import { CacheRouter } from '../cache/cache.router';	16✔
10	import { DataSourceError } from '@/domain/errors/data-source.error';	16✔
11	import {	16✔
12	CacheService,
13	ICacheService,
14	} from '@/datasources/cache/cache.service.interface';
15	import {	16✔
16	NetworkService,
17	INetworkService,
18	} from '@/datasources/network/network.service.interface';
19	import { difference, get, random } from 'lodash';	16✔
20	import { LoggingService, ILoggingService } from '@/logging/logging.interface';	16✔
21	import { NetworkResponseError } from '@/datasources/network/entities/network.error.entity';	16✔
22	import { asError } from '@/logging/utils';	16✔
23	import { Chain } from '@/domain/chains/entities/chain.entity';
24
25	@Injectable()
26	export class CoingeckoApi implements IPricesApi {	16✔
27	/**
28	* Coingecko API Key header name. To be included in http requests when using a paid subscription.
29	*/
30	private static readonly COINGECKO_API_HEADER: string = 'x-cg-pro-api-key';	16✔
31	/**
32	* Coingecko API maximum amount of token addresses being requested in the same call.
33	*/
34	private static readonly MAX_BATCH_SIZE: number = 100;	16✔
35	/**
36	* Time range in seconds used to get a random value when calculating a TTL for not-found token prices.
37	*/
38	static readonly NOT_FOUND_TTL_RANGE_SECONDS: number = 600; // 10 minutes	16✔
39	private readonly apiKey: string \| undefined;
40	private readonly baseUrl: string;
41	private readonly defaultExpirationTimeInSeconds: number;
42	private readonly defaultNotFoundExpirationTimeSeconds: number;
43	private readonly pricesTtlSeconds: number;
44	/**
45	* TTL in seconds for native coin prices.
46	*/
47	private readonly nativeCoinPricesTtlSeconds: number;
48	/**
49	* TTL in seconds for a not found token price.
50	*/
51	private readonly notFoundPriceTtlSeconds: number;
52	/**
53	* Token addresses that will be cached with a highRefreshRateTokensTtlSeconds TTL.
54	*/
55	private readonly highRefreshRateTokens: string[];
56	/**
57	* TTL in seconds for high-rate refresh token prices.
58	*/
59	private readonly highRefreshRateTokensTtlSeconds: number;
60
61	constructor(
62	@Inject(IConfigurationService)
63	private readonly configurationService: IConfigurationService,	16✔
64	private readonly dataSource: CacheFirstDataSource,	16✔
65	@Inject(NetworkService) private readonly networkService: INetworkService,	16✔
66	@Inject(CacheService) private readonly cacheService: ICacheService,	16✔
67	@Inject(LoggingService) private readonly loggingService: ILoggingService,	16✔
68	) {
69	this.apiKey = this.configurationService.get<string>(	16✔
70	'balances.providers.safe.prices.apiKey',
71	);
72	this.baseUrl = this.configurationService.getOrThrow<string>(	16✔
73	'balances.providers.safe.prices.baseUri',
74	);
75	this.defaultExpirationTimeInSeconds =	16✔
76	this.configurationService.getOrThrow<number>(
77	'expirationTimeInSeconds.default',
78	);
79	this.pricesTtlSeconds = this.configurationService.getOrThrow<number>(	16✔
80	'balances.providers.safe.prices.pricesTtlSeconds',
81	);
82	this.nativeCoinPricesTtlSeconds =	16✔
83	this.configurationService.getOrThrow<number>(
84	'balances.providers.safe.prices.nativeCoinPricesTtlSeconds',
85	);
86	this.notFoundPriceTtlSeconds = this.configurationService.getOrThrow<number>(	16✔
87	'balances.providers.safe.prices.notFoundPriceTtlSeconds',
88	);
89	this.defaultNotFoundExpirationTimeSeconds =	16✔
90	this.configurationService.getOrThrow<number>(
91	'expirationTimeInSeconds.notFound.default',
92	);
93	// Coingecko expects the token addresses to be lowercase, so lowercase addresses are enforced here.
94	this.highRefreshRateTokens = this.configurationService	16✔
95	.getOrThrow<
96	string[]
97	>('balances.providers.safe.prices.highRefreshRateTokens')
98	.map((tokenAddress) => tokenAddress.toLowerCase());	×
99
100	this.highRefreshRateTokensTtlSeconds =	16✔
101	this.configurationService.getOrThrow<number>(
102	'balances.providers.safe.prices.highRefreshRateTokensTtlSeconds',
103	);
104	}
105
106	/**
107	* Gets prices for a chain's native coin, trying to get it from cache first.
108	* If it's not found in the cache, it tries to retrieve it from the Coingecko API.
109	*
110	* @param args.chain Chain entity containing the chain-specific configuration
111	* @param args.fiatCode
112	* @returns number representing the native coin price, or null if not found.
113	*/
114	async getNativeCoinPrice(args: {
115	chain: Chain;
116	fiatCode: string;
117	}): Promise<number \| null> {
118	try {	×
119	const nativeCoinId = args.chain.pricesProvider.nativeCoin;	×
NEW 120	if (nativeCoinId == null) {	×
NEW 121	throw new DataSourceError('pricesProvider.nativeCoinId is not defined');	×
122	}
NEW 123	const lowerCaseFiatCode = args.fiatCode.toLowerCase();	×
UNCOV 124	const cacheDir = CacheRouter.getNativeCoinPriceCacheDir({	×
125	nativeCoinId,
126	fiatCode: lowerCaseFiatCode,
127	});
128	const url = `${this.baseUrl}/simple/price`;	×
129	const result = await this.dataSource.get<AssetPrice>({	×
130	cacheDir,
131	url,
132	networkRequest: {
133	params: {
134	vs_currencies: lowerCaseFiatCode,
135	ids: nativeCoinId,
136	},
137	...(this.apiKey && {	×
138	headers: {
139	[CoingeckoApi.COINGECKO_API_HEADER]: this.apiKey,
140	},
141	}),
142	},
143	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
144	expireTimeSeconds: this.nativeCoinPricesTtlSeconds,
145	});
146	return result?.[nativeCoinId]?.[lowerCaseFiatCode];	×
147	} catch (error) {
148	// Error at this level are logged out, but not thrown to the upper layers.
149	// The service won't throw an error if a single coin price retrieval fails.
150	this.loggingService.error(	×
151	`Error getting native coin price: ${asError(error)} `,
152	);
153	return null;	×
154	}
155	}
156
157	/**
158	* Gets prices for a set of token addresses, trying to get them from cache first.
159	* For those not found in the cache, it tries to retrieve them from the Coingecko API.
160	*
161	* @param args.chain Chain entity containing the chain-specific configuration
162	* @param args.tokenAddresses Array of token addresses which prices are being retrieved
163	* @param args.fiatCode
164	* @returns Array of {@link AssetPrice}
165	*/
166	async getTokenPrices(args: {
167	chain: Chain;
168	tokenAddresses: string[];
169	fiatCode: string;
170	}): Promise<AssetPrice[]> {
171	try {	×
NEW 172	const chainName = args.chain.pricesProvider.chainName;	×
NEW 173	if (chainName == null) {	×
NEW 174	throw new DataSourceError('pricesProvider.chainName is not defined');	×
175	}
176	const lowerCaseFiatCode = args.fiatCode.toLowerCase();	×
177	const lowerCaseTokenAddresses = args.tokenAddresses.map((address) =>	×
178	address.toLowerCase(),	×
179	);
180	const pricesFromCache = await this._getTokenPricesFromCache({	×
181	chainName,
182	tokenAddresses: lowerCaseTokenAddresses,
183	fiatCode: lowerCaseFiatCode,
184	});
185	const notCachedTokenPrices = difference(	×
186	lowerCaseTokenAddresses,
187	pricesFromCache.map((assetPrice) => Object.keys(assetPrice)).flat(),	×
188	);
189	const pricesFromNetwork = notCachedTokenPrices.length	×
190	? await this._getTokenPricesFromNetwork({
191	chainName,
192	fiatCode: lowerCaseFiatCode,
193	tokenAddresses: notCachedTokenPrices,
194	})
195	: [];
196
197	return [pricesFromCache, pricesFromNetwork].flat();	×
198	} catch (error) {
199	// Error at this level are logged out, but not thrown to the upper layers.
200	// The service won't throw an error if a single token price retrieval fails.
201	this.loggingService.error(	×
202	`Error getting token prices: ${asError(error)} `,
203	);
204	return [];	×
205	}
206	}
207
208	async getFiatCodes(): Promise<string[]> {
209	try {	×
210	const cacheDir = CacheRouter.getPriceFiatCodesCacheDir();	×
211	const url = `${this.baseUrl}/simple/supported_vs_currencies`;	×
212	const result = await this.dataSource.get<string[]>({	×
213	cacheDir,
214	url,
215	networkRequest: {
216	...(this.apiKey && {	×
217	headers: {
218	[CoingeckoApi.COINGECKO_API_HEADER]: this.apiKey,
219	},
220	}),
221	},
222	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
223	expireTimeSeconds: this.defaultExpirationTimeInSeconds,
224	});
225	return result.map((item) => item.toUpperCase());	×
226	} catch (error) {
227	this.loggingService.error(	×
228	`CoinGecko error getting fiat codes: ${asError(error)} `,
229	);
230	return [];	×
231	}
232	}
233
234	private _mapProviderError(error: unknown): string {
235	const errorCode =
236	error instanceof NetworkResponseError && get(error, 'data.error_code');	×
237	return errorCode ? ` [status: ${errorCode}]` : '';	×
238	}
239
240	/**
241	* For an array of token addresses, gets the prices available from cache.
242	*/
243	private async _getTokenPricesFromCache(args: {
244	chainName: string;
245	tokenAddresses: string[];
246	fiatCode: string;
247	}): Promise<AssetPrice[]> {
248	const result: AssetPrice[] = [];	×
249	for (const tokenAddress of args.tokenAddresses) {	×
250	const cacheDir = CacheRouter.getTokenPriceCacheDir({	×
251	...args,
252	tokenAddress,
253	});
254	const cached = await this.cacheService.get(cacheDir);	×
255	const { key, field } = cacheDir;	×
256	if (cached != null) {	×
257	this.loggingService.debug({ type: 'cache_hit', key, field });	×
258	const cachedAssetPrice = AssetPriceSchema.parse(JSON.parse(cached));	×
259	result.push(cachedAssetPrice);	×
260	} else {
261	this.loggingService.debug({ type: 'cache_miss', key, field });	×
262	}
263	}
264	return result;	×
265	}
266
267	/**
268	* For an array of token addresses, gets the prices available from the CoinGecko API.
269	* Stores both retrieved prices and not-found prices in cache.
270	*/
271	private async _getTokenPricesFromNetwork(args: {
272	chainName: string;
273	tokenAddresses: string[];
274	fiatCode: string;
275	}): Promise<AssetPrice[]> {
276	const prices = await this._requestPricesFromNetwork({	×
277	...args,
278	tokenAddresses: args.tokenAddresses.slice(0, CoingeckoApi.MAX_BATCH_SIZE),
279	});
280
281	return Promise.all(	×
282	args.tokenAddresses.map(async (tokenAddress) => {
283	const validPrice = prices[tokenAddress]?.[args.fiatCode];	×
284	const price: AssetPrice = validPrice	×
285	? { [tokenAddress]: { [args.fiatCode]: validPrice } }
286	: { [tokenAddress]: { [args.fiatCode]: null } };
287	await this.cacheService.set(	×
288	CacheRouter.getTokenPriceCacheDir({ ...args, tokenAddress }),
289	JSON.stringify(price),
290	this._getTtl(validPrice, tokenAddress),
291	);
292	return price;	×
293	}),
294	);
295	}
296
297	/**
298	* Gets the cache TTL for storing the price value.
299	* If the token address is included in {@link highRefreshRateTokens} (defaults to []),
300	* then {@link highRefreshRateTokensTtlSeconds} is used (defaults to 30 seconds).
301	* If the price cannot ve retrieved (or it's zero) {@link _getRandomNotFoundTokenPriceTtl} is called.
302	* Else {@link pricesTtlSeconds} is used (defaults to 300 seconds).
303	*/
304	private _getTtl(
305	price: number \| null \| undefined,
306	tokenAddress: string,
307	): number {
308	if (this.highRefreshRateTokens.includes(tokenAddress)) {	×
309	return this.highRefreshRateTokensTtlSeconds;	×
310	}
311
312	return !price	×
313	? this._getRandomNotFoundTokenPriceTtl()
314	: this.pricesTtlSeconds;
315	}
316
317	/**
318	* Requests the token prices provided by the CoinGecko API, using the {@link NetworkService}.
319	*/
320	private async _requestPricesFromNetwork(args: {
321	chainName: string;
322	tokenAddresses: string[];
323	fiatCode: string;
324	}): Promise<AssetPrice> {
325	try {	×
326	const url = `${this.baseUrl}/simple/token_price/${args.chainName}`;	×
327	const { data } = await this.networkService.get<AssetPrice>({	×
328	url,
329	networkRequest: {
330	params: {
331	vs_currencies: args.fiatCode,
332	contract_addresses: args.tokenAddresses.join(','),
333	},
334	...(this.apiKey && {	×
335	headers: {
336	[CoingeckoApi.COINGECKO_API_HEADER]: this.apiKey,
337	},
338	}),
339	},
340	});
341	return data;	×
342	} catch (error) {
343	throw new DataSourceError(	×
344	`Error getting ${
345	args.tokenAddresses
346	} price from provider${this._mapProviderError(error)}`,
347	);
348	}
349	}
350
351	/**
352	* Gets a random integer value between notFoundPriceTtlSeconds and (notFoundPriceTtlSeconds + notFoundTtlRangeSeconds).
353	* The minimum result will be greater than notFoundTtlRangeSeconds to avoid having a negative TTL.
354	*/
355	private _getRandomNotFoundTokenPriceTtl(): number {
356	return random(	×
357	this.notFoundPriceTtlSeconds,
358	this.notFoundPriceTtlSeconds + CoingeckoApi.NOT_FOUND_TTL_RANGE_SECONDS,
359	);
360	}
361	}

safe-global / safe-client-gateway / 9775961080

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous