9448387095

Committed 10 Jun 2024 11:31AM UTC coverage: 92.748% (+0.05%) from 92.7%

Build # 9448387095

Build Type

push

github

Committed by

web-flow

Commit Message

Add FF_COUNTERFACTUAL_BALANCES (#1625)

Add FF_COUNTERFACTUAL_BALANCES

Run Details

2002 of 2457 branches covered (81.48%)

Branch coverage included in aggregate %.

8 of 8 new or added lines in 1 file covered. (100.0%)

4 existing lines in 1 file now uncovered.

7129 of 7388 relevant lines covered (96.49%)

328.0 hits per line

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

81.9

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

import { IConfigurationService } from '@/config/configuration.service.interface';
import { ChainAttributes } from '@/datasources/balances-api/entities/provider-chain-attributes.entity';
import {
  ZerionAttributes,
  ZerionBalance,
  ZerionBalanceSchema,
  ZerionBalances,
  ZerionBalancesSchema,
} from '@/datasources/balances-api/entities/zerion-balance.entity';
import {
  ZerionCollectible,
  ZerionCollectibles,
  ZerionCollectiblesSchema,
} from '@/datasources/balances-api/entities/zerion-collectible.entity';
import { CacheRouter } from '@/datasources/cache/cache.router';
import {
  CacheService,
  ICacheService,
} from '@/datasources/cache/cache.service.interface';
import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';
import { LimitReachedError } from '@/datasources/network/entities/errors/limit-reached.error';
import {
  INetworkService,
  NetworkService,
} from '@/datasources/network/network.service.interface';
import {
  Balance,
  Erc20Balance,
  NativeBalance,
} from '@/domain/balances/entities/balance.entity';
import { Collectible } from '@/domain/collectibles/entities/collectible.entity';
import { getNumberString } from '@/domain/common/utils/utils';
import { Page } from '@/domain/entities/page.entity';
import { DataSourceError } from '@/domain/errors/data-source.error';
import { IBalancesApi } from '@/domain/interfaces/balances-api.interface';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { Inject, Injectable } from '@nestjs/common';
import { getAddress } from 'viem';
import { z } from 'zod';

export const IZerionBalancesApi = Symbol('IZerionBalancesApi');

@Injectable()
export class ZerionBalancesApi implements IBalancesApi {
  private static readonly COLLECTIBLES_SORTING = '-floor_price';
  private static readonly RATE_LIMIT_CACHE_KEY_PREFIX = 'zerion';
  private readonly apiKey: string | undefined;
  private readonly baseUri: string;
  private readonly chainsConfiguration: Record<number, ChainAttributes>;
  private readonly defaultExpirationTimeInSeconds: number;
  private readonly defaultNotFoundExpirationTimeSeconds: number;
  private readonly fiatCodes: string[];
  // Number of seconds for each rate-limit cycle
  private readonly limitPeriodSeconds: number;
  // Number of allowed calls on each rate-limit cycle
  private readonly limitCalls: number;

  constructor(
    @Inject(CacheService) private readonly cacheService: ICacheService,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    @Inject(NetworkService) private readonly networkService: INetworkService,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    private readonly httpErrorFactory: HttpErrorFactory,
  ) {
    this.apiKey = this.configurationService.get<string>(
      'balances.providers.zerion.apiKey',
    );
    this.baseUri = this.configurationService.getOrThrow<string>(
      'balances.providers.zerion.baseUri',
    );
    this.defaultExpirationTimeInSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.default',
      );
    this.defaultNotFoundExpirationTimeSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.notFound.default',
      );
    this.chainsConfiguration = this.configurationService.getOrThrow<
      Record<number, ChainAttributes>
    >('balances.providers.zerion.chains');
    this.fiatCodes = this.configurationService
      .getOrThrow<string[]>('balances.providers.zerion.currencies')
      .map((currency) => currency.toUpperCase());
    this.limitPeriodSeconds = configurationService.getOrThrow(
      'balances.providers.zerion.limitPeriodSeconds',
    );
    this.limitCalls = configurationService.getOrThrow(
      'balances.providers.zerion.limitCalls',
    );
  }

  async getBalances(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    fiatCode: string;
  }): Promise<Balance[]> {
    if (!this.fiatCodes.includes(args.fiatCode.toUpperCase())) {
      throw new DataSourceError(
        `Unsupported currency code: ${args.fiatCode}`,
        400,
      );
    }

    const cacheDir = CacheRouter.getZerionBalancesCacheDir(args);
    const chainName = this._getChainName(args.chainId);
    const cached = await this.cacheService.get(cacheDir);
    if (cached != null) {
      const { key, field } = cacheDir;
      this.loggingService.debug({ type: 'cache_hit', key, field });
      const zerionBalances = z
        .array(ZerionBalanceSchema)
        .parse(JSON.parse(cached));
      return this._mapBalances(chainName, zerionBalances);
    }

    try {
      await this._checkRateLimit();
      const { key, field } = cacheDir;
      this.loggingService.debug({ type: 'cache_miss', key, field });
      const url = `${this.baseUri}/v1/wallets/${args.safeAddress}/positions`;
      const networkRequest = {
        headers: { Authorization: `Basic ${this.apiKey}` },
        params: {
          'filter[chain_ids]': chainName,
          currency: args.fiatCode.toLowerCase(),
          sort: 'value',
        },
      };
      const { data } = await this.networkService.get<ZerionBalances>({
        url,
        networkRequest,
      });
      const zerionBalances = ZerionBalancesSchema.parse(data);
      await this.cacheService.set(
        cacheDir,
        JSON.stringify(zerionBalances.data),
        this.defaultExpirationTimeInSeconds,
      );
      return this._mapBalances(chainName, data.data);
    } catch (error) {
      if (error instanceof LimitReachedError) {
        throw new DataSourceError(error.message, 429);
      }
      throw this.httpErrorFactory.from(error);
    }
  }

  /**
   * NOTE: Zerion does not support limit & offset parameters.
   * Documentation: https://developers.zerion.io/reference/listwalletnftpositions
   *
   * It uses a "size" query param for the page size, and an "after" parameter for the offset.
   * "size" is an integer which could be mapped to "limit", but "after" is a base64-encoded string.
   *
   * Since this setup does not align well with the CGW API, it is needed to encode/decode these parameters.
   */
  async getCollectibles(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    limit?: number;
    offset?: number;
  }): Promise<Page<Collectible>> {
    const cacheDir = CacheRouter.getZerionCollectiblesCacheDir(args);
    const cached = await this.cacheService.get(cacheDir);
    if (cached != null) {
      const { key, field } = cacheDir;
      this.loggingService.debug({ type: 'cache_hit', key, field });
      const data = ZerionCollectiblesSchema.parse(JSON.parse(cached));
      return this._buildCollectiblesPage(data.links.next, data.data);
    } else {
      try {
        await this._checkRateLimit();
        const chainName = this._getChainName(args.chainId);
        const url = `${this.baseUri}/v1/wallets/${args.safeAddress}/nft-positions`;
        const pageAfter = this._encodeZerionPageOffset(args.offset);
        const networkRequest = {
          headers: { Authorization: `Basic ${this.apiKey}` },
          params: {
            'filter[chain_ids]': chainName,
            sort: ZerionBalancesApi.COLLECTIBLES_SORTING,
            'page[size]': args.limit,
            ...(pageAfter && { 'page[after]': pageAfter }),
          },
        };
        const { data } = await this.networkService.get<ZerionCollectibles>({
          url,
          networkRequest,
        });
        await this.cacheService.set(
          cacheDir,
          JSON.stringify(data),
          this.defaultExpirationTimeInSeconds,
        );
        return this._buildCollectiblesPage(data.links.next, data.data);
      } catch (error) {
        throw this.httpErrorFactory.from(error);
      }
    }
  }

  async clearCollectibles(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<void> {
    const key = CacheRouter.getZerionCollectiblesCacheKey(args);
    await this.cacheService.deleteByKey(key);
  }

  private _mapBalances(
    chainName: string,
    zerionBalances: ZerionBalance[],
  ): Balance[] {
    return zerionBalances
      .filter((zb) => zb.attributes.flags.displayable)
      .map((zb) => {
        const implementation = zb.attributes.fungible_info.implementations.find(
          (implementation) => implementation.chain_id === chainName,
        );
        if (!implementation)
          throw Error(
            `Zerion error: ${chainName} implementation not found for balance ${zb.id}`,
          );
        const { value } = zb.attributes;
        const fiatBalance = value ? getNumberString(value) : null;
        const fiatConversion = getNumberString(zb.attributes.price);

        return {
          ...(implementation.address === null
            ? this._mapNativeBalance(zb.attributes)
            : this._mapErc20Balance(zb.attributes, implementation.address)),
          fiatBalance,
          fiatConversion,
        };
      });
  }

  async getFiatCodes(): Promise<string[]> {
    // Resolving to conform with interface
    return Promise.resolve(this.fiatCodes);
  }

  private _mapErc20Balance(
    zerionBalanceAttributes: ZerionAttributes,
    tokenAddress: string,
  ): Erc20Balance {
    const { fungible_info, quantity } = zerionBalanceAttributes;
    return {
      tokenAddress: getAddress(tokenAddress),
      token: {
        name: fungible_info.name ?? '',
        symbol: fungible_info.symbol ?? '',
        decimals: quantity.decimals,
        logoUri: fungible_info.icon?.url ?? '',
      },
      balance: quantity.int,
    };
  }

  private _mapNativeBalance(
    zerionBalanceAttributes: ZerionAttributes,
  ): NativeBalance {
    return {
      tokenAddress: null,
      token: null,
      balance: zerionBalanceAttributes.quantity.int,
    };
  }

  async clearBalances(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<void> {
    const key = CacheRouter.getZerionBalancesCacheKey(args);
    await this.cacheService.deleteByKey(key);
  }

  private _getChainName(chainId: string): string {
    const chainName = this.chainsConfiguration[Number(chainId)]?.chainName;
    if (!chainName)
      throw Error(
        `Chain ${chainId} balances retrieval via Zerion is not configured`,
      );
    return chainName;
  }

  private _buildCollectiblesPage(
    next: string | null,
    data: ZerionCollectible[],
  ): Page<Collectible> {
    // Zerion does not provide the items count.
    // Zerion does not provide a "previous" cursor.
    return {
      count: null,
      next: next ? this._decodeZerionPagination(next) : null,
      previous: null,
      results: this._mapCollectibles(data),
    };
  }

  private _mapCollectibles(
    zerionCollectibles: ZerionCollectible[],
  ): Collectible[] {
    return zerionCollectibles.map(
      ({ attributes: { nft_info, collection_info } }) => ({
        address: nft_info.contract_address,
        tokenName: nft_info.name ?? '',
        tokenSymbol: nft_info.name ?? '',
        logoUri: collection_info?.content?.icon.url ?? '',
        id: nft_info.token_id,
        uri: nft_info.content?.detail?.url ?? null,
        name: collection_info?.name ?? null,
        description: collection_info?.description ?? null,
        imageUri: nft_info.content?.preview?.url ?? '',
        metadata: nft_info.content,
      }),
    );
  }

  /**
   * Zerion represents cursor offsets by base64 string
   * contained within double quotation marks.
   *
   * @param offset number representing the offset
   * @returns base64 string representing the offset
   */
  private _encodeZerionPageOffset(offset?: number): string | null {
    return offset
      ? Buffer.from(`"${offset}"`, 'utf8').toString('base64')
      : null;
  }

  /**
   * Zerion uses page[size] as pagination limit.
   * Zerion uses page[after] as pagination offset, which is a
   * base64 string contained within double quotation marks.
   *
   * @param url Zerion-formatted string representing an URL
   * @returns URL string optionally containing "limit" and "offset" query params
   */
  private _decodeZerionPagination(url: string): string {
    const zerionUrl = new URL(url);
    const size = zerionUrl.searchParams.get('page[size]');
    const after = zerionUrl.searchParams.get('page[after]');

    if (size) zerionUrl.searchParams.set('limit', size);
    if (after) {
      zerionUrl.searchParams.set(
        'offset',
        Buffer.from(after ?? '0', 'base64')
          .toString('utf8')
          .replace(/"/g, ''),
      );
    }
    return zerionUrl.toString();
  }

  private async _checkRateLimit(): Promise<void> {
    const current = await this.cacheService.increment(
      CacheRouter.getRateLimitCacheKey(
        ZerionBalancesApi.RATE_LIMIT_CACHE_KEY_PREFIX,
      ),
      this.limitPeriodSeconds,
    );
    if (current > this.limitCalls) throw new LimitReachedError();
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	100✔
2	import { ChainAttributes } from '@/datasources/balances-api/entities/provider-chain-attributes.entity';
3	import {	100✔
4	ZerionAttributes,
5	ZerionBalance,
6	ZerionBalanceSchema,
7	ZerionBalances,
8	ZerionBalancesSchema,
9	} from '@/datasources/balances-api/entities/zerion-balance.entity';
10	import {	100✔
11	ZerionCollectible,
12	ZerionCollectibles,
13	ZerionCollectiblesSchema,
14	} from '@/datasources/balances-api/entities/zerion-collectible.entity';
15	import { CacheRouter } from '@/datasources/cache/cache.router';	100✔
16	import {	100✔
17	CacheService,
18	ICacheService,
19	} from '@/datasources/cache/cache.service.interface';
20	import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';	100✔
21	import { LimitReachedError } from '@/datasources/network/entities/errors/limit-reached.error';	100✔
22	import {	100✔
23	INetworkService,
24	NetworkService,
25	} from '@/datasources/network/network.service.interface';
26	import {
27	Balance,
28	Erc20Balance,
29	NativeBalance,
30	} from '@/domain/balances/entities/balance.entity';
31	import { Collectible } from '@/domain/collectibles/entities/collectible.entity';
32	import { getNumberString } from '@/domain/common/utils/utils';	100✔
33	import { Page } from '@/domain/entities/page.entity';
34	import { DataSourceError } from '@/domain/errors/data-source.error';	100✔
35	import { IBalancesApi } from '@/domain/interfaces/balances-api.interface';
36	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	100✔
37	import { Inject, Injectable } from '@nestjs/common';	100✔
38	import { getAddress } from 'viem';	100✔
39	import { z } from 'zod';	100✔
40
41	export const IZerionBalancesApi = Symbol('IZerionBalancesApi');	100✔
42
43	@Injectable()
44	export class ZerionBalancesApi implements IBalancesApi {	100✔
45	private static readonly COLLECTIBLES_SORTING = '-floor_price';	100✔
46	private static readonly RATE_LIMIT_CACHE_KEY_PREFIX = 'zerion';	100✔
47	private readonly apiKey: string \| undefined;
48	private readonly baseUri: string;
49	private readonly chainsConfiguration: Record<number, ChainAttributes>;
50	private readonly defaultExpirationTimeInSeconds: number;
51	private readonly defaultNotFoundExpirationTimeSeconds: number;
52	private readonly fiatCodes: string[];
53	// Number of seconds for each rate-limit cycle
54	private readonly limitPeriodSeconds: number;
55	// Number of allowed calls on each rate-limit cycle
56	private readonly limitCalls: number;
57
58	constructor(
59	@Inject(CacheService) private readonly cacheService: ICacheService,	1,364✔
60	@Inject(LoggingService) private readonly loggingService: ILoggingService,	1,364✔
61	@Inject(NetworkService) private readonly networkService: INetworkService,	1,364✔
62	@Inject(IConfigurationService)
63	private readonly configurationService: IConfigurationService,	1,364✔
64	private readonly httpErrorFactory: HttpErrorFactory,	1,364✔
65	) {
66	this.apiKey = this.configurationService.get<string>(	1,364✔
67	'balances.providers.zerion.apiKey',
68	);
69	this.baseUri = this.configurationService.getOrThrow<string>(	1,364✔
70	'balances.providers.zerion.baseUri',
71	);
72	this.defaultExpirationTimeInSeconds =	1,364✔
73	this.configurationService.getOrThrow<number>(
74	'expirationTimeInSeconds.default',
75	);
76	this.defaultNotFoundExpirationTimeSeconds =	1,364✔
77	this.configurationService.getOrThrow<number>(
78	'expirationTimeInSeconds.notFound.default',
79	);
80	this.chainsConfiguration = this.configurationService.getOrThrow<	1,364✔
81	Record<number, ChainAttributes>
82	>('balances.providers.zerion.chains');
83	this.fiatCodes = this.configurationService	1,364✔
84	.getOrThrow<string[]>('balances.providers.zerion.currencies')
85	.map((currency) => currency.toUpperCase());	10,372✔
86	this.limitPeriodSeconds = configurationService.getOrThrow(	1,364✔
87	'balances.providers.zerion.limitPeriodSeconds',
88	);
89	this.limitCalls = configurationService.getOrThrow(	1,364✔
90	'balances.providers.zerion.limitCalls',
91	);
92	}
93
94	async getBalances(args: {
95	chainId: string;
96	safeAddress: `0x${string}`;
97	fiatCode: string;
98	}): Promise<Balance[]> {
99	if (!this.fiatCodes.includes(args.fiatCode.toUpperCase())) {	24✔
100	throw new DataSourceError(	4✔
101	`Unsupported currency code: ${args.fiatCode}`,
102	400,
103	);
104	}
105
106	const cacheDir = CacheRouter.getZerionBalancesCacheDir(args);	20✔
107	const chainName = this._getChainName(args.chainId);	20✔
108	const cached = await this.cacheService.get(cacheDir);	20✔
109	if (cached != null) {	20!
110	const { key, field } = cacheDir;	×
111	this.loggingService.debug({ type: 'cache_hit', key, field });	×
112	const zerionBalances = z	×
113	.array(ZerionBalanceSchema)
114	.parse(JSON.parse(cached));
115	return this._mapBalances(chainName, zerionBalances);	×
116	}
117
118	try {	20✔
119	await this._checkRateLimit();	20✔
120	const { key, field } = cacheDir;	18✔
121	this.loggingService.debug({ type: 'cache_miss', key, field });	18✔
122	const url = `${this.baseUri}/v1/wallets/${args.safeAddress}/positions`;	18✔
123	const networkRequest = {	18✔
124	headers: { Authorization: `Basic ${this.apiKey}` },
125	params: {
126	'filter[chain_ids]': chainName,
127	currency: args.fiatCode.toLowerCase(),
128	sort: 'value',
129	},
130	};
131	const { data } = await this.networkService.get<ZerionBalances>({	18✔
132	url,
133	networkRequest,
134	});
135	const zerionBalances = ZerionBalancesSchema.parse(data);	16✔
136	await this.cacheService.set(	16✔
137	cacheDir,
138	JSON.stringify(zerionBalances.data),
139	this.defaultExpirationTimeInSeconds,
140	);
141	return this._mapBalances(chainName, data.data);	16✔
142	} catch (error) {
143	if (error instanceof LimitReachedError) {	4✔
144	throw new DataSourceError(error.message, 429);	2✔
145	}
146	throw this.httpErrorFactory.from(error);	2✔
147	}
148	}
149
150	/**
151	* NOTE: Zerion does not support limit & offset parameters.
152	* Documentation: https://developers.zerion.io/reference/listwalletnftpositions
153	*
154	* It uses a "size" query param for the page size, and an "after" parameter for the offset.
155	* "size" is an integer which could be mapped to "limit", but "after" is a base64-encoded string.
156	*
157	* Since this setup does not align well with the CGW API, it is needed to encode/decode these parameters.
158	*/
159	async getCollectibles(args: {
160	chainId: string;
161	safeAddress: `0x${string}`;
162	limit?: number;
163	offset?: number;
164	}): Promise<Page<Collectible>> {
165	const cacheDir = CacheRouter.getZerionCollectiblesCacheDir(args);	10✔
166	const cached = await this.cacheService.get(cacheDir);	10✔
167	if (cached != null) {	10!
168	const { key, field } = cacheDir;	×
169	this.loggingService.debug({ type: 'cache_hit', key, field });	×
170	const data = ZerionCollectiblesSchema.parse(JSON.parse(cached));	×
171	return this._buildCollectiblesPage(data.links.next, data.data);	×
172	} else {
173	try {	10✔
174	await this._checkRateLimit();	10✔
175	const chainName = this._getChainName(args.chainId);	10✔
176	const url = `${this.baseUri}/v1/wallets/${args.safeAddress}/nft-positions`;	10✔
177	const pageAfter = this._encodeZerionPageOffset(args.offset);	10✔
178	const networkRequest = {	10✔
179	headers: { Authorization: `Basic ${this.apiKey}` },
180	params: {
181	'filter[chain_ids]': chainName,
182	sort: ZerionBalancesApi.COLLECTIBLES_SORTING,
183	'page[size]': args.limit,
184	...(pageAfter && { 'page[after]': pageAfter }),	7✔
185	},
186	};
187	const { data } = await this.networkService.get<ZerionCollectibles>({	10✔
188	url,
189	networkRequest,
190	});
191	await this.cacheService.set(	8✔
192	cacheDir,
193	JSON.stringify(data),
194	this.defaultExpirationTimeInSeconds,
195	);
196	return this._buildCollectiblesPage(data.links.next, data.data);	8✔
197	} catch (error) {
198	throw this.httpErrorFactory.from(error);	2✔
199	}
200	}
201	}
202
203	async clearCollectibles(args: {
204	chainId: string;
205	safeAddress: `0x${string}`;
206	}): Promise<void> {
UNCOV 207	const key = CacheRouter.getZerionCollectiblesCacheKey(args);	×
UNCOV 208	await this.cacheService.deleteByKey(key);	×
209	}
210
211	private _mapBalances(
212	chainName: string,
213	zerionBalances: ZerionBalance[],
214	): Balance[] {
215	return zerionBalances	16✔
216	.filter((zb) => zb.attributes.flags.displayable)	32✔
217	.map((zb) => {
218	const implementation = zb.attributes.fungible_info.implementations.find(	30✔
219	(implementation) => implementation.chain_id === chainName,	34✔
220	);
221	if (!implementation)	30!
222	throw Error(	×
223	`Zerion error: ${chainName} implementation not found for balance ${zb.id}`,
224	);
225	const { value } = zb.attributes;	30✔
226	const fiatBalance = value ? getNumberString(value) : null;	30!
227	const fiatConversion = getNumberString(zb.attributes.price);	30✔
228
229	return {	30✔
230	...(implementation.address === null	15✔
231	? this._mapNativeBalance(zb.attributes)
232	: this._mapErc20Balance(zb.attributes, implementation.address)),
233	fiatBalance,
234	fiatConversion,
235	};
236	});
237	}
238
239	async getFiatCodes(): Promise<string[]> {
240	// Resolving to conform with interface
241	return Promise.resolve(this.fiatCodes);	6✔
242	}
243
244	private _mapErc20Balance(
245	zerionBalanceAttributes: ZerionAttributes,
246	tokenAddress: string,
247	): Erc20Balance {
248	const { fungible_info, quantity } = zerionBalanceAttributes;	14✔
249	return {	14✔
250	tokenAddress: getAddress(tokenAddress),
251	token: {
252	name: fungible_info.name ?? '',	21!
253	symbol: fungible_info.symbol ?? '',	21!
254	decimals: quantity.decimals,
255	logoUri: fungible_info.icon?.url ?? '',	41✔
256	},
257	balance: quantity.int,
258	};
259	}
260
261	private _mapNativeBalance(
262	zerionBalanceAttributes: ZerionAttributes,
263	): NativeBalance {
264	return {	16✔
265	tokenAddress: null,
266	token: null,
267	balance: zerionBalanceAttributes.quantity.int,
268	};
269	}
270
271	async clearBalances(args: {
272	chainId: string;
273	safeAddress: `0x${string}`;
274	}): Promise<void> {
UNCOV 275	const key = CacheRouter.getZerionBalancesCacheKey(args);	×
UNCOV 276	await this.cacheService.deleteByKey(key);	×
277	}
278
279	private _getChainName(chainId: string): string {
280	const chainName = this.chainsConfiguration[Number(chainId)]?.chainName;	30!
281	if (!chainName)	30!
282	throw Error(	×
283	`Chain ${chainId} balances retrieval via Zerion is not configured`,
284	);
285	return chainName;	30✔
286	}
287
288	private _buildCollectiblesPage(
289	next: string \| null,
290	data: ZerionCollectible[],
291	): Page<Collectible> {
292	// Zerion does not provide the items count.
293	// Zerion does not provide a "previous" cursor.
294	return {	8✔
295	count: null,
296	next: next ? this._decodeZerionPagination(next) : null,	4✔
297	previous: null,
298	results: this._mapCollectibles(data),
299	};
300	}
301
302	private _mapCollectibles(
303	zerionCollectibles: ZerionCollectible[],
304	): Collectible[] {
305	return zerionCollectibles.map(	8✔
306	({ attributes: { nft_info, collection_info } }) => ({	18✔
307	address: nft_info.contract_address,
308	tokenName: nft_info.name ?? '',	27!
309	tokenSymbol: nft_info.name ?? '',	27!
310	logoUri: collection_info?.content?.icon.url ?? '',	81!
311	id: nft_info.token_id,
312	uri: nft_info.content?.detail?.url ?? null,	81!
313	name: collection_info?.name ?? null,	54!
314	description: collection_info?.description ?? null,	54!
315	imageUri: nft_info.content?.preview?.url ?? '',	81!
316	metadata: nft_info.content,
317	}),
318	);
319	}
320
321	/**
322	* Zerion represents cursor offsets by base64 string
323	* contained within double quotation marks.
324	*
325	* @param offset number representing the offset
326	* @returns base64 string representing the offset
327	*/
328	private _encodeZerionPageOffset(offset?: number): string \| null {
329	return offset	10✔
330	? Buffer.from(`"${offset}"`, 'utf8').toString('base64')
331	: null;
332	}
333
334	/**
335	* Zerion uses page[size] as pagination limit.
336	* Zerion uses page[after] as pagination offset, which is a
337	* base64 string contained within double quotation marks.
338	*
339	* @param url Zerion-formatted string representing an URL
340	* @returns URL string optionally containing "limit" and "offset" query params
341	*/
342	private _decodeZerionPagination(url: string): string {
343	const zerionUrl = new URL(url);	6✔
344	const size = zerionUrl.searchParams.get('page[size]');	6✔
345	const after = zerionUrl.searchParams.get('page[after]');	6✔
346
347	if (size) zerionUrl.searchParams.set('limit', size);	6✔
348	if (after) {	6✔
349	zerionUrl.searchParams.set(	6✔
350	'offset',
351	Buffer.from(after ?? '0', 'base64')	9!
352	.toString('utf8')
353	.replace(/"/g, ''),
354	);
355	}
356	return zerionUrl.toString();	6✔
357	}
358
359	private async _checkRateLimit(): Promise<void> {
360	const current = await this.cacheService.increment(	30✔
361	CacheRouter.getRateLimitCacheKey(
362	ZerionBalancesApi.RATE_LIMIT_CACHE_KEY_PREFIX,
363	),
364	this.limitPeriodSeconds,
365	);
366	if (current > this.limitCalls) throw new LimitReachedError();	30✔
367	}
368	}

safe-global / safe-client-gateway / 9448387095

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