6431246712

Committed 06 Oct 2023 11:54AM UTC coverage: 91.191% (+0.001%) from 91.19%

Build Type

github

Committed by Hector Gómez Varela

Commit Message

Add external prices provider tests

Pull Request Pull Request #732: Add external prices provider support

Run Details

1293 of 1550 branches covered (0.0%)

Branch coverage included in aggregate %.

142 of 149 new or added lines in 13 files covered. (95.3%)

14 existing lines in 2 files now uncovered.

4763 of 5091 relevant lines covered (93.56%)

150.8 hits per line

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

92.74

/src/routes/balances/balances.service.ts

import { Inject, Injectable } from '@nestjs/common';
import { Balance as TransactionApiBalance } from '../../domain/balances/entities/balance.entity';
import { Token } from './entities/token.entity';
import { TokenType } from './entities/token-type.entity';
import { Balances } from './entities/balances.entity';
import { NativeCurrency } from '@/domain/chains/entities/native.currency.entity';
import { Balance } from './entities/balance.entity';
import { IBalancesRepository } from '@/domain/balances/balances.repository.interface';
import { IExchangeRepository } from '@/domain/exchange/exchange.repository.interface';
import { IChainsRepository } from '@/domain/chains/chains.repository.interface';
import { NULL_ADDRESS } from '../common/constants';
import { IPricesRepository } from '../../domain/prices/prices.repository.interface';
import { intersection, orderBy } from 'lodash';
import { IConfigurationService } from '../../config/configuration.service.interface';
import { SimpleBalance } from '../../domain/balances/entities/simple-balance.entity';

@Injectable()
export class BalancesService {
  static readonly fromRateCurrencyCode: string = 'USD';
  private readonly activeExternalPricesChainIds: string[];

  constructor(
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(IBalancesRepository)
    private readonly balancesRepository: IBalancesRepository,
    @Inject(IChainsRepository)
    private readonly chainsRepository: IChainsRepository,
    @Inject(IExchangeRepository)
    private readonly exchangeRepository: IExchangeRepository,
    @Inject(IPricesRepository)
    private readonly pricesRepository: IPricesRepository,
  ) {
    this.activeExternalPricesChainIds = this.configurationService.getOrThrow<
      string[]
    >('features.externalPricesChainIds');
  }

  getNumberString(value: number): string {
    // Prevent scientific notation
    return value.toLocaleString('fullwide', {
      useGrouping: false,
    });
  }

  async getBalances(args: {
    chainId: string;
    safeAddress: string;
    fiatCode: string;
    trusted?: boolean;
    excludeSpam?: boolean;
  }): Promise<Balances> {
    if (this.activeExternalPricesChainIds.includes(args.chainId)) {
      return this._getFromSimpleBalances(args);
    }

    const txServiceBalances = await this.balancesRepository.getBalances(args);

    const usdToFiatRate: number = await this.exchangeRepository.convertRates({
      to: args.fiatCode,
      from: BalancesService.fromRateCurrencyCode,
    });
    const nativeCurrency: NativeCurrency = (
      await this.chainsRepository.getChain(args.chainId)
    ).nativeCurrency;

    // Map balances payload
    const balances: Balance[] = txServiceBalances.map((balance) =>
      this.mapBalance(balance, usdToFiatRate, nativeCurrency),
    );

    // Get total fiat from [balances]
    const totalFiat: number = balances.reduce((acc, b) => {
      return acc + Number(b.fiatBalance);
    }, 0);

    // Sort balances in place
    balances.sort((b1, b2) => {
      return Number(b2.fiatBalance) - Number(b1.fiatBalance);
    });

    return <Balances>{
      fiatTotal: this.getNumberString(totalFiat),
      items: balances,
    };
  }

  private mapBalance(
    txBalance: TransactionApiBalance,
    usdToFiatRate: number,
    nativeCurrency: NativeCurrency,
  ): Balance {
    const fiatConversion = Number(txBalance.fiatConversion) * usdToFiatRate;
    const fiatBalance = Number(txBalance.fiatBalance) * usdToFiatRate;
    const tokenAddress = txBalance.tokenAddress ?? NULL_ADDRESS;
    const tokenType =
      tokenAddress === NULL_ADDRESS ? TokenType.NativeToken : TokenType.Erc20;

    const tokenMetaData =
      tokenType === TokenType.NativeToken
        ? {
            decimals: nativeCurrency.decimals,
            symbol: nativeCurrency.symbol,
            name: nativeCurrency.name,
            logoUri: nativeCurrency.logoUri,
          }
        : {
            decimals: txBalance.token?.decimals,
            symbol: txBalance.token?.symbol,
            name: txBalance.token?.name,
            logoUri: txBalance.token?.logoUri,
          };

    return <Balance>{
      tokenInfo: <Token>{
        type: tokenType,
        address: tokenAddress,
        ...tokenMetaData,
      },
      balance: txBalance.balance,
      fiatBalance: this.getNumberString(fiatBalance),
      fiatConversion: this.getNumberString(fiatConversion),
    };
  }

  private async _getFromSimpleBalances(args: {
    chainId: string;
    safeAddress: string;
    fiatCode: string;
    trusted?: boolean;
    excludeSpam?: boolean;
  }): Promise<Balances> {
    const { chainId, fiatCode } = args;
    const simpleBalances =
      await this.balancesRepository.getSimpleBalances(args);
    const { nativeCurrency } = await this.chainsRepository.getChain(chainId);
    const balances: Balance[] = await Promise.all(
      simpleBalances.map(async (balance) =>
        this.mapSimpleBalance(balance, chainId, fiatCode, nativeCurrency),
      ),
    );
    const fiatTotal = balances
      .filter((b) => b.fiatBalance !== null)
      .reduce((acc, b) => acc + Number(b.fiatBalance), 0);

    return <Balances>{
      fiatTotal: this.getNumberString(fiatTotal),
      items: orderBy(balances, 'fiatBalance', 'desc'),
    };
  }

  private async mapSimpleBalance(
    txBalance: SimpleBalance,
    chainId: string,
    fiatCode: string,
    nativeCurrency: NativeCurrency,
  ): Promise<Balance> {
    const tokenAddress = txBalance.tokenAddress;
    const tokenType =
      tokenAddress === null ? TokenType.NativeToken : TokenType.Erc20;

    const tokenMetaData =
      tokenType === TokenType.NativeToken
        ? {
            decimals: nativeCurrency.decimals,
            symbol: nativeCurrency.symbol,
            name: nativeCurrency.name,
            logoUri: nativeCurrency.logoUri,
          }
        : {
            decimals: txBalance.token?.decimals,
            symbol: txBalance.token?.symbol,
            name: txBalance.token?.name,
            logoUri: txBalance.token?.logoUri,
          };

    const fiatConversion = await this.getFiatConversion(
      chainId,
      fiatCode,
      tokenAddress,
    );

    return <Balance>{
      tokenInfo: <Token>{
        type: tokenType,
        address: tokenAddress ?? NULL_ADDRESS,
        ...tokenMetaData,
      },
      balance: txBalance.balance,
      fiatBalance: this.getFiatBalance(fiatConversion, txBalance),
      fiatConversion: this.getNumberString(fiatConversion),
    };
  }

  async getFiatConversion(
    chainId: string,
    fiatCode: string,
    tokenAddress: string | null,
  ): Promise<number> {
    if (tokenAddress === null) {
      const nativeCoinId = this.configurationService.getOrThrow<string>(
        `prices.chains.${chainId}.nativeCoin`,
      );
      return this.pricesRepository.getNativeCoinPrice({
        nativeCoinId,
        fiatCode,
      });
    }
    const chainName = this.configurationService.getOrThrow<string>(
      `prices.chains.${chainId}.chainName`,
    );
    return this.pricesRepository.getTokenPrice({
      chainName,
      tokenAddress,
      fiatCode,
    });
  }

  getFiatBalance(fiatConversion: number, txBalance: SimpleBalance): string {
    const fiatBalance =
      (fiatConversion * Number(txBalance.balance)) /
      10 ** (txBalance.token?.decimals ?? 18);

    return this.getNumberString(fiatBalance);
  }

  /**
   * Gets the list of supported fiat codes.
   * USD and EUR fiat codes are fixed, and should be the first ones in the result list.
   * @returns ordered list of uppercase strings representing the supported fiat codes.
   *
   * TODO: Note: during the prices retrieval migration, this will return the
   * intersection between the exchange and the prices provider supported currencies.
   * When it is finished, just the prices provider will be taken as source.
   */
  async getSupportedFiatCodes(): Promise<string[]> {
    const [exchangeFiatCodes, pricesProviderFiatCodes] = await Promise.all([
      this.exchangeRepository.getFiatCodes(),
      this.pricesRepository.getFiatCodes(),
    ]);

    const fiatCodes = intersection(
      exchangeFiatCodes.map((item) => item.toUpperCase()),
      pricesProviderFiatCodes.map((item) => item.toUpperCase()),
    ).sort();

    return Array.from(new Set(['USD', 'EUR', ...fiatCodes]));
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	52✔
2	import { Balance as TransactionApiBalance } from '../../domain/balances/entities/balance.entity';
3	import { Token } from './entities/token.entity';
4	import { TokenType } from './entities/token-type.entity';	52✔
5	import { Balances } from './entities/balances.entity';
6	import { NativeCurrency } from '@/domain/chains/entities/native.currency.entity';
7	import { Balance } from './entities/balance.entity';
8	import { IBalancesRepository } from '@/domain/balances/balances.repository.interface';	52✔
9	import { IExchangeRepository } from '@/domain/exchange/exchange.repository.interface';	52✔
10	import { IChainsRepository } from '@/domain/chains/chains.repository.interface';	52✔
11	import { NULL_ADDRESS } from '../common/constants';	52✔
12	import { IPricesRepository } from '../../domain/prices/prices.repository.interface';	52✔
13	import { intersection, orderBy } from 'lodash';	52✔
14	import { IConfigurationService } from '../../config/configuration.service.interface';	52✔
15	import { SimpleBalance } from '../../domain/balances/entities/simple-balance.entity';
16
17	@Injectable()
18	export class BalancesService {	52✔
19	static readonly fromRateCurrencyCode: string = 'USD';	52✔
20	private readonly activeExternalPricesChainIds: string[];
21
22	constructor(
23	@Inject(IConfigurationService)
24	private readonly configurationService: IConfigurationService,	426✔
25	@Inject(IBalancesRepository)
26	private readonly balancesRepository: IBalancesRepository,	426✔
27	@Inject(IChainsRepository)
28	private readonly chainsRepository: IChainsRepository,	426✔
29	@Inject(IExchangeRepository)
30	private readonly exchangeRepository: IExchangeRepository,	426✔
31	@Inject(IPricesRepository)
32	private readonly pricesRepository: IPricesRepository,	426✔
33	) {
34	this.activeExternalPricesChainIds = this.configurationService.getOrThrow<	426✔
35	string[]
36	>('features.externalPricesChainIds');
37	}
38
39	getNumberString(value: number): string {
40	// Prevent scientific notation
41	return value.toLocaleString('fullwide', {	64✔
42	useGrouping: false,
43	});
44	}
45
46	async getBalances(args: {
47	chainId: string;
48	safeAddress: string;
49	fiatCode: string;
50	trusted?: boolean;
51	excludeSpam?: boolean;
52	}): Promise<Balances> {
53	if (this.activeExternalPricesChainIds.includes(args.chainId)) {	36✔
54	return this._getFromSimpleBalances(args);	12✔
55	}
56
57	const txServiceBalances = await this.balancesRepository.getBalances(args);	24✔
58
59	const usdToFiatRate: number = await this.exchangeRepository.convertRates({	18✔
60	to: args.fiatCode,
61	from: BalancesService.fromRateCurrencyCode,
62	});
63	const nativeCurrency: NativeCurrency = (	8✔
64	await this.chainsRepository.getChain(args.chainId)
65	).nativeCurrency;
66
67	// Map balances payload
68	const balances: Balance[] = txServiceBalances.map((balance) =>	8✔
69	this.mapBalance(balance, usdToFiatRate, nativeCurrency),	8✔
70	);
71
72	// Get total fiat from [balances]
73	const totalFiat: number = balances.reduce((acc, b) => {	8✔
74	return acc + Number(b.fiatBalance);	8✔
75	}, 0);
76
77	// Sort balances in place
78	balances.sort((b1, b2) => {	8✔
UNCOV 79	return Number(b2.fiatBalance) - Number(b1.fiatBalance);	×
80	});
81
82	return <Balances>{	8✔
83	fiatTotal: this.getNumberString(totalFiat),
84	items: balances,
85	};
86	}
87
88	private mapBalance(
89	txBalance: TransactionApiBalance,
90	usdToFiatRate: number,
91	nativeCurrency: NativeCurrency,
92	): Balance {
93	const fiatConversion = Number(txBalance.fiatConversion) * usdToFiatRate;	8✔
94	const fiatBalance = Number(txBalance.fiatBalance) * usdToFiatRate;	8✔
95	const tokenAddress = txBalance.tokenAddress ?? NULL_ADDRESS;	8✔
96	const tokenType =
97	tokenAddress === NULL_ADDRESS ? TokenType.NativeToken : TokenType.Erc20;	8✔
98
99	const tokenMetaData =
100	tokenType === TokenType.NativeToken	8✔
101	? {
102	decimals: nativeCurrency.decimals,
103	symbol: nativeCurrency.symbol,
104	name: nativeCurrency.name,
105	logoUri: nativeCurrency.logoUri,
106	}
107	: {
108	decimals: txBalance.token?.decimals,	9!
109	symbol: txBalance.token?.symbol,	9!
110	name: txBalance.token?.name,	9!
111	logoUri: txBalance.token?.logoUri,	9!
112	};
113
114	return <Balance>{	8✔
115	tokenInfo: <Token>{
116	type: tokenType,
117	address: tokenAddress,
118	...tokenMetaData,
119	},
120	balance: txBalance.balance,
121	fiatBalance: this.getNumberString(fiatBalance),
122	fiatConversion: this.getNumberString(fiatConversion),
123	};
124	}
125
126	private async _getFromSimpleBalances(args: {
127	chainId: string;
128	safeAddress: string;
129	fiatCode: string;
130	trusted?: boolean;
131	excludeSpam?: boolean;
132	}): Promise<Balances> {
133	const { chainId, fiatCode } = args;	12✔
134	const simpleBalances =
135	await this.balancesRepository.getSimpleBalances(args);	12✔
136	const { nativeCurrency } = await this.chainsRepository.getChain(chainId);	12✔
137	const balances: Balance[] = await Promise.all(	12✔
138	simpleBalances.map(async (balance) =>
139	this.mapSimpleBalance(balance, chainId, fiatCode, nativeCurrency),	14✔
140	),
141	);
142	const fiatTotal = balances	12✔
143	.filter((b) => b.fiatBalance !== null)	14✔
144	.reduce((acc, b) => acc + Number(b.fiatBalance), 0);	14✔
145
146	return <Balances>{	12✔
147	fiatTotal: this.getNumberString(fiatTotal),
148	items: orderBy(balances, 'fiatBalance', 'desc'),
149	};
150	}
151
152	private async mapSimpleBalance(
153	txBalance: SimpleBalance,
154	chainId: string,
155	fiatCode: string,
156	nativeCurrency: NativeCurrency,
157	): Promise<Balance> {
158	const tokenAddress = txBalance.tokenAddress;	14✔
159	const tokenType =
160	tokenAddress === null ? TokenType.NativeToken : TokenType.Erc20;	14✔
161
162	const tokenMetaData =
163	tokenType === TokenType.NativeToken	14✔
164	? {
165	decimals: nativeCurrency.decimals,
166	symbol: nativeCurrency.symbol,
167	name: nativeCurrency.name,
168	logoUri: nativeCurrency.logoUri,
169	}
170	: {
171	decimals: txBalance.token?.decimals,	15!
172	symbol: txBalance.token?.symbol,	15!
173	name: txBalance.token?.name,	15!
174	logoUri: txBalance.token?.logoUri,	15!
175	};
176
177	const fiatConversion = await this.getFiatConversion(	14✔
178	chainId,
179	fiatCode,
180	tokenAddress,
181	);
182
183	return <Balance>{	14✔
184	tokenInfo: <Token>{
185	type: tokenType,
186	address: tokenAddress ?? NULL_ADDRESS,	19✔
187	...tokenMetaData,
188	},
189	balance: txBalance.balance,
190	fiatBalance: this.getFiatBalance(fiatConversion, txBalance),
191	fiatConversion: this.getNumberString(fiatConversion),
192	};
193	}
194
195	async getFiatConversion(
196	chainId: string,
197	fiatCode: string,
198	tokenAddress: string \| null,
199	): Promise<number> {
200	if (tokenAddress === null) {	14✔
201	const nativeCoinId = this.configurationService.getOrThrow<string>(	4✔
202	`prices.chains.${chainId}.nativeCoin`,
203	);
204	return this.pricesRepository.getNativeCoinPrice({	4✔
205	nativeCoinId,
206	fiatCode,
207	});
208	}
209	const chainName = this.configurationService.getOrThrow<string>(	10✔
210	`prices.chains.${chainId}.chainName`,
211	);
212	return this.pricesRepository.getTokenPrice({	10✔
213	chainName,
214	tokenAddress,
215	fiatCode,
216	});
217	}
218
219	getFiatBalance(fiatConversion: number, txBalance: SimpleBalance): string {
220	const fiatBalance =
221	(fiatConversion * Number(txBalance.balance)) /	14✔
222	10 ** (txBalance.token?.decimals ?? 18);	40✔
223
224	return this.getNumberString(fiatBalance);	14✔
225	}
226
227	/**
228	* Gets the list of supported fiat codes.
229	* USD and EUR fiat codes are fixed, and should be the first ones in the result list.
230	* @returns ordered list of uppercase strings representing the supported fiat codes.
231	*
232	* TODO: Note: during the prices retrieval migration, this will return the
233	* intersection between the exchange and the prices provider supported currencies.
234	* When it is finished, just the prices provider will be taken as source.
235	*/
236	async getSupportedFiatCodes(): Promise<string[]> {
237	const [exchangeFiatCodes, pricesProviderFiatCodes] = await Promise.all([	6✔
238	this.exchangeRepository.getFiatCodes(),
239	this.pricesRepository.getFiatCodes(),
240	]);
241
242	const fiatCodes = intersection(	2✔
243	exchangeFiatCodes.map((item) => item.toUpperCase()),	10✔
244	pricesProviderFiatCodes.map((item) => item.toUpperCase()),	10✔
245	).sort();
246
247	return Array.from(new Set(['USD', 'EUR', ...fiatCodes]));	2✔
248	}
249	}

safe-global / safe-client-gateway / 6431246712

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