7695925571

Committed 29 Jan 2024 12:20PM UTC coverage: 93.331% (-0.03%) from 93.36%

Build # 7695925571

Build Type

Pull #1062

github

Committed by

web-flow

Commit Message

Update src/datasources/balances-api/balances-api.manager.ts

Thanks! I was trying to be explicit about the intention of filling this `allProviderChainIds` array with more providers, but I agree it doesn't make much sense it this point.

Co-authored-by: Aaron Cook <aaron@safe.global>

Pull Request Pull Request #1062: Add Valk Balances provider

Run Details

1513 of 1801 branches covered (0.0%)

Branch coverage included in aggregate %.

75 of 80 new or added lines in 8 files covered. (93.75%)

4 existing lines in 1 file now uncovered.

5652 of 5876 relevant lines covered (96.19%)

171.95 hits per line

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

94.95

/src/domain/balances/balances.repository.ts

import { Inject, Injectable } from '@nestjs/common';
import { IBalancesRepository } from '@/domain/balances/balances.repository.interface';
import { Balance } from '@/domain/balances/entities/balance.entity';
import { ITransactionApiManager } from '@/domain/interfaces/transaction-api.manager.interface';
import { BalancesValidator } from '@/domain/balances/balances.validator';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { IPricesRepository } from '@/domain/prices/prices.repository.interface';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { getNumberString } from '@/domain/common/utils/utils';
import { AssetPrice } from '@/domain/prices/entities/asset-price.entity';
import { IBalancesApiManager } from '@/domain/interfaces/balances-api.manager.interface';

@Injectable()
export class BalancesRepository implements IBalancesRepository {
  constructor(
    @Inject(IBalancesApiManager)
    private readonly balancesApiManager: IBalancesApiManager,
    @Inject(ITransactionApiManager)
    private readonly transactionApiManager: ITransactionApiManager,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(IPricesRepository)
    private readonly pricesRepository: IPricesRepository,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    private readonly balancesValidator: BalancesValidator,
  ) {}

  async getBalances(args: {
    chainId: string;
    safeAddress: string;
    fiatCode: string;
    trusted?: boolean;
    excludeSpam?: boolean;
  }): Promise<Balance[]> {
    return this.balancesApiManager.isExternalized(args.chainId)
      ? this._getBalancesFromBalancesApi(args)
      : this._getBalancesFromTransactionApi(args);
  }

  async clearLocalBalances(args: {
    chainId: string;
    safeAddress: string;
  }): Promise<void> {
    if (this.balancesApiManager.isExternalized(args.chainId)) {
      const api = this.balancesApiManager.getBalancesApi(args.chainId);
      await api.clearBalances(args);
    } else {
      const api = await this.transactionApiManager.getTransactionApi(
        args.chainId,
      );
      await api.clearLocalBalances(args.safeAddress);
    }
  }

  private async _getBalancesFromBalancesApi(args: {
    chainId: string;
    safeAddress: string;
    fiatCode: string;
    trusted?: boolean;
    excludeSpam?: boolean;
  }): Promise<Balance[]> {
    const api = this.balancesApiManager.getBalancesApi(args.chainId);
    const balances = await api.getBalances(args);
    return balances.map((balance) => this.balancesValidator.validate(balance));
  }

  private async _getBalancesFromTransactionApi(args: {
    chainId: string;
    safeAddress: string;
    fiatCode: string;
    trusted?: boolean;
    excludeSpam?: boolean;
  }): Promise<Balance[]> {
    const { chainId, safeAddress, fiatCode, trusted, excludeSpam } = args;
    const api = await this.transactionApiManager.getTransactionApi(chainId);
    const balances = await api.getBalances({
      safeAddress,
      trusted,
      excludeSpam,
    });
    balances.map((balance) => this.balancesValidator.validate(balance));

    const tokenAddresses = balances
      .map((balance) => balance.tokenAddress)
      .filter((address): address is string => address !== null);

    const prices = tokenAddresses.length
      ? await this._getTokenPrices(chainId, fiatCode, tokenAddresses)
      : [];

    return await Promise.all(
      balances.map(async (balance) => {
        const tokenAddress = balance.tokenAddress?.toLowerCase() ?? null;
        let price: number | null;
        if (tokenAddress === null) {
          price = await this._getNativeCoinPrice(chainId, fiatCode);
        } else {
          const found = prices.find((assetPrice) => assetPrice[tokenAddress]);
          price = found?.[tokenAddress]?.[fiatCode.toLowerCase()] ?? null;
        }
        const fiatBalance = await this._getFiatBalance(price, balance);
        return {
          ...balance,
          fiatBalance: fiatBalance ? getNumberString(fiatBalance) : null,
          fiatConversion: price ? getNumberString(price) : null,
        };
      }),
    );
  }

  private async _getNativeCoinPrice(
    chainId: string,
    fiatCode: string,
  ): Promise<number | null> {
    const nativeCoinId = this.configurationService.getOrThrow<string>(
      `prices.chains.${chainId}.nativeCoin`,
    );
    try {
      return await this.pricesRepository.getNativeCoinPrice({
        nativeCoinId,
        fiatCode,
      });
    } catch (err) {
      this.loggingService.warn({
        type: 'invalid_native_coin_price',
        native_coin_id: nativeCoinId,
        fiat_code: fiatCode,
      });
      return null;
    }
  }

  private async _getTokenPrices(
    chainId: string,
    fiatCode: string,
    tokenAddresses: string[],
  ): Promise<AssetPrice[]> {
    const chainName = this.configurationService.getOrThrow<string>(
      `prices.chains.${chainId}.chainName`,
    );
    try {
      return await this.pricesRepository.getTokenPrices({
        chainName,
        tokenAddresses,
        fiatCode,
      });
    } catch (err) {
      this.loggingService.warn({
        type: 'invalid_token_price',
        token_address: tokenAddresses,
        fiat_code: fiatCode,
      });
      return [];
    }
  }

  private _getFiatBalance(
    price: number | null,
    balance: Balance,
  ): number | null {
    return price !== null
      ? (price * Number(balance.balance)) /
          10 ** (balance.token?.decimals ?? 18)
      : null;
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	80✔
2	import { IBalancesRepository } from '@/domain/balances/balances.repository.interface';
3	import { Balance } from '@/domain/balances/entities/balance.entity';
4	import { ITransactionApiManager } from '@/domain/interfaces/transaction-api.manager.interface';	80✔
5	import { BalancesValidator } from '@/domain/balances/balances.validator';	80✔
6	import { IConfigurationService } from '@/config/configuration.service.interface';	80✔
7	import { IPricesRepository } from '@/domain/prices/prices.repository.interface';	80✔
8	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	80✔
9	import { getNumberString } from '@/domain/common/utils/utils';	80✔
10	import { AssetPrice } from '@/domain/prices/entities/asset-price.entity';
11	import { IBalancesApiManager } from '@/domain/interfaces/balances-api.manager.interface';	80✔
12
13	@Injectable()
14	export class BalancesRepository implements IBalancesRepository {	80✔
15	constructor(
16	@Inject(IBalancesApiManager)
17	private readonly balancesApiManager: IBalancesApiManager,	590✔
18	@Inject(ITransactionApiManager)
19	private readonly transactionApiManager: ITransactionApiManager,	590✔
20	@Inject(IConfigurationService)
21	private readonly configurationService: IConfigurationService,	590✔
22	@Inject(IPricesRepository)
23	private readonly pricesRepository: IPricesRepository,	590✔
24	@Inject(LoggingService) private readonly loggingService: ILoggingService,	590✔
25	private readonly balancesValidator: BalancesValidator,	590✔
26	) {}
27
28	async getBalances(args: {
29	chainId: string;
30	safeAddress: string;
31	fiatCode: string;
32	trusted?: boolean;
33	excludeSpam?: boolean;
34	}): Promise<Balance[]> {
35	return this.balancesApiManager.isExternalized(args.chainId)	26✔
36	? this._getBalancesFromBalancesApi(args)
37	: this._getBalancesFromTransactionApi(args);
38	}
39
40	async clearLocalBalances(args: {
41	chainId: string;
42	safeAddress: string;
43	}): Promise<void> {
44	if (this.balancesApiManager.isExternalized(args.chainId)) {	36!
NEW 45	const api = this.balancesApiManager.getBalancesApi(args.chainId);	×
NEW 46	await api.clearBalances(args);	×
47	} else {
48	const api = await this.transactionApiManager.getTransactionApi(	36✔
49	args.chainId,
50	);
51	await api.clearLocalBalances(args.safeAddress);	36✔
52	}
53	}
54
55	private async _getBalancesFromBalancesApi(args: {
56	chainId: string;
57	safeAddress: string;
58	fiatCode: string;
59	trusted?: boolean;
60	excludeSpam?: boolean;
61	}): Promise<Balance[]> {
62	const api = this.balancesApiManager.getBalancesApi(args.chainId);	8✔
63	const balances = await api.getBalances(args);	8✔
64	return balances.map((balance) => this.balancesValidator.validate(balance));	8✔
65	}
66
67	private async _getBalancesFromTransactionApi(args: {
68	chainId: string;
69	safeAddress: string;
70	fiatCode: string;
71	trusted?: boolean;
72	excludeSpam?: boolean;
73	}): Promise<Balance[]> {
74	const { chainId, safeAddress, fiatCode, trusted, excludeSpam } = args;	18✔
75	const api = await this.transactionApiManager.getTransactionApi(chainId);	18✔
76	const balances = await api.getBalances({	16✔
77	safeAddress,
78	trusted,
79	excludeSpam,
80	});
81	balances.map((balance) => this.balancesValidator.validate(balance));	18✔
82
83	const tokenAddresses = balances	12✔
84	.map((balance) => balance.tokenAddress)	16✔
85	.filter((address): address is string => address !== null);	16✔
86
87	const prices = tokenAddresses.length	12✔
88	? await this._getTokenPrices(chainId, fiatCode, tokenAddresses)
89	: [];
90
91	return await Promise.all(	12✔
92	balances.map(async (balance) => {
93	const tokenAddress = balance.tokenAddress?.toLowerCase() ?? null;	16✔
94	let price: number \| null;
95	if (tokenAddress === null) {	16✔
96	price = await this._getNativeCoinPrice(chainId, fiatCode);	4✔
97	} else {
98	const found = prices.find((assetPrice) => assetPrice[tokenAddress]);	12✔
99	price = found?.[tokenAddress]?.[fiatCode.toLowerCase()] ?? null;	12✔
100	}
101	const fiatBalance = await this._getFiatBalance(price, balance);	16✔
102	return {	16✔
103	...balance,
104	fiatBalance: fiatBalance ? getNumberString(fiatBalance) : null,	8✔
105	fiatConversion: price ? getNumberString(price) : null,	8✔
106	};
107	}),
108	);
109	}
110
111	private async _getNativeCoinPrice(
112	chainId: string,
113	fiatCode: string,
114	): Promise<number \| null> {
115	const nativeCoinId = this.configurationService.getOrThrow<string>(	4✔
116	`prices.chains.${chainId}.nativeCoin`,
117	);
118	try {	4✔
119	return await this.pricesRepository.getNativeCoinPrice({	4✔
120	nativeCoinId,
121	fiatCode,
122	});
123	} catch (err) {
124	this.loggingService.warn({	×
125	type: 'invalid_native_coin_price',
126	native_coin_id: nativeCoinId,
127	fiat_code: fiatCode,
128	});
129	return null;	×
130	}
131	}
132
133	private async _getTokenPrices(
134	chainId: string,
135	fiatCode: string,
136	tokenAddresses: string[],
137	): Promise<AssetPrice[]> {
138	const chainName = this.configurationService.getOrThrow<string>(	10✔
139	`prices.chains.${chainId}.chainName`,
140	);
141	try {	10✔
142	return await this.pricesRepository.getTokenPrices({	10✔
143	chainName,
144	tokenAddresses,
145	fiatCode,
146	});
147	} catch (err) {
148	this.loggingService.warn({	2✔
149	type: 'invalid_token_price',
150	token_address: tokenAddresses,
151	fiat_code: fiatCode,
152	});
153	return [];	2✔
154	}
155	}
156
157	private _getFiatBalance(
158	price: number \| null,
159	balance: Balance,
160	): number \| null {
161	return price !== null	16✔
162	? (price * Number(balance.balance)) /
163	10 ** (balance.token?.decimals ?? 18)	34✔
164	: null;
165	}
166	}

safe-global / safe-client-gateway / 7695925571

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