9368823744

Committed 04 Jun 2024 10:11AM UTC coverage: 92.771% (-0.09%) from 92.859%

Build # 9368823744

Build Type

push

github

Committed by

web-flow

Commit Message

Fix @typescript-eslint/no-unsafe-argument instances (#1533)

Enable @typescript-eslint/no-unsafe-argument

Run Details

2004 of 2456 branches covered (81.6%)

Branch coverage included in aggregate %.

16 of 19 new or added lines in 9 files covered. (84.21%)

3 existing lines in 3 files now uncovered.

7121 of 7380 relevant lines covered (96.49%)

328.29 hits per line

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

81.22

/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,
  ZerionBalances,
} from '@/datasources/balances-api/entities/zerion-balance.entity';
import {
  ZerionCollectible,
  ZerionCollectibles,
} 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';

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

safe-global / safe-client-gateway / 9368823744

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