9779825056

Committed 03 Jul 2024 02:32PM UTC coverage: 48.46% (-0.08%) from 48.543%

Build # 9779825056

Build Type

push

github

Committed by

web-flow

Commit Message

Add Swaps decoding debug logs (#1718)

Adds transient debug logging for Swaps decoding.

Run Details

414 of 2539 branches covered (16.31%)

Branch coverage included in aggregate %.

0 of 9 new or added lines in 2 files covered. (0.0%)

6 existing lines in 4 files now uncovered.

4213 of 7009 relevant lines covered (60.11%)

13.11 hits per line

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

72.22

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

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