11975306312

Committed 22 Nov 2024 03:19PM UTC coverage: 89.483% (-0.02%) from 89.504%

Build # 11975306312

Build Type

push

github

Committed by

web-flow

Commit Message

Tighten eligibility vpn check (#2150)

* Tighten eligibility vpn check

* Add more unit tests for fingerprint-api service

* Test FingerprintVpnSchema, extract isVpn method

Run Details

2764 of 3437 branches covered (80.42%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 2 files covered. (100.0%)

2 existing lines in 2 files now uncovered.

9386 of 10141 relevant lines covered (92.55%)

426.38 hits per line

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

96.49

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

import { IConfigurationService } from '@/config/configuration.service.interface';
import { SafeBalancesApi } from '@/datasources/balances-api/safe-balances-api.service';
import { IZerionBalancesApi } from '@/datasources/balances-api/zerion-balances-api.service';
import { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';
import {
  CacheService,
  ICacheService,
} from '@/datasources/cache/cache.service.interface';
import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';
import { IBalancesApi } from '@/domain/interfaces/balances-api.interface';
import { IBalancesApiManager } from '@/domain/interfaces/balances-api.manager.interface';
import { IConfigApi } from '@/domain/interfaces/config-api.interface';
import { IPricesApi } from '@/datasources/balances-api/prices-api.interface';
import { Inject, Injectable } from '@nestjs/common';
import { intersection } from 'lodash';
import { ITransactionApiManager } from '@/domain/interfaces/transaction-api.manager.interface';
import { ChainSchema } from '@/domain/chains/entities/schemas/chain.schema';
import { z } from 'zod';
import { type Raw, rawify } from '@/validation/entities/raw.entity';

@Injectable()
export class BalancesApiManager implements IBalancesApiManager {
  private safeBalancesApiMap: Record<string, SafeBalancesApi> = {};
  private readonly isCounterFactualBalancesEnabled: boolean;
  private readonly zerionChainIds: string[];
  private readonly zerionBalancesApi: IBalancesApi;
  private readonly useVpcUrl: boolean;

  constructor(
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(IConfigApi) private readonly configApi: IConfigApi,
    private readonly dataSource: CacheFirstDataSource,
    @Inject(CacheService) private readonly cacheService: ICacheService,
    private readonly httpErrorFactory: HttpErrorFactory,
    @Inject(IZerionBalancesApi) zerionBalancesApi: IBalancesApi,
    @Inject(IPricesApi) private readonly coingeckoApi: IPricesApi,
    @Inject(ITransactionApiManager)
    private readonly transactionApiManager: ITransactionApiManager,
  ) {
    this.isCounterFactualBalancesEnabled =
      this.configurationService.getOrThrow<boolean>(
        'features.counterfactualBalances',
      );
    this.zerionChainIds = this.configurationService.getOrThrow<string[]>(
      'features.zerionBalancesChainIds',
    );
    this.useVpcUrl = this.configurationService.getOrThrow<boolean>(
      'safeTransaction.useVpcUrl',
    );
    this.zerionBalancesApi = zerionBalancesApi;
  }

  async getApi(
    chainId: string,
    safeAddress: `0x${string}`,
  ): Promise<IBalancesApi> {
    if (this.zerionChainIds.includes(chainId)) {
      return this.zerionBalancesApi;
    }
    const transactionApi = await this.transactionApiManager.getApi(chainId);

    if (!this.isCounterFactualBalancesEnabled) {
      return this._getSafeBalancesApi(chainId);
    }

    // SafeBalancesApi will be returned only if TransactionApi returns the Safe data.
    // Otherwise ZerionBalancesApi will be returned as the Safe is considered counterfactual/not deployed.
    const isSafe = await transactionApi.isSafe(safeAddress);
    if (isSafe) {
      return this._getSafeBalancesApi(chainId);
    } else {
      return this.zerionBalancesApi;
    }
  }

  async getFiatCodes(): Promise<Raw<string[]>> {
    const [zerionFiatCodes, safeFiatCodes] = await Promise.all([
      this.zerionBalancesApi.getFiatCodes(),
      this.coingeckoApi.getFiatCodes(),
    ]).then(z.array(z.array(z.string())).parse);
    return rawify(intersection(zerionFiatCodes, safeFiatCodes).sort());
  }

  private async _getSafeBalancesApi(chainId: string): Promise<SafeBalancesApi> {
    const safeBalancesApi = this.safeBalancesApiMap[chainId];
    if (safeBalancesApi !== undefined) return safeBalancesApi;

    const chain = await this.configApi
      .getChain(chainId)
      .then(ChainSchema.parse);
    this.safeBalancesApiMap[chainId] = new SafeBalancesApi(
      chainId,
      this.useVpcUrl ? chain.vpcTransactionService : chain.transactionService,
      this.dataSource,
      this.cacheService,
      this.configurationService,
      this.httpErrorFactory,
      this.coingeckoApi,
    );
    return this.safeBalancesApiMap[chainId];
  }

  destroyApi(chainId: string): void {
    if (this.safeBalancesApiMap[chainId] !== undefined) {
      delete this.safeBalancesApiMap[chainId];
    }
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	112✔
2	import { SafeBalancesApi } from '@/datasources/balances-api/safe-balances-api.service';	112✔
3	import { IZerionBalancesApi } from '@/datasources/balances-api/zerion-balances-api.service';	112✔
4	import { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';	112✔
5	import {	112✔
6	CacheService,
7	ICacheService,
8	} from '@/datasources/cache/cache.service.interface';
9	import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';	112✔
10	import { IBalancesApi } from '@/domain/interfaces/balances-api.interface';
11	import { IBalancesApiManager } from '@/domain/interfaces/balances-api.manager.interface';
12	import { IConfigApi } from '@/domain/interfaces/config-api.interface';	112✔
13	import { IPricesApi } from '@/datasources/balances-api/prices-api.interface';	112✔
14	import { Inject, Injectable } from '@nestjs/common';	112✔
15	import { intersection } from 'lodash';	112✔
16	import { ITransactionApiManager } from '@/domain/interfaces/transaction-api.manager.interface';	112✔
17	import { ChainSchema } from '@/domain/chains/entities/schemas/chain.schema';	112✔
18	import { z } from 'zod';	112✔
19	import { type Raw, rawify } from '@/validation/entities/raw.entity';	112✔
20
21	@Injectable()
22	export class BalancesApiManager implements IBalancesApiManager {	112✔
23	private safeBalancesApiMap: Record<string, SafeBalancesApi> = {};	1,232✔
24	private readonly isCounterFactualBalancesEnabled: boolean;
25	private readonly zerionChainIds: string[];
26	private readonly zerionBalancesApi: IBalancesApi;
27	private readonly useVpcUrl: boolean;
28
29	constructor(
30	@Inject(IConfigurationService)
31	private readonly configurationService: IConfigurationService,	1,232✔
32	@Inject(IConfigApi) private readonly configApi: IConfigApi,	1,232✔
33	private readonly dataSource: CacheFirstDataSource,	1,232✔
34	@Inject(CacheService) private readonly cacheService: ICacheService,	1,232✔
35	private readonly httpErrorFactory: HttpErrorFactory,	1,232✔
36	@Inject(IZerionBalancesApi) zerionBalancesApi: IBalancesApi,
37	@Inject(IPricesApi) private readonly coingeckoApi: IPricesApi,	1,232✔
38	@Inject(ITransactionApiManager)
39	private readonly transactionApiManager: ITransactionApiManager,	1,232✔
40	) {
41	this.isCounterFactualBalancesEnabled =	1,232✔
42	this.configurationService.getOrThrow<boolean>(
43	'features.counterfactualBalances',
44	);
45	this.zerionChainIds = this.configurationService.getOrThrow<string[]>(	1,232✔
46	'features.zerionBalancesChainIds',
47	);
48	this.useVpcUrl = this.configurationService.getOrThrow<boolean>(	1,232✔
49	'safeTransaction.useVpcUrl',
50	);
51	this.zerionBalancesApi = zerionBalancesApi;	1,232✔
52	}
53
54	async getApi(
55	chainId: string,
56	safeAddress: `0x${string}`,
57	): Promise<IBalancesApi> {
58	if (this.zerionChainIds.includes(chainId)) {	164✔
59	return this.zerionBalancesApi;	32✔
60	}
61	const transactionApi = await this.transactionApiManager.getApi(chainId);	132✔
62
63	if (!this.isCounterFactualBalancesEnabled) {	132✔
64	return this._getSafeBalancesApi(chainId);	68✔
65	}
66
67	// SafeBalancesApi will be returned only if TransactionApi returns the Safe data.
68	// Otherwise ZerionBalancesApi will be returned as the Safe is considered counterfactual/not deployed.
69	const isSafe = await transactionApi.isSafe(safeAddress);	64✔
70	if (isSafe) {	62✔
71	return this._getSafeBalancesApi(chainId);	60✔
72	} else {
73	return this.zerionBalancesApi;	2✔
74	}
75	}
76
77	async getFiatCodes(): Promise<Raw<string[]>> {
78	const [zerionFiatCodes, safeFiatCodes] = await Promise.all([	8✔
79	this.zerionBalancesApi.getFiatCodes(),
80	this.coingeckoApi.getFiatCodes(),
81	]).then(z.array(z.array(z.string())).parse);
82	return rawify(intersection(zerionFiatCodes, safeFiatCodes).sort());	8✔
83	}
84
85	private async _getSafeBalancesApi(chainId: string): Promise<SafeBalancesApi> {
86	const safeBalancesApi = this.safeBalancesApiMap[chainId];	128✔
87	if (safeBalancesApi !== undefined) return safeBalancesApi;	128✔
88
89	const chain = await this.configApi	74✔
90	.getChain(chainId)
91	.then(ChainSchema.parse);
92	this.safeBalancesApiMap[chainId] = new SafeBalancesApi(	74✔
93	chainId,
94	this.useVpcUrl ? chain.vpcTransactionService : chain.transactionService,	37✔
95	this.dataSource,
96	this.cacheService,
97	this.configurationService,
98	this.httpErrorFactory,
99	this.coingeckoApi,
100	);
101	return this.safeBalancesApiMap[chainId];	74✔
102	}
103
104	destroyApi(chainId: string): void {
105	if (this.safeBalancesApiMap[chainId] !== undefined) {	2!
UNCOV 106	delete this.safeBalancesApiMap[chainId];	×
107	}
108	}
109	}

safe-global / safe-client-gateway / 11975306312

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