7759428306

Committed 02 Feb 2024 05:29PM UTC coverage: 93.187% (-0.1%) from 93.311%

Build # 7759428306

Build Type

Pull #1096

github

Committed by

hectorgomezv

Commit Message

Split balance providers tests

Pull Request Pull Request #1096: Add Zerion Balances provider

Run Details

1506 of 1805 branches covered (0.0%)

Branch coverage included in aggregate %.

71 of 75 new or added lines in 5 files covered. (94.67%)

4 existing lines in 1 file now uncovered.

5743 of 5974 relevant lines covered (96.13%)

178.04 hits per line

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

81.69

/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 { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';
import { CacheRouter } from '@/datasources/cache/cache.router';
import {
  CacheService,
  ICacheService,
} from '@/datasources/cache/cache.service.interface';
import {
  Balance,
  Erc20Balance,
  NativeBalance,
} from '@/domain/balances/entities/balance.entity';
import { getNumberString } from '@/domain/common/utils/utils';
import { DataSourceError } from '@/domain/errors/data-source.error';
import { IBalancesApi } from '@/domain/interfaces/balances-api.interface';
import { asError } from '@/logging/utils';
import { Inject, Injectable } from '@nestjs/common';

export const IZerionBalancesApi = Symbol('IZerionBalancesApi');

@Injectable()
export class ZerionBalancesApi implements IBalancesApi {
  private readonly apiKey: string | undefined;
  private readonly baseUri: string;
  private readonly chainsConfiguration: Record<number, ChainAttributes>;
  private readonly defaultExpirationTimeInSeconds: number;
  private readonly defaultNotFoundExpirationTimeSeconds: number;

  constructor(
    @Inject(CacheService) private readonly cacheService: ICacheService,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    private readonly dataSource: CacheFirstDataSource,
  ) {
    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');
  }

  async getBalances(args: {
    chainId: string;
    safeAddress: string;
    fiatCode: string;
  }): Promise<Balance[]> {
    try {
      const cacheDir = CacheRouter.getZerionBalancesCacheDir(args);
      const chainName = this._getChainName(args.chainId);
      const currency = args.fiatCode.toLowerCase();
      const url = `${this.baseUri}/v1/wallets/${args.safeAddress}/positions`;
      const { data } = await this.dataSource.get<ZerionBalances>({
        cacheDir,
        url,
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        networkRequest: {
          headers: { Authorization: `Basic ${this.apiKey}` },
          params: {
            'filter[chain_ids]': chainName,
            currency,
            sort: 'value',
          },
        },
        expireTimeSeconds: this.defaultExpirationTimeInSeconds,
      });
      return this._mapBalances(chainName, data);
    } catch (error) {
      throw new DataSourceError(
        `Error getting ${args.safeAddress} balances from provider: ${asError(error).message}}`,
      );
    }
  }

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

  private _mapErc20Balance(
    zerionBalanceAttributes: ZerionAttributes,
    tokenAddress: string,
  ): Erc20Balance {
    const { fungible_info, quantity } = zerionBalanceAttributes;
    return {
      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: 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;
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	86✔
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 { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';	86✔
9	import { CacheRouter } from '@/datasources/cache/cache.router';	86✔
10	import {	86✔
11	CacheService,
12	ICacheService,
13	} from '@/datasources/cache/cache.service.interface';
14	import {
15	Balance,
16	Erc20Balance,
17	NativeBalance,
18	} from '@/domain/balances/entities/balance.entity';
19	import { getNumberString } from '@/domain/common/utils/utils';	86✔
20	import { DataSourceError } from '@/domain/errors/data-source.error';	86✔
21	import { IBalancesApi } from '@/domain/interfaces/balances-api.interface';
22	import { asError } from '@/logging/utils';	86✔
23	import { Inject, Injectable } from '@nestjs/common';	86✔
24
25	export const IZerionBalancesApi = Symbol('IZerionBalancesApi');	86✔
26
27	@Injectable()
28	export class ZerionBalancesApi implements IBalancesApi {	86✔
29	private readonly apiKey: string \| undefined;
30	private readonly baseUri: string;
31	private readonly chainsConfiguration: Record<number, ChainAttributes>;
32	private readonly defaultExpirationTimeInSeconds: number;
33	private readonly defaultNotFoundExpirationTimeSeconds: number;
34
35	constructor(
36	@Inject(CacheService) private readonly cacheService: ICacheService,	614✔
37	@Inject(IConfigurationService)
38	private readonly configurationService: IConfigurationService,	614✔
39	private readonly dataSource: CacheFirstDataSource,	614✔
40	) {
41	this.apiKey = this.configurationService.get<string>(	614✔
42	'balances.providers.zerion.apiKey',
43	);
44	this.baseUri = this.configurationService.getOrThrow<string>(	614✔
45	'balances.providers.zerion.baseUri',
46	);
47	this.defaultExpirationTimeInSeconds =	614✔
48	this.configurationService.getOrThrow<number>(
49	'expirationTimeInSeconds.default',
50	);
51	this.defaultNotFoundExpirationTimeSeconds =	614✔
52	this.configurationService.getOrThrow<number>(
53	'expirationTimeInSeconds.notFound.default',
54	);
55	this.chainsConfiguration = this.configurationService.getOrThrow<	614✔
56	Record<number, ChainAttributes>
57	>('balances.providers.zerion.chains');
58	}
59
60	async getBalances(args: {
61	chainId: string;
62	safeAddress: string;
63	fiatCode: string;
64	}): Promise<Balance[]> {
65	try {	8✔
66	const cacheDir = CacheRouter.getZerionBalancesCacheDir(args);	8✔
67	const chainName = this._getChainName(args.chainId);	8✔
68	const currency = args.fiatCode.toLowerCase();	8✔
69	const url = `${this.baseUri}/v1/wallets/${args.safeAddress}/positions`;	8✔
70	const { data } = await this.dataSource.get<ZerionBalances>({	8✔
71	cacheDir,
72	url,
73	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
74	networkRequest: {
75	headers: { Authorization: `Basic ${this.apiKey}` },
76	params: {
77	'filter[chain_ids]': chainName,
78	currency,
79	sort: 'value',
80	},
81	},
82	expireTimeSeconds: this.defaultExpirationTimeInSeconds,
83	});
84	return this._mapBalances(chainName, data);	6✔
85	} catch (error) {
86	throw new DataSourceError(	2✔
87	`Error getting ${args.safeAddress} balances from provider: ${asError(error).message}}`,
88	);
89	}
90	}
91
92	private _mapBalances(
93	chainName: string,
94	zerionBalances: ZerionBalance[],
95	): Balance[] {
96	return zerionBalances	6✔
97	.filter((zb) => zb.attributes.flags.displayable)	8✔
98	.map((zb) => {
99	const implementation = zb.attributes.fungible_info.implementations.find(	8✔
100	(implementation) => implementation.chain_id === chainName,	12✔
101	);
102	if (!implementation)	8!
NEW 103	throw Error(	×
104	`Zerion error: ${chainName} implementation not found for balance ${zb.id}`,
105	);
106	const { value } = zb.attributes;	8✔
107	const fiatBalance = value ? getNumberString(value) : null;	8!
108	const fiatConversion = getNumberString(zb.attributes.price);	8✔
109
110	return {	8✔
111	...(implementation.address === null	4✔
112	? this._mapNativeBalance(zb.attributes)
113	: this._mapErc20Balance(zb.attributes, implementation.address)),
114	fiatBalance,
115	fiatConversion,
116	};
117	});
118	}
119
120	private _mapErc20Balance(
121	zerionBalanceAttributes: ZerionAttributes,
122	tokenAddress: string,
123	): Erc20Balance {
124	const { fungible_info, quantity } = zerionBalanceAttributes;	4✔
125	return {	4✔
126	tokenAddress,
127	token: {
128	name: fungible_info.name ?? '',	6!
129	symbol: fungible_info.symbol ?? '',	6!
130	decimals: quantity.decimals,
131	logoUri: fungible_info.icon.url ?? '',	6!
132	},
133	balance: quantity.int,
134	};
135	}
136
137	private _mapNativeBalance(
138	zerionBalanceAttributes: ZerionAttributes,
139	): NativeBalance {
140	return {	4✔
141	tokenAddress: null,
142	token: null,
143	balance: zerionBalanceAttributes.quantity.int,
144	};
145	}
146
147	async clearBalances(args: {
148	chainId: string;
149	safeAddress: string;
150	}): Promise<void> {
NEW 151	const key = CacheRouter.getZerionBalancesCacheKey(args);	×
NEW 152	await this.cacheService.deleteByKey(key);	×
153	}
154
155	private _getChainName(chainId: string): string {
156	const chainName = this.chainsConfiguration[Number(chainId)]?.chainName;	8!
157	if (!chainName)	8!
NEW 158	throw Error(	×
159	`Chain ${chainId} balances retrieval via Zerion is not configured`,
160	);
161	return chainName;	8✔
162	}
163	}

safe-global / safe-client-gateway / 7759428306

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