9498277027

Committed 13 Jun 2024 10:46AM UTC coverage: 92.69% (-0.007%) from 92.697%

Build # 9498277027

Build Type

Pull #1648

github

Committed by

hectorgomezv

Commit Message

Rename counterfactualBalancesProvider to balancesProvider

Pull Request Pull Request #1648: Extract Zerion configuration from Chain entity

Run Details

2025 of 2487 branches covered (81.42%)

Branch coverage included in aggregate %.

23 of 23 new or added lines in 8 files covered. (100.0%)

2 existing lines in 2 files now uncovered.

7232 of 7500 relevant lines covered (96.43%)

329.26 hits per line

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

81.17

/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 { Chain } from '@/domain/chains/entities/chain.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: {
    chain: Chain;
    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({
      chainId: args.chain.chainId,
      safeAddress: args.safeAddress,
      fiatCode: args.fiatCode,
    });
    const chainName = this._getChainName(args.chain);
    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: {
    chain: Chain;
    safeAddress: `0x${string}`;
    limit?: number;
    offset?: number;
  }): Promise<Page<Collectible>> {
    const cacheDir = CacheRouter.getZerionCollectiblesCacheDir({
      ...args,
      chainId: args.chain.chainId,
    });
    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.chain);
        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, price } = zb.attributes;
        const fiatBalance = value ? getNumberString(value) : null;
        const fiatConversion = price ? getNumberString(price) : null;

        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);
  }

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

safe-global / safe-client-gateway / 9498277027

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