Refactor namings

src/atomex/atomexContext.ts

@@ -1,7 +1,7 @@
 import type { AuthorizationManager } from '../authorization/index';
 import type { WalletsManager, AtomexBlockchainProvider } from '../blockchain/index';
 import type { AtomexNetwork, CurrenciesProvider } from '../common/index';
-import type { AggregatedRatesProvider, ExchangeManager, ExchangeService, ManagedExchangeSymbolsProvider, ManagedOrderBookProvider } from '../exchange/index';
+import type { ExchangeManager, ExchangeService, ManagedExchangeSymbolsProvider, ManagedOrderBookProvider, RatesProvider } from '../exchange/index';
 import type { SwapManager, SwapService } from '../swaps/index';
 
 export class AtomexContext {
@@ -111,7 +111,7 @@ class AtomexContextProvidersSection {
   private _currenciesProvider: CurrenciesProvider | undefined;
   private _exchangeSymbolsProvider: ManagedExchangeSymbolsProvider | undefined;
   private _orderBookProvider: ManagedOrderBookProvider | undefined;
-  private _ratesProvider: AggregatedRatesProvider | undefined;
+  private _ratesProvider: RatesProvider | undefined;
 
   constructor(readonly context: AtomexContext) {
   }
@@ -160,14 +160,14 @@ class AtomexContextProvidersSection {
     this._orderBookProvider = orderBookProvider;
   }
 
-  get ratesProvider(): AggregatedRatesProvider {
+  get ratesProvider(): RatesProvider {
     if (!this._ratesProvider)
       throw new AtomexComponentNotResolvedError('providers.ratesProvider');
 
     return this._ratesProvider;
   }
 
-  private set ratesProvider(ratesProvider: AggregatedRatesProvider) {
+  private set ratesProvider(ratesProvider: RatesProvider) {
     this._ratesProvider = ratesProvider;
   }
 }

src/atomexBuilder/atomexBuilder.ts

@@ -5,8 +5,8 @@ import { AtomexBlockchainProvider, WalletsManager } from '../blockchain/index';
 import type { DeepReadonly } from '../core/index';
 import { createDefaultEthereumBlockchainOptions } from '../ethereum/index';
 import {
-  AggregatedRatesProvider, AtomexRatesProvider, BinanceRatesProvider, ExchangeManager, InMemoryExchangeSymbolsProvider,
-  InMemoryOrderBookProvider, KrakenRatesProvider, MixedRatesProvider, RatesProvider
+  AtomexRatesService, BinanceRatesService, ExchangeManager, InMemoryExchangeSymbolsProvider,
+  InMemoryOrderBookProvider, KrakenRatesService, MixedRatesProvider, RatesProvider, RatesService
 } from '../exchange/index';
 import { SwapManager } from '../swaps/swapManager';
 import { createDefaultTezosBlockchainOptions } from '../tezos/index';
@@ -124,11 +124,11 @@ export class AtomexBuilder {
     };
   }
 
-  protected createRatesProvider(): AggregatedRatesProvider {
-    return new MixedRatesProvider(new Map<string, RatesProvider>([
-      ['binance', new BinanceRatesProvider()],
-      ['kraken', new KrakenRatesProvider()],
-      ['atomex', new AtomexRatesProvider(this.atomexContext.services.exchangeService)]
+  protected createRatesProvider(): RatesProvider {
+    return new MixedRatesProvider(new Map<string, RatesService>([
+      ['binance', new BinanceRatesService()],
+      ['kraken', new KrakenRatesService()],
+      ['atomex', new AtomexRatesService(this.atomexContext.services.exchangeService)]
     ]));
   }
 }

src/atomexBuilder/controlledAtomexContext.ts

@@ -2,7 +2,7 @@ import type { AuthorizationManager } from '../authorization/index';
 import type { AtomexBlockchainProvider } from '../blockchain/atomexBlockchainProvider';
 import type { WalletsManager } from '../blockchain/index';
 import type { AtomexNetwork, CurrenciesProvider } from '../common/index';
-import type { AggregatedRatesProvider, ExchangeManager, ExchangeService, ManagedExchangeSymbolsProvider, ManagedOrderBookProvider } from '../exchange/index';
+import type { ExchangeManager, ExchangeService, ManagedExchangeSymbolsProvider, ManagedOrderBookProvider, RatesProvider } from '../exchange/index';
 import type { SwapManager, SwapService } from '../swaps/index';
 
 export interface ControlledAtomexContext {
@@ -49,6 +49,6 @@ interface ControlledAtomexContextProvidersSection {
   get orderBookProvider(): ManagedOrderBookProvider;
   set orderBookProvider(value: ManagedOrderBookProvider);
 
-  get ratesProvider(): AggregatedRatesProvider;
-  set ratesProvider(value: AggregatedRatesProvider);
+  get ratesProvider(): RatesProvider;
+  set ratesProvider(value: RatesProvider);
 }

src/exchange/index.ts

@@ -9,7 +9,5 @@ export type { ExchangeSymbolsProvider, ManagedExchangeSymbolsProvider } from './
 export type { OrderBookProvider, ManagedOrderBookProvider } from './orderBookProvider/index';
 export type { ExchangeService, ExchangeServiceEvents } from './exchangeService';
 
-export {
-  type RatesProvider, type AggregatedRatesProvider,
-  BinanceRatesProvider, KrakenRatesProvider, MixedRatesProvider, AtomexRatesProvider
-} from './ratesProvider/index';
+export { type RatesProvider, MixedRatesProvider } from './ratesProvider/index';
+export { type RatesService, AtomexRatesService, BinanceRatesService, KrakenRatesService } from './ratesService/index';

src/exchange/ratesProvider/index.ts

@@ -1,6 +1,2 @@
 export type { RatesProvider } from './ratesProvider';
-export type { AggregatedRatesProvider } from './aggregatedRatesProvider';
-export { AtomexRatesProvider } from './atomex/index';
-export { BinanceRatesProvider } from './binance/index';
-export { KrakenRatesProvider } from './kraken/index';
 export { MixedRatesProvider } from './mixedRatesProvider/index';

src/exchange/ratesProvider/mixedRatesProvider/mixedRatesProvider.ts

@@ -1,17 +1,17 @@
 import BigNumber from 'bignumber.js';
 
 import type { Currency } from '../../../common';
-import type { AggregatedRatesProvider } from '../aggregatedRatesProvider';
+import type { RatesService } from '../../ratesService/index';
 import type { RatesProvider } from '../ratesProvider';
 
-export class MixedRatesProvider implements AggregatedRatesProvider {
+export class MixedRatesProvider implements RatesProvider {
   constructor(
-    private readonly providersMap: Map<string, RatesProvider>
+    private readonly servicesMap: Map<string, RatesService>
   ) { }
 
   async getAveragePrice(baseCurrency: string, quoteCurrency: string): Promise<BigNumber | undefined> {
-    const providers = this.getAvailableProviders();
-    const pricePromises = providers.map(provider => this.getPrice(baseCurrency, quoteCurrency, provider));
+    const services = this.getAvailableServices();
+    const pricePromises = services.map(service => this.getPrice(baseCurrency, quoteCurrency, service));
     const pricePromiseResults = await Promise.allSettled(pricePromises);
 
     const prices: BigNumber[] = [];
@@ -22,24 +22,24 @@ export class MixedRatesProvider implements AggregatedRatesProvider {
     return prices.length ? BigNumber.sum(...prices).div(prices.length) : undefined;
   }
 
-  async getPrice(baseCurrency: Currency['id'], quoteCurrency: Currency['id'], provider?: string): Promise<BigNumber | undefined> {
-    let price = await this.getPriceCore(baseCurrency, quoteCurrency, provider);
+  async getPrice(baseCurrency: Currency['id'], quoteCurrency: Currency['id'], service?: string): Promise<BigNumber | undefined> {
+    let price = await this.getPriceCore(baseCurrency, quoteCurrency, service);
     if (!price) {
-      const reversedPrice = await this.getPriceCore(quoteCurrency, baseCurrency, provider);
+      const reversedPrice = await this.getPriceCore(quoteCurrency, baseCurrency, service);
       if (reversedPrice)
         price = reversedPrice.pow(-1);
     }
 
     return price;
   }
 
-  getAvailableProviders(): string[] {
-    return [...this.providersMap.keys()];
+  getAvailableServices(): string[] {
+    return [...this.servicesMap.keys()];
   }
 
-  private async getPriceCore(baseCurrency: Currency['id'], quoteCurrency: Currency['id'], provider?: string): Promise<BigNumber | undefined> {
-    const providers = this.getSelectedProviders(provider);
-    const pricePromises = providers.map(p => p.getPrice(baseCurrency, quoteCurrency));
+  private async getPriceCore(baseCurrency: Currency['id'], quoteCurrency: Currency['id'], service?: string): Promise<BigNumber | undefined> {
+    const services = this.getSelectedServices(service);
+    const pricePromises = services.map(service => service.getPrice(baseCurrency, quoteCurrency));
     const pricePromiseResults = await Promise.allSettled(pricePromises);
 
     for (const result of pricePromiseResults)
@@ -49,14 +49,14 @@ export class MixedRatesProvider implements AggregatedRatesProvider {
     return undefined;
   }
 
-  private getSelectedProviders(provider?: string): RatesProvider[] {
-    if (!provider)
-      return [...this.providersMap.values()];
+  private getSelectedServices(service?: string): RatesService[] {
+    if (!service)
+      return [...this.servicesMap.values()];
 
-    const selectedProvider = this.providersMap.get(provider);
-    if (!selectedProvider)
-      throw new Error(`Provider not found for key: ${provider}`);
+    const selectedService = this.servicesMap.get(service);
+    if (!selectedService)
+      throw new Error(`Service not found for key: ${service}`);
 
-    return [selectedProvider];
+    return [selectedService];
   }
 }

src/exchange/ratesProvider/ratesProvider.ts

@@ -3,5 +3,7 @@ import type BigNumber from 'bignumber.js';
 import type { Currency } from '../../common';
 
 export interface RatesProvider {
-  getPrice(baseCurrency: Currency['id'], quoteCurrency: Currency['id']): Promise<BigNumber | undefined>;
+  getPrice(baseCurrency: Currency['id'], quoteCurrency: Currency['id'], service?: string): Promise<BigNumber | undefined>;
+  getAveragePrice(baseCurrency: Currency['id'], quoteCurrency: Currency['id']): Promise<BigNumber | undefined>;
+  getAvailableServices(): string[];
 }

src/exchange/ratesProvider/atomex/atomexRatesProvider.ts → src/exchange/ratesService/atomex/atomexRatesService.ts

@@ -3,9 +3,9 @@ import type BigNumber from 'bignumber.js';
 import type { Currency } from '../../../common/index';
 import type { ExchangeService } from '../../exchangeService';
 import type { Quote } from '../../models/index';
-import type { RatesProvider } from '../ratesProvider';
+import type { RatesService } from '../ratesService';
 
-export class AtomexRatesProvider implements RatesProvider {
+export class AtomexRatesService implements RatesService {
   constructor(
     private readonly exchangeService: ExchangeService
   ) { }

src/exchange/ratesService/atomex/index.ts

@@ -0,0 +1 @@
+export { AtomexRatesService } from './atomexRatesService';

src/exchange/ratesProvider/binance/binanceRatesProvider.ts → src/exchange/ratesService/binance/binanceRatesService.ts

@@ -2,19 +2,19 @@ import BigNumber from 'bignumber.js';
 
 import type { Currency } from '../../../common';
 import { HttpClient } from '../../../core';
-import type { RatesProvider } from '../ratesProvider';
+import type { RatesService } from '../ratesService';
 import type { BinanceErrorDto, BinanceRatesDto } from './dtos';
 import { isErrorDto } from './utils';
 
-export class BinanceRatesProvider implements RatesProvider {
+export class BinanceRatesService implements RatesService {
   private static readonly baseUrl = 'https://www.binance.com';
   private static readonly priceUrlPath = '/api/v3/ticker/price';
 
   private readonly httpClient: HttpClient;
   private _allSymbols: Set<string> | undefined;
 
   constructor() {
-    this.httpClient = new HttpClient(BinanceRatesProvider.baseUrl);
+    this.httpClient = new HttpClient(BinanceRatesService.baseUrl);
   }
 
   async getPrice(baseCurrency: Currency['id'], quoteCurrency: Currency['id']): Promise<BigNumber | undefined> {
@@ -23,7 +23,7 @@ export class BinanceRatesProvider implements RatesProvider {
     if (!allSymbols.has(symbol))
       return undefined;
 
-    const urlPath = `${BinanceRatesProvider.priceUrlPath}?symbol=${symbol}`;
+    const urlPath = `${BinanceRatesService.priceUrlPath}?symbol=${symbol}`;
     const responseDto = await this.httpClient.request<BinanceRatesDto | BinanceErrorDto>({ urlPath }, false);
 
     return this.mapRatesDtoToPrice(responseDto);
@@ -44,7 +44,7 @@ export class BinanceRatesProvider implements RatesProvider {
   }
 
   private async requestAllSymbols(): Promise<string[]> {
-    const urlPath = BinanceRatesProvider.priceUrlPath;
+    const urlPath = BinanceRatesService.priceUrlPath;
     const responseDto = await this.httpClient.request<BinanceRatesDto[]>({ urlPath }, false);
 
     return responseDto.map(dto => dto.symbol);

src/exchange/ratesService/binance/index.ts

@@ -0,0 +1 @@
+export { BinanceRatesService } from './binanceRatesService';

src/exchange/ratesService/index.ts

@@ -0,0 +1,4 @@
+export type { RatesService } from './ratesService';
+export { AtomexRatesService } from './atomex/index';
+export { BinanceRatesService } from './binance/index';
+export { KrakenRatesService } from './kraken/index';

src/exchange/ratesService/kraken/index.ts

@@ -0,0 +1 @@
+export { KrakenRatesService } from './krakenRatesService';

src/exchange/ratesProvider/kraken/krakenRatesProvider.ts → src/exchange/ratesService/kraken/krakenRatesService.ts

@@ -2,16 +2,16 @@ import BigNumber from 'bignumber.js';
 
 import type { Currency } from '../../../common';
 import { HttpClient } from '../../../core';
-import type { RatesProvider } from '../ratesProvider';
+import type { RatesService } from '../ratesService';
 import type { KrakenRatesDto } from './dtos';
 
-export class KrakenRatesProvider implements RatesProvider {
+export class KrakenRatesService implements RatesService {
   private static readonly baseUrl = 'https://api.kraken.com';
 
   private readonly httpClient: HttpClient;
 
   constructor() {
-    this.httpClient = new HttpClient(KrakenRatesProvider.baseUrl);
+    this.httpClient = new HttpClient(KrakenRatesService.baseUrl);
   }
 
   async getPrice(baseCurrency: Currency['id'], quoteCurrency: Currency['id']): Promise<BigNumber | undefined> {

src/exchange/ratesService/ratesService.ts

@@ -0,0 +1,7 @@
+import type BigNumber from 'bignumber.js';
+
+import type { Currency } from '../../common';
+
+export interface RatesService {
+  getPrice(baseCurrency: Currency['id'], quoteCurrency: Currency['id']): Promise<BigNumber | undefined>;
+}