7730241130

Committed 31 Jan 2024 05:49PM UTC coverage: 93.163% (-0.1%) from 93.295%

Build # 7730241130

Build Type

Pull #1096

github

Committed by

web-flow

Commit Message

Merge a094c430c into 430a0e98c

Pull Request Pull Request #1096: Add Zerion Balances provider

Run Details

1499 of 1798 branches covered (0.0%)

Branch coverage included in aggregate %.

65 of 71 new or added lines in 5 files covered. (91.55%)

2 existing lines in 1 file now uncovered.

5737 of 5969 relevant lines covered (96.11%)

176.32 hits per line

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

79.69

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

import { IConfigurationService } from '@/config/configuration.service.interface';
import { ChainAttributes } from '@/datasources/balances-api/entities/provider-chain-attributes.entity';
import { ZerionBalance } from '@/datasources/balances-api/entities/zerion-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';

export const IZerionBalancesApi = Symbol('IZerionBalancesApi');

@Injectable()
export class ZerionBalancesApi 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.zerion.apiKey',
    );
    this.baseUri = this.configurationService.getOrThrow<string>(
      'balances.providers.zerion.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.zerion.chains');
  }

  async getBalances(args: {
    chainId: string;
    safeAddress: string;
    fiatCode: string;
  }): Promise<Balance[]> {
    try {
      const cacheDir = CacheRouter.getZerionBalancesCacheDir(args);
      const chainName = this._getChainName(args.chainId);
      const currency = args.fiatCode.toLowerCase();
      const url = `${this.baseUri}/v1/wallets/${args.safeAddress}/positions?filter[chain_ids]=${chainName}&currency=${currency}&sort=value`;
      const zerionBalances = await this.dataSource.get<ZerionBalance[]>({
        cacheDir,
        url,
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        networkRequest: { headers: { Authorization: `Basic ${this.apiKey}` } },
        expireTimeSeconds: this.defaultExpirationTimeInSeconds,
      });
      return this._mapBalances(chainName, zerionBalances);
    } catch (error) {
      throw new DataSourceError(
        `Error getting ${args.safeAddress} balances from provider: ${asError(error).message}}`,
      );
    }
  }

  private _mapBalances(
    chainName: string,
    zerionBalances: ZerionBalance[],
  ): Balance[] {
    try {
      return zerionBalances
        .filter((zb) => zb.attributes.flags.displayable === true)
        .map((zb) => {
          const implementation =
            zb.attributes.fungible_info.implementations.find(
              (implementation) => implementation.chain_id === chainName,
            );
          if (!implementation)
            throw Error(
              `Zerion error: ${chainName} implementation not found for balance ${zb.id}`,
            );
          const fiatBalance = getNumberString(zb.attributes.value ?? 0);
          const fiatConversion = getNumberString(zb.attributes.price);

          return {
            ...(implementation.address === null
              ? this._mapNativeBalance(zb)
              : this._mapErc20Balance(zb, implementation.address)),
            fiatBalance,
            fiatConversion,
          };
        });
    } catch (err) {
      throw err;
    }
  }

  private _mapErc20Balance(
    zerionBalance: ZerionBalance,
    tokenAddress: string,
  ): Erc20Balance {
    return {
      tokenAddress,
      token: {
        name: zerionBalance.attributes.fungible_info.name!,
        symbol: zerionBalance.attributes.fungible_info.symbol!,
        decimals: zerionBalance.attributes.quantity.decimals,
        logoUri: zerionBalance.attributes.fungible_info.icon.url ?? '',
      },
      balance: zerionBalance.attributes.quantity.int,
    };
  }

  private _mapNativeBalance(zerionBalance: ZerionBalance): NativeBalance {
    return {
      tokenAddress: null,
      token: null,
      balance: zerionBalance.attributes.quantity.int,
    };
  }

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

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

1	import { IConfigurationService } from '@/config/configuration.service.interface';	84✔
2	import { ChainAttributes } from '@/datasources/balances-api/entities/provider-chain-attributes.entity';
3	import { ZerionBalance } from '@/datasources/balances-api/entities/zerion-balance.entity';
4	import { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';	84✔
5	import { CacheRouter } from '@/datasources/cache/cache.router';	84✔
6	import {	84✔
7	CacheService,
8	ICacheService,
9	} from '@/datasources/cache/cache.service.interface';
10	import {
11	Balance,
12	Erc20Balance,
13	NativeBalance,
14	} from '@/domain/balances/entities/balance.entity';
15	import { getNumberString } from '@/domain/common/utils/utils';	84✔
16	import { DataSourceError } from '@/domain/errors/data-source.error';	84✔
17	import { IBalancesApi } from '@/domain/interfaces/balances-api.interface';
18	import { asError } from '@/logging/utils';	84✔
19	import { Inject, Injectable } from '@nestjs/common';	84✔
20
21	export const IZerionBalancesApi = Symbol('IZerionBalancesApi');	84✔
22
23	@Injectable()
24	export class ZerionBalancesApi implements IBalancesApi {	84✔
25	private readonly apiKey: string \| undefined;
26	private readonly baseUri: string;
27	private readonly chainsConfiguration: Record<number, ChainAttributes>;
28	private readonly defaultExpirationTimeInSeconds: number;
29	private readonly defaultNotFoundExpirationTimeSeconds: number;
30
31	constructor(
32	@Inject(CacheService) private readonly cacheService: ICacheService,	608✔
33	@Inject(IConfigurationService)
34	private readonly configurationService: IConfigurationService,	608✔
35	private readonly dataSource: CacheFirstDataSource,	608✔
36	) {
37	this.apiKey = this.configurationService.get<string>(	608✔
38	'balances.providers.zerion.apiKey',
39	);
40	this.baseUri = this.configurationService.getOrThrow<string>(	608✔
41	'balances.providers.zerion.baseUri',
42	);
43	this.defaultExpirationTimeInSeconds =	608✔
44	this.configurationService.getOrThrow<number>(
45	'expirationTimeInSeconds.default',
46	);
47	this.defaultNotFoundExpirationTimeSeconds =	608✔
48	this.configurationService.getOrThrow<number>(
49	'expirationTimeInSeconds.notFound.default',
50	);
51	this.chainsConfiguration = this.configurationService.getOrThrow<	608✔
52	Record<number, ChainAttributes>
53	>('balances.providers.zerion.chains');
54	}
55
56	async getBalances(args: {
57	chainId: string;
58	safeAddress: string;
59	fiatCode: string;
60	}): Promise<Balance[]> {
61	try {	2✔
62	const cacheDir = CacheRouter.getZerionBalancesCacheDir(args);	2✔
63	const chainName = this._getChainName(args.chainId);	2✔
64	const currency = args.fiatCode.toLowerCase();	2✔
65	const url = `${this.baseUri}/v1/wallets/${args.safeAddress}/positions?filter[chain_ids]=${chainName}&currency=${currency}&sort=value`;	2✔
66	const zerionBalances = await this.dataSource.get<ZerionBalance[]>({	2✔
67	cacheDir,
68	url,
69	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
70	networkRequest: { headers: { Authorization: `Basic ${this.apiKey}` } },
71	expireTimeSeconds: this.defaultExpirationTimeInSeconds,
72	});
73	return this._mapBalances(chainName, zerionBalances);	2✔
74	} catch (error) {
NEW 75	throw new DataSourceError(	×
76	`Error getting ${args.safeAddress} balances from provider: ${asError(error).message}}`,
77	);
78	}
79	}
80
81	private _mapBalances(
82	chainName: string,
83	zerionBalances: ZerionBalance[],
84	): Balance[] {
85	try {	2✔
86	return zerionBalances	2✔
87	.filter((zb) => zb.attributes.flags.displayable === true)	4✔
88	.map((zb) => {
89	const implementation =
90	zb.attributes.fungible_info.implementations.find(	4✔
91	(implementation) => implementation.chain_id === chainName,	4✔
92	);
93	if (!implementation)	4!
NEW 94	throw Error(	×
95	`Zerion error: ${chainName} implementation not found for balance ${zb.id}`,
96	);
97	const fiatBalance = getNumberString(zb.attributes.value ?? 0);	4!
98	const fiatConversion = getNumberString(zb.attributes.price);	4✔
99
100	return {	4✔
101	...(implementation.address === null	2✔
102	? this._mapNativeBalance(zb)
103	: this._mapErc20Balance(zb, implementation.address)),
104	fiatBalance,
105	fiatConversion,
106	};
107	});
108	} catch (err) {
NEW 109	throw err;	×
110	}
111	}
112
113	private _mapErc20Balance(
114	zerionBalance: ZerionBalance,
115	tokenAddress: string,
116	): Erc20Balance {
117	return {	2✔
118	tokenAddress,
119	token: {
120	name: zerionBalance.attributes.fungible_info.name!,
121	symbol: zerionBalance.attributes.fungible_info.symbol!,
122	decimals: zerionBalance.attributes.quantity.decimals,
123	logoUri: zerionBalance.attributes.fungible_info.icon.url ?? '',	3!
124	},
125	balance: zerionBalance.attributes.quantity.int,
126	};
127	}
128
129	private _mapNativeBalance(zerionBalance: ZerionBalance): NativeBalance {
130	return {	2✔
131	tokenAddress: null,
132	token: null,
133	balance: zerionBalance.attributes.quantity.int,
134	};
135	}
136
137	async clearBalances(args: {
138	chainId: string;
139	safeAddress: string;
140	}): Promise<void> {
NEW 141	const key = CacheRouter.getZerionBalancesCacheKey(args);	×
NEW 142	await this.cacheService.deleteByKey(key);	×
143	}
144
145	private _getChainName(chainId: string): string {
146	const chainName = this.chainsConfiguration[Number(chainId)]?.chainName;	2!
147	if (!chainName)	2!
NEW 148	throw Error(	×
149	`Chain ${chainId} balances retrieval via Zerion is not configured`,
150	);
151	return chainName;	2✔
152	}
153	}

safe-global / safe-client-gateway / 7730241130

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