7017826532

Committed 28 Nov 2023 11:04AM UTC coverage: 89.754% (-1.5%) from 91.299%

Build # 7017826532

Build Type

Pull #883

github

Committed by

hectorgomezv

Commit Message

PR comments

Pull Request Pull Request #883: Add a configurable cache invalidation delay

Run Details

1419 of 1711 branches covered (0.0%)

Branch coverage included in aggregate %.

6 of 7 new or added lines in 1 file covered. (85.71%)

98 existing lines in 10 files now uncovered.

5221 of 5687 relevant lines covered (91.81%)

151.97 hits per line

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

95.88

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

import { Inject, Injectable } from '@nestjs/common';
import { IBalancesRepository } from '@/domain/balances/balances.repository.interface';
import { BalancesValidator } from '@/domain/balances/balances.validator';
import { Balance } from '@/domain/balances/entities/balance.entity';
import { ITransactionApiManager } from '@/domain/interfaces/transaction-api.manager.interface';
import { SimpleBalancesValidator } from '@/domain/balances/simple-balances.validator';
import { SimpleBalance } from '@/domain/balances/entities/simple-balance.entity';
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';

@Injectable()
export class BalancesRepository implements IBalancesRepository {
  private readonly pricesProviderChainIds: string[];

  constructor(
    @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,
    private readonly simpleBalancesValidator: SimpleBalancesValidator,
  ) {
    this.pricesProviderChainIds = this.configurationService.getOrThrow<
      string[]
    >('features.pricesProviderChainIds');
  }

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

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

  private async _buildFromSimpleBalances(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 simpleBalances = await api.getSimpleBalances({
      safeAddress,
      trusted,
      excludeSpam,
    });
    simpleBalances.map((simpleBalance) =>
      this.simpleBalancesValidator.validate(simpleBalance),
    );

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

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

    return await Promise.all(
      simpleBalances.map(async (simpleBalance) => {
        const tokenAddress = simpleBalance.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, simpleBalance);
        return {
          ...simpleBalance,
          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: SimpleBalance,
  ): number | null {
    return price !== null
      ? (price * Number(balance.balance)) /
          10 ** (balance.token?.decimals ?? 18)
      : null;
  }
}

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

safe-global / safe-client-gateway / 7017826532

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