7697995857

Committed 29 Jan 2024 02:56PM UTC coverage: 93.305% (-0.06%) from 93.36%

Build # 7697995857

Build Type

Pull #1062

github

Committed by

hectorgomezv

Commit Message

PR comments

Pull Request Pull Request #1062: Add Valk Balances provider

Run Details

1513 of 1801 branches covered (0.0%)

Branch coverage included in aggregate %.

75 of 80 new or added lines in 8 files covered. (93.75%)

1 existing line in 1 file now uncovered.

5650 of 5876 relevant lines covered (96.15%)

171.54 hits per line

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

85.71

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

import { IConfigurationService } from '@/config/configuration.service.interface';
import { ValkBalance } from '@/datasources/balances-api/entities/valk-balance.entity';
import { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';
import { CacheRouter } from '@/datasources/cache/cache.router';
import {
  CacheService,
  ICacheService,
} from '@/datasources/cache/cache.service.interface';
import {
  Balance,
  Erc20Balance,
  NativeBalance,
} from '@/domain/balances/entities/balance.entity';
import { getNumberString } from '@/domain/common/utils/utils';
import { DataSourceError } from '@/domain/errors/data-source.error';
import { IBalancesApi } from '@/domain/interfaces/balances-api.interface';
import { asError } from '@/logging/utils';
import { Inject, Injectable } from '@nestjs/common';
import { isAddress } from 'viem';

export const IValkBalancesApi = Symbol('IValkBalancesApi');

type ChainAttributes = {
  chainName: string;
  nativeCoin?: string;
};

@Injectable()
export class ValkBalancesApi implements IBalancesApi {
  private readonly apiKey: string | undefined;
  private readonly baseUri: string;
  private readonly chainsConfiguration: Record<number, ChainAttributes>;
  private readonly defaultExpirationTimeInSeconds: number;
  private readonly defaultNotFoundExpirationTimeSeconds: number;

  constructor(
    @Inject(CacheService) private readonly cacheService: ICacheService,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    private readonly dataSource: CacheFirstDataSource,
  ) {
    this.apiKey = this.configurationService.get<string>(
      'balances.providers.valk.apiKey',
    );
    this.baseUri = this.configurationService.getOrThrow<string>(
      'balances.providers.valk.baseUri',
    );
    this.defaultExpirationTimeInSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.default',
      );
    this.defaultNotFoundExpirationTimeSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.notFound.default',
      );
    this.chainsConfiguration = this.configurationService.getOrThrow<
      Record<number, ChainAttributes>
    >('balances.providers.valk.chains');
  }

  async getBalances(args: {
    chainId: string;
    safeAddress: string;
    fiatCode: string;
  }): Promise<Balance[]> {
    try {
      const cacheDir = CacheRouter.getValkBalancesCacheDir(args);
      const chainName = this._getChainName(args.chainId);
      const url = `${this.baseUri}/balances/token/${args.safeAddress}?chain=${chainName}`;
      const valkBalances = await this.dataSource.get<ValkBalance[]>({
        cacheDir,
        url,
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        networkRequest: { headers: { Authorization: `${this.apiKey}` } },
        expireTimeSeconds: this.defaultExpirationTimeInSeconds,
      });
      return this._mapBalances(valkBalances, args.fiatCode);
    } catch (error) {
      throw new DataSourceError(
        `Error getting ${args.safeAddress} balances from provider: ${asError(error).message}}`,
      );
    }
  }

  async clearBalances(args: {
    chainId: string;
    safeAddress: string;
  }): Promise<void> {
    const key = CacheRouter.getValkBalancesCacheKey(args);
    await this.cacheService.deleteByKey(key);
  }

  private _mapBalances(
    valkBalances: ValkBalance[],
    fiatCode: string,
  ): Balance[] {
    return valkBalances.map((valkBalance) => {
      const price = valkBalance.prices[fiatCode.toUpperCase()] ?? null;
      const fiatBalance = getNumberString(
        (valkBalance.balance / Math.pow(10, valkBalance.decimals)) * price,
      );
      const fiatConversion = getNumberString(price);

      // Valk returns a string representing the native coin (e.g.: 'eth') as token_address
      // for native coins balances. An Ethereum address is returned for ERC20 tokens.
      return {
        ...(isAddress(valkBalance.token_address)
          ? this._mapErc20Balance(valkBalance)
          : this._mapNativeBalance(valkBalance)),
        fiatBalance,
        fiatConversion,
      } as Balance;
    });
  }

  private _mapErc20Balance(valkBalance: ValkBalance): Erc20Balance {
    return {
      tokenAddress: valkBalance.token_address,
      token: {
        name: valkBalance.name,
        symbol: valkBalance.symbol,
        decimals: valkBalance.decimals,
        logoUri: valkBalance.logo ?? '',
      },
      balance: getNumberString(valkBalance.balance),
    };
  }

  private _mapNativeBalance(valkBalance: ValkBalance): NativeBalance {
    return {
      tokenAddress: null,
      token: null,
      balance: getNumberString(valkBalance.balance),
    };
  }

  private _getChainName(chainId: string): string {
    const chainName = this.chainsConfiguration[Number(chainId)]?.chainName;
    if (!chainName)
      throw Error(
        `Chain ${chainId} balances retrieval via Valk is not configured`,
      );
    return chainName;
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	82✔
2	import { ValkBalance } from '@/datasources/balances-api/entities/valk-balance.entity';
3	import { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';	82✔
4	import { CacheRouter } from '@/datasources/cache/cache.router';	82✔
5	import {	82✔
6	CacheService,
7	ICacheService,
8	} from '@/datasources/cache/cache.service.interface';
9	import {
10	Balance,
11	Erc20Balance,
12	NativeBalance,
13	} from '@/domain/balances/entities/balance.entity';
14	import { getNumberString } from '@/domain/common/utils/utils';	82✔
15	import { DataSourceError } from '@/domain/errors/data-source.error';	82✔
16	import { IBalancesApi } from '@/domain/interfaces/balances-api.interface';
17	import { asError } from '@/logging/utils';	82✔
18	import { Inject, Injectable } from '@nestjs/common';	82✔
19	import { isAddress } from 'viem';	82✔
20
21	export const IValkBalancesApi = Symbol('IValkBalancesApi');	82✔
22
23	type ChainAttributes = {
24	chainName: string;
25	nativeCoin?: string;
26	};
27
28	@Injectable()
29	export class ValkBalancesApi implements IBalancesApi {	82✔
30	private readonly apiKey: string \| undefined;
31	private readonly baseUri: string;
32	private readonly chainsConfiguration: Record<number, ChainAttributes>;
33	private readonly defaultExpirationTimeInSeconds: number;
34	private readonly defaultNotFoundExpirationTimeSeconds: number;
35
36	constructor(
37	@Inject(CacheService) private readonly cacheService: ICacheService,	590✔
38	@Inject(IConfigurationService)
39	private readonly configurationService: IConfigurationService,	590✔
40	private readonly dataSource: CacheFirstDataSource,	590✔
41	) {
42	this.apiKey = this.configurationService.get<string>(	590✔
43	'balances.providers.valk.apiKey',
44	);
45	this.baseUri = this.configurationService.getOrThrow<string>(	590✔
46	'balances.providers.valk.baseUri',
47	);
48	this.defaultExpirationTimeInSeconds =	590✔
49	this.configurationService.getOrThrow<number>(
50	'expirationTimeInSeconds.default',
51	);
52	this.defaultNotFoundExpirationTimeSeconds =	590✔
53	this.configurationService.getOrThrow<number>(
54	'expirationTimeInSeconds.notFound.default',
55	);
56	this.chainsConfiguration = this.configurationService.getOrThrow<	590✔
57	Record<number, ChainAttributes>
58	>('balances.providers.valk.chains');
59	}
60
61	async getBalances(args: {
62	chainId: string;
63	safeAddress: string;
64	fiatCode: string;
65	}): Promise<Balance[]> {
66	try {	8✔
67	const cacheDir = CacheRouter.getValkBalancesCacheDir(args);	8✔
68	const chainName = this._getChainName(args.chainId);	8✔
69	const url = `${this.baseUri}/balances/token/${args.safeAddress}?chain=${chainName}`;	8✔
70	const valkBalances = await this.dataSource.get<ValkBalance[]>({	8✔
71	cacheDir,
72	url,
73	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
74	networkRequest: { headers: { Authorization: `${this.apiKey}` } },
75	expireTimeSeconds: this.defaultExpirationTimeInSeconds,
76	});
77	return this._mapBalances(valkBalances, args.fiatCode);	6✔
78	} catch (error) {
79	throw new DataSourceError(	2✔
80	`Error getting ${args.safeAddress} balances from provider: ${asError(error).message}}`,
81	);
82	}
83	}
84
85	async clearBalances(args: {
86	chainId: string;
87	safeAddress: string;
88	}): Promise<void> {
NEW 89	const key = CacheRouter.getValkBalancesCacheKey(args);	×
NEW 90	await this.cacheService.deleteByKey(key);	×
91	}
92
93	private _mapBalances(
94	valkBalances: ValkBalance[],
95	fiatCode: string,
96	): Balance[] {
97	return valkBalances.map((valkBalance) => {	6✔
98	const price = valkBalance.prices[fiatCode.toUpperCase()] ?? null;	8!
99	const fiatBalance = getNumberString(	8✔
100	(valkBalance.balance / Math.pow(10, valkBalance.decimals)) * price,
101	);
102	const fiatConversion = getNumberString(price);	8✔
103
104	// Valk returns a string representing the native coin (e.g.: 'eth') as token_address
105	// for native coins balances. An Ethereum address is returned for ERC20 tokens.
106	return {	8✔
107	...(isAddress(valkBalance.token_address)	4✔
108	? this._mapErc20Balance(valkBalance)
109	: this._mapNativeBalance(valkBalance)),
110	fiatBalance,
111	fiatConversion,
112	} as Balance;
113	});
114	}
115
116	private _mapErc20Balance(valkBalance: ValkBalance): Erc20Balance {
117	return {	6✔
118	tokenAddress: valkBalance.token_address,
119	token: {
120	name: valkBalance.name,
121	symbol: valkBalance.symbol,
122	decimals: valkBalance.decimals,
123	logoUri: valkBalance.logo ?? '',	9!
124	},
125	balance: getNumberString(valkBalance.balance),
126	};
127	}
128
129	private _mapNativeBalance(valkBalance: ValkBalance): NativeBalance {
130	return {	2✔
131	tokenAddress: null,
132	token: null,
133	balance: getNumberString(valkBalance.balance),
134	};
135	}
136
137	private _getChainName(chainId: string): string {
138	const chainName = this.chainsConfiguration[Number(chainId)]?.chainName;	8!
139	if (!chainName)	8!
NEW 140	throw Error(	×
141	`Chain ${chainId} balances retrieval via Valk is not configured`,
142	);
143	return chainName;	8✔
144	}
145	}

safe-global / safe-client-gateway / 7697995857

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