9398906867

Committed 06 Jun 2024 10:01AM UTC coverage: 92.915% (+0.1%) from 92.819%

Build # 9398906867

Build Type

push

github

Committed by

web-flow

Commit Message

Add schemas for Zerion entities (#1611)

This adds the relative validation schemas for the balances/collectibles from Zeriod and parses against them to ensure validity:

- Create `ZerionCollectiblesSchema` (and sub-schemas)
- Create `ZerionBalancesSchema` (and sub-schemas)
- Validate relevant data against the above in `ZerionBalancesApi`
- Update tests accordingly

Run Details

2011 of 2457 branches covered (81.85%)

Branch coverage included in aggregate %.

18 of 20 new or added lines in 4 files covered. (90.0%)

1 existing line in 1 file now uncovered.

7156 of 7409 relevant lines covered (96.59%)

328.31 hits per line

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

85.25

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

safe-global / safe-client-gateway / 9398906867

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