11742544373

Committed 08 Nov 2024 12:57PM UTC coverage: 89.215% (-0.03%) from 89.246%

Build # 11742544373

Build Type

Pull #2111

github

Committed by

iamacook

Commit Message

Return `502` for gateway validation errors

Pull Request Pull Request #2111: Return `502` for gateway validation errors

Run Details

2644 of 3315 branches covered (79.76%)

Branch coverage included in aggregate %.

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

4 existing lines in 1 file now uncovered.

8970 of 9703 relevant lines covered (92.45%)

428.79 hits per line

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

94.17

/src/datasources/balances-api/safe-balances-api.service.ts

import { IConfigurationService } from '@/config/configuration.service.interface';
import { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';
import { CacheRouter } from '@/datasources/cache/cache.router';
import { ICacheService } from '@/datasources/cache/cache.service.interface';
import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';
import { Balance } from '@/domain/balances/entities/balance.entity';
import { Collectible } from '@/domain/collectibles/entities/collectible.entity';
import { getNumberString } from '@/domain/common/utils/utils';
import { Page } from '@/domain/entities/page.entity';
import { IBalancesApi } from '@/domain/interfaces/balances-api.interface';
import { IPricesApi } from '@/datasources/balances-api/prices-api.interface';
import { Injectable } from '@nestjs/common';
import { Chain } from '@/domain/chains/entities/chain.entity';

@Injectable()
export class SafeBalancesApi implements IBalancesApi {
  private readonly defaultExpirationTimeInSeconds: number;
  private readonly defaultNotFoundExpirationTimeSeconds: number;
  private static readonly DEFAULT_DECIMALS = 18;
  private static readonly HOLESKY_CHAIN_ID = '17000';

  constructor(
    private readonly chainId: string,
    private readonly baseUrl: string,
    private readonly dataSource: CacheFirstDataSource,
    private readonly cacheService: ICacheService,
    private readonly configurationService: IConfigurationService,
    private readonly httpErrorFactory: HttpErrorFactory,
    private readonly coingeckoApi: IPricesApi,
  ) {
    // TODO: Remove temporary cache times for Holesky chain.
    if (chainId === SafeBalancesApi.HOLESKY_CHAIN_ID) {
      const holeskyExpirationTime =
        this.configurationService.getOrThrow<number>(
          'expirationTimeInSeconds.holesky',
        );
      this.defaultExpirationTimeInSeconds = holeskyExpirationTime;
      this.defaultNotFoundExpirationTimeSeconds = holeskyExpirationTime;
    } else {
      this.defaultExpirationTimeInSeconds =
        this.configurationService.getOrThrow<number>(
          'expirationTimeInSeconds.default',
        );
      this.defaultNotFoundExpirationTimeSeconds =
        this.configurationService.getOrThrow<number>(
          'expirationTimeInSeconds.notFound.default',
        );
    }
  }

  async getBalances(args: {
    safeAddress: `0x${string}`;
    fiatCode: string;
    chain: Chain;
    trusted?: boolean;
    excludeSpam?: boolean;
  }): Promise<Balance[]> {
    try {
      const cacheDir = CacheRouter.getBalancesCacheDir({
        chainId: this.chainId,
        ...args,
      });
      const url = `${this.baseUrl}/api/v1/safes/${args.safeAddress}/balances/`;
      const data = await this.dataSource.get<Balance[]>({
        cacheDir,
        url,
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        networkRequest: {
          params: {
            trusted: args.trusted,
            exclude_spam: args.excludeSpam,
          },
        },
        expireTimeSeconds: this.defaultExpirationTimeInSeconds,
      });

      return this._mapBalances(data, args.fiatCode, args.chain);
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async clearBalances(args: { safeAddress: `0x${string}` }): Promise<void> {
    const key = CacheRouter.getBalancesCacheKey({
      chainId: this.chainId,
      safeAddress: args.safeAddress,
    });
    await this.cacheService.deleteByKey(key);
  }

  async getCollectibles(args: {
    safeAddress: `0x${string}`;
    limit?: number;
    offset?: number;
    trusted?: boolean;
    excludeSpam?: boolean;
  }): Promise<Page<Collectible>> {
    try {
      const cacheDir = CacheRouter.getCollectiblesCacheDir({
        chainId: this.chainId,
        ...args,
      });
      const url = `${this.baseUrl}/api/v2/safes/${args.safeAddress}/collectibles/`;
      return await this.dataSource.get({
        cacheDir,
        url,
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        networkRequest: {
          params: {
            limit: args.limit,
            offset: args.offset,
            trusted: args.trusted,
            exclude_spam: args.excludeSpam,
          },
        },
        expireTimeSeconds: this.defaultExpirationTimeInSeconds,
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async clearCollectibles(args: { safeAddress: `0x${string}` }): Promise<void> {
    const key = CacheRouter.getCollectiblesKey({
      chainId: this.chainId,
      safeAddress: args.safeAddress,
    });
    await this.cacheService.deleteByKey(key);
  }

  async getFiatCodes(): Promise<string[]> {
    return this.coingeckoApi.getFiatCodes();
  }

  /**
   * Gets the USD price of the native coin of the chain associated with {@link chainId}.
   */
  async getNativeCoinPrice(chain: Chain): Promise<number | null> {
    return this.coingeckoApi.getNativeCoinPrice({
      chain,
      fiatCode: 'USD',
    });
  }

  private async _mapBalances(
    balances: Balance[],
    fiatCode: string,
    chain: Chain,
  ): Promise<Balance[]> {
    const tokenAddresses = balances
      .map((balance) => balance.tokenAddress)
      .filter((address): address is `0x${string}` => address !== null);

    const assetPrices = await this.coingeckoApi.getTokenPrices({
      chain,
      fiatCode,
      tokenAddresses,
    });

    const lowerCaseAssetPrices = assetPrices?.map((assetPrice) =>
      Object.fromEntries(
        Object.entries(assetPrice).map(([k, v]) => [k.toLowerCase(), v]),
      ),
    );

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

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

1	import { IConfigurationService } from '@/config/configuration.service.interface';	108✔
2	import { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';	108✔
3	import { CacheRouter } from '@/datasources/cache/cache.router';	108✔
4	import { ICacheService } from '@/datasources/cache/cache.service.interface';
5	import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';	108✔
6	import { Balance } from '@/domain/balances/entities/balance.entity';
7	import { Collectible } from '@/domain/collectibles/entities/collectible.entity';
8	import { getNumberString } from '@/domain/common/utils/utils';	108✔
9	import { Page } from '@/domain/entities/page.entity';
10	import { IBalancesApi } from '@/domain/interfaces/balances-api.interface';
11	import { IPricesApi } from '@/datasources/balances-api/prices-api.interface';	108✔
12	import { Injectable } from '@nestjs/common';	108✔
13	import { Chain } from '@/domain/chains/entities/chain.entity';
14
15	@Injectable()
16	export class SafeBalancesApi implements IBalancesApi {	108✔
17	private readonly defaultExpirationTimeInSeconds: number;
18	private readonly defaultNotFoundExpirationTimeSeconds: number;
19	private static readonly DEFAULT_DECIMALS = 18;	108✔
20	private static readonly HOLESKY_CHAIN_ID = '17000';	108✔
21
22	constructor(
23	private readonly chainId: string,	74✔
24	private readonly baseUrl: string,	74✔
25	private readonly dataSource: CacheFirstDataSource,	74✔
26	private readonly cacheService: ICacheService,	74✔
27	private readonly configurationService: IConfigurationService,	74✔
28	private readonly httpErrorFactory: HttpErrorFactory,	74✔
29	private readonly coingeckoApi: IPricesApi,	74✔
30	) {
31	// TODO: Remove temporary cache times for Holesky chain.
32	if (chainId === SafeBalancesApi.HOLESKY_CHAIN_ID) {	74!
33	const holeskyExpirationTime =
UNCOV 34	this.configurationService.getOrThrow<number>(	×
35	'expirationTimeInSeconds.holesky',
36	);
UNCOV 37	this.defaultExpirationTimeInSeconds = holeskyExpirationTime;	×
38	this.defaultNotFoundExpirationTimeSeconds = holeskyExpirationTime;	×
39	} else {
40	this.defaultExpirationTimeInSeconds =	74✔
41	this.configurationService.getOrThrow<number>(
42	'expirationTimeInSeconds.default',
43	);
44	this.defaultNotFoundExpirationTimeSeconds =	74✔
45	this.configurationService.getOrThrow<number>(
46	'expirationTimeInSeconds.notFound.default',
47	);
48	}
49	}
50
51	async getBalances(args: {
52	safeAddress: `0x${string}`;
53	fiatCode: string;
54	chain: Chain;
55	trusted?: boolean;
56	excludeSpam?: boolean;
57	}): Promise<Balance[]> {
58	try {	60✔
59	const cacheDir = CacheRouter.getBalancesCacheDir({	60✔
60	chainId: this.chainId,
61	...args,
62	});
63	const url = `${this.baseUrl}/api/v1/safes/${args.safeAddress}/balances/`;	60✔
64	const data = await this.dataSource.get<Balance[]>({	60✔
65	cacheDir,
66	url,
67	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
68	networkRequest: {
69	params: {
70	trusted: args.trusted,
71	exclude_spam: args.excludeSpam,
72	},
73	},
74	expireTimeSeconds: this.defaultExpirationTimeInSeconds,
75	});
76
77	return this._mapBalances(data, args.fiatCode, args.chain);	58✔
78	} catch (error) {
79	throw this.httpErrorFactory.from(error);	2✔
80	}
81	}
82
83	async clearBalances(args: { safeAddress: `0x${string}` }): Promise<void> {
84	const key = CacheRouter.getBalancesCacheKey({	28✔
85	chainId: this.chainId,
86	safeAddress: args.safeAddress,
87	});
88	await this.cacheService.deleteByKey(key);	28✔
89	}
90
91	async getCollectibles(args: {
92	safeAddress: `0x${string}`;
93	limit?: number;
94	offset?: number;
95	trusted?: boolean;
96	excludeSpam?: boolean;
97	}): Promise<Page<Collectible>> {
98	try {	10✔
99	const cacheDir = CacheRouter.getCollectiblesCacheDir({	10✔
100	chainId: this.chainId,
101	...args,
102	});
103	const url = `${this.baseUrl}/api/v2/safes/${args.safeAddress}/collectibles/`;	10✔
104	return await this.dataSource.get({	10✔
105	cacheDir,
106	url,
107	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
108	networkRequest: {
109	params: {
110	limit: args.limit,
111	offset: args.offset,
112	trusted: args.trusted,
113	exclude_spam: args.excludeSpam,
114	},
115	},
116	expireTimeSeconds: this.defaultExpirationTimeInSeconds,
117	});
118	} catch (error) {
119	throw this.httpErrorFactory.from(error);	4✔
120	}
121	}
122
123	async clearCollectibles(args: { safeAddress: `0x${string}` }): Promise<void> {
124	const key = CacheRouter.getCollectiblesKey({	30✔
125	chainId: this.chainId,
126	safeAddress: args.safeAddress,
127	});
128	await this.cacheService.deleteByKey(key);	30✔
129	}
130
131	async getFiatCodes(): Promise<string[]> {
UNCOV 132	return this.coingeckoApi.getFiatCodes();	×
133	}
134
135	/**
136	* Gets the USD price of the native coin of the chain associated with {@link chainId}.
137	*/
138	async getNativeCoinPrice(chain: Chain): Promise<number \| null> {
UNCOV 139	return this.coingeckoApi.getNativeCoinPrice({	×
140	chain,
141	fiatCode: 'USD',
142	});
143	}
144
145	private async _mapBalances(
146	balances: Balance[],
147	fiatCode: string,
148	chain: Chain,
149	): Promise<Balance[]> {
150	const tokenAddresses = balances	58✔
151	.map((balance) => balance.tokenAddress)	128✔
152	.filter((address): address is `0x${string}` => address !== null);	128✔
153
154	const assetPrices = await this.coingeckoApi.getTokenPrices({	58✔
155	chain,
156	fiatCode,
157	tokenAddresses,
158	});
159
160	const lowerCaseAssetPrices = assetPrices?.map((assetPrice) =>	58✔
161	Object.fromEntries(	78✔
162	Object.entries(assetPrice).map(([k, v]) => [k.toLowerCase(), v]),	78✔
163	),
164	);
165
166	return await Promise.all(	58✔
167	balances.map(async (balance) => {
168	const tokenAddress = balance.tokenAddress?.toLowerCase() ?? null;	128✔
169	let price: number \| null;
170	if (tokenAddress === null) {	128✔
171	price = await this.coingeckoApi.getNativeCoinPrice({	42✔
172	chain,
173	fiatCode,
174	});
175	} else {
176	const found = lowerCaseAssetPrices.find(	86✔
177	(assetPrice) => assetPrice[tokenAddress],	114✔
178	);
179	price = found?.[tokenAddress]?.[fiatCode.toLowerCase()] ?? null;	86✔
180	}
181	const fiatBalance = this._getFiatBalance(price, balance);	128✔
182	return {	128✔
183	...balance,
184	fiatBalance: fiatBalance ? getNumberString(fiatBalance) : null,	64✔
185	fiatConversion: price ? getNumberString(price) : null,	64✔
186	};
187	}),
188	);
189	}
190
191	private _getFiatBalance(
192	price: number \| null,
193	balance: Balance,
194	): number \| null {
195	return price !== null	128✔
196	? (price * Number(balance.balance)) /
197	10 ** (balance.token?.decimals ?? SafeBalancesApi.DEFAULT_DECIMALS)	293✔
198	: null;
199	}
200	}

safe-global / safe-client-gateway / 11742544373

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