12163361564

Committed 04 Dec 2024 03:48PM UTC coverage: 89.439% (-0.02%) from 89.463%

Build # 12163361564

Build Type

push

github

Committed by

web-flow

Commit Message

Don't create `DataSourceError` from `ZodError`s (#2166)

Throws any `ZodError`s directly, to be caught by the `ZodErrorFilter`:

- Throw `ZodError`s directly within methods that parse against schemas.

Run Details

2771 of 3451 branches covered (80.3%)

Branch coverage included in aggregate %.

2 of 4 new or added lines in 1 file covered. (50.0%)

1 existing line in 1 file now uncovered.

9399 of 10156 relevant lines covered (92.55%)

425.86 hits per line

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

80.59

/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 { rawify, type Raw } from '@/validation/entities/raw.entity';
import { Inject, Injectable } from '@nestjs/common';
import { getAddress } from 'viem';
import { z, ZodError } 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<Raw<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.hGet(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 zerionBalances = await this.networkService
        .get<ZerionBalances>({
          url,
          networkRequest,
        })
        .then(({ data }) => ZerionBalancesSchema.parse(data));
      await this.cacheService.hSet(
        cacheDir,
        JSON.stringify(zerionBalances.data),
        this.defaultExpirationTimeInSeconds,
      );
      return this._mapBalances(chainName, zerionBalances.data);
    } catch (error) {
      if (error instanceof LimitReachedError || error instanceof ZodError) {
        throw error;
      }
      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<Raw<Page<Collectible>>> {
    const cacheDir = CacheRouter.getZerionCollectiblesCacheDir({
      ...args,
      chainId: args.chain.chainId,
    });
    const cached = await this.cacheService.hGet(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 zerionCollectibles = await this.networkService
          .get<ZerionCollectibles>({
            url,
            networkRequest,
          })
          .then(({ data }) => ZerionCollectiblesSchema.parse(data));
        await this.cacheService.hSet(
          cacheDir,
          JSON.stringify(zerionCollectibles),
          this.defaultExpirationTimeInSeconds,
        );
        return this._buildCollectiblesPage(
          zerionCollectibles.links.next,
          zerionCollectibles.data,
        );
      } catch (error) {
        if (error instanceof ZodError) {
          throw 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[],
  ): Raw<Balance[]> {
    const balances = 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,
        };
      });
    return rawify(balances);
  }

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

safe-global / safe-client-gateway / 12163361564

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