11740021123

Committed 08 Nov 2024 10:02AM UTC coverage: 89.237% (+0.002%) from 89.235%

Build # 11740021123

Build Type

push

github

Committed by

web-flow

Commit Message

Type `IStakingApi` responses as "raw" (#2099)

Types all the IStakingApi responses as "raw". These responses can therefore not be used directly unless they are validated:

- Add Raw utility type to IStakingApi
- Update validation where appropriate

Run Details

2642 of 3308 branches covered (79.87%)

Branch coverage included in aggregate %.

6 of 7 new or added lines in 5 files covered. (85.71%)

2 existing lines in 2 files now uncovered.

8957 of 9690 relevant lines covered (92.44%)

414.33 hits per line

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

96.3

/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';

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

safe-global / safe-client-gateway / 11740021123

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