bitrinjani / r2 / 48

pending completion

Build # 48

Build Type

push

travis-ci

Committed by

bitrinjani

Commit Message

<a href="https://github.com/bitrinjani/r2/commit/<a class=hub.com/bitrinjani/r2/commit/02171a0a33cddea2625419ecbf211ec6d79964e8">02171a0a3<a href="https://github.com/bitrinjani/r2/commit/02171a0a33cddea2625419ecbf211ec6d79964e8">&quot;&gt;Revert &amp;quot;major refactoring&quot;

This reverts commit </a><a class="double-link" href="https://github.com/bitrinjani/r2/commit/<a class="double-link" href="https://github.com/bitrinjani/r2/commit/b68dd72dcacbde5e58f1533ba68ab4e0246b88ff">b68dd72dc</a>">b68dd72dc</a><a href="https://github.com/bitrinjani/r2/commit/02171a0a33cddea2625419ecbf211ec6d79964e8">.

Run Details

257 of 303 branches covered (84.82%)

Branch coverage included in aggregate %.

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

1406 of 1424 relevant lines covered (98.74%)

35.87 hits per line

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

92.56

/src/Coincheck/BrokerAdapterImpl.ts

﻿import { getLogger } from '../logger';
import { injectable, inject } from 'inversify';
import { addMinutes } from 'date-fns';
import symbols from '../symbols';
import * as _ from 'lodash';
import Order from '../Order';
import Quote from '../Quote';
import BrokerApi from './BrokerApi';
import Execution from '../Execution';
import {
  CashMarginType, ConfigStore, BrokerConfig, Broker,
  BrokerAdapter, QuoteSide, OrderStatus, OrderSide
} from '../type';
import { OrderBooksResponse, NewOrderRequest, LeveragePosition } from './type';
import { getBrokerOrderType } from './mapper';
import { eRound, almostEqual } from '../util';

@injectable()
export default class BrokerAdapterImpl implements BrokerAdapter {
  private brokerApi: BrokerApi;
  private log = getLogger('Coincheck.BrokerAdapter');
  private config: BrokerConfig;
  broker = Broker.Coincheck;

  constructor(
    @inject(symbols.ConfigStore) configStore: ConfigStore
  ) {
    this.config = _.find(configStore.config.brokers,
      (b: BrokerConfig) => b.broker === this.broker) as BrokerConfig;
    this.brokerApi = new BrokerApi(this.config.key, this.config.secret);
  }

  async getBtcPosition(): Promise<number> {
    if (this.config.cashMarginType === CashMarginType.Cash) {
      return (await this.brokerApi.getAccountsBalance()).btc;
    }
    const positions = await this.brokerApi.getAllOpenLeveragePositions();
    const longPosition = _.sumBy(positions.filter(p => p.side === 'buy'), p => p.amount);
    const shortPosition = _.sumBy(positions.filter(p => p.side === 'sell'), p => p.amount);
    return eRound(longPosition - shortPosition);
  }

  async fetchQuotes(): Promise<Quote[]> {
    try {
      const response = await this.brokerApi.getOrderBooks();
      return this.mapToQuote(response);
    } catch (ex) {
      this.log.error(ex.message);
      this.log.debug(ex.stack);
      return [];
    }
  }

  private mapToQuote(orderBooksResponse: OrderBooksResponse): Quote[] {
    const asks = _(orderBooksResponse.asks)
      .take(100)
      .map(q => new Quote(this.broker, QuoteSide.Ask, q[0], q[1]))
      .value();
    const bids = _(orderBooksResponse.bids)
      .take(100)
      .map(q => new Quote(this.broker, QuoteSide.Bid, q[0], q[1]))
      .value();
    return _.concat(asks, bids);
  }

  async send(order: Order): Promise<void> {
    if (order.broker !== this.broker) {
      throw new Error();
    }
    let request: NewOrderRequest;
    if (order.cashMarginType === CashMarginType.NetOut) {
      request = await this.getNetOutRequest(order);
    } else {
      const orderType = getBrokerOrderType(order);
      request = {
        pair: 'btc_jpy',
        order_type: orderType,
        amount: order.size,
        rate: order.price
      };
    }
    const reply = await this.brokerApi.newOrder(request);
    if (!reply.success) {
      throw new Error('Send failed.');
    }
    order.sentTime = reply.created_at;
    order.status = OrderStatus.New;
    order.brokerOrderId = reply.id;
    order.lastUpdated = new Date();
  }

  private async getNetOutRequest(order: Order): Promise<NewOrderRequest> {
    const openPositions = await this.brokerApi.getAllOpenLeveragePositions();
    const targetSide = order.side === OrderSide.Buy ? 'sell' : 'buy';
    const candidates = _(openPositions)
      .filter(p => p.side === targetSide)
      .filter(p => almostEqual(p.amount, order.size, 1))
      .value();
    const request = { pair: 'btc_jpy', rate: order.price };
    if (candidates.length === 0) {
      return {
        ...request,
        order_type: order.side === OrderSide.Buy ? 'leverage_buy' : 'leverage_sell',
        amount: order.size
      };
    } else {
      const targetPosition = _.last(candidates) as LeveragePosition;
      return {
        ...request,
        order_type: order.side === OrderSide.Buy ? 'close_short' : 'close_long',
        amount: targetPosition.amount,
        position_id: Number(targetPosition.id)
      };
    }
  }

  async cancel(order: Order): Promise<void> {
    const orderId = order.brokerOrderId;
    const reply = await this.brokerApi.cancelOrder(orderId);
    if (!reply.success) {
      throw new Error(`Cancel ${orderId} failed.`);
    }
    order.lastUpdated = new Date();
    order.status = OrderStatus.Canceled;
  }

  async refresh(order: Order): Promise<void> {
    const reply = await this.brokerApi.getOpenOrders();
    const brokerOrder = _.find(reply.orders, o => o.id === order.brokerOrderId);
    if (brokerOrder !== undefined) {
      if (brokerOrder.pending_amount === undefined || brokerOrder.pending_amount === 0) {
        throw new Error('Unexpected reply returned.');
      }
      order.filledSize = eRound(order.size - brokerOrder.pending_amount);
      if (order.filledSize > 0) {
        order.status = OrderStatus.PartiallyFilled;
      }
      order.lastUpdated = new Date();
      return;
    }
    const from = addMinutes(order.creationTime, -1);
    const transactions = (await this.brokerApi.getTransactionsWithStartDate(from))
      .filter(x => x.order_id === order.brokerOrderId);
    if (transactions.length === 0) {
      this.log.warn('The order is not found in pending orders and historical orders.');
      return;
    }
    order.executions = transactions.map((x) => {
      const execution = new Execution(order);
      execution.execTime = x.created_at;
      execution.price = x.rate;
      execution.size = Math.abs(x.funds.btc);
      return execution;
    });
    order.filledSize = eRound(_.sumBy(order.executions, x => x.size));
    order.status = almostEqual(order.filledSize, order.size, 1) ? OrderStatus.Filled : OrderStatus.Canceled;
    order.lastUpdated = new Date();
  }
}

1	import { getLogger } from '../logger';	2✔
2	import { injectable, inject } from 'inversify';	2✔
3	import { addMinutes } from 'date-fns';	2✔
4	import symbols from '../symbols';	2✔
5	import * as _ from 'lodash';	2✔
6	import Order from '../Order';
7	import Quote from '../Quote';	2✔
8	import BrokerApi from './BrokerApi';	2✔
9	import Execution from '../Execution';	2✔
10	import {	2✔
11	CashMarginType, ConfigStore, BrokerConfig, Broker,
12	BrokerAdapter, QuoteSide, OrderStatus, OrderSide
13	} from '../type';
14	import { OrderBooksResponse, NewOrderRequest, LeveragePosition } from './type';
15	import { getBrokerOrderType } from './mapper';	2✔
16	import { eRound, almostEqual } from '../util';	2✔
17
18	@injectable()
19	export default class BrokerAdapterImpl implements BrokerAdapter {	2✔
20	private brokerApi: BrokerApi;
21	private log = getLogger('Coincheck.BrokerAdapter');	14✔
22	private config: BrokerConfig;
23	broker = Broker.Coincheck;	14✔
24
25	constructor(
26	@inject(symbols.ConfigStore) configStore: ConfigStore	2!
27	) {
28	this.config = _.find(configStore.config.brokers,	14✔
29	(b: BrokerConfig) => b.broker === this.broker) as BrokerConfig;	14✔
30	this.brokerApi = new BrokerApi(this.config.key, this.config.secret);	14✔
31	}
32
33	async getBtcPosition(): Promise<number> {
34	if (this.config.cashMarginType === CashMarginType.Cash) {	2✔
35	return (await this.brokerApi.getAccountsBalance()).btc;	1✔
36	}
37	const positions = await this.brokerApi.getAllOpenLeveragePositions();	1✔
38	const longPosition = _.sumBy(positions.filter(p => p.side === 'buy'), p => p.amount);	6✔
39	const shortPosition = _.sumBy(positions.filter(p => p.side === 'sell'), p => p.amount);	6✔
40	return eRound(longPosition - shortPosition);	1✔
41	}
42
43	async fetchQuotes(): Promise<Quote[]> {
44	try {	2✔
45	const response = await this.brokerApi.getOrderBooks();	2✔
46	return this.mapToQuote(response);	1✔
47	} catch (ex) {
48	this.log.error(ex.message);	1✔
49	this.log.debug(ex.stack);	1✔
50	return [];	1✔
51	}
52	}
53
54	private mapToQuote(orderBooksResponse: OrderBooksResponse): Quote[] {
55	const asks = _(orderBooksResponse.asks)	1✔
56	.take(100)
57	.map(q => new Quote(this.broker, QuoteSide.Ask, q[0], q[1]))	100✔
58	.value();
59	const bids = _(orderBooksResponse.bids)	1✔
60	.take(100)
61	.map(q => new Quote(this.broker, QuoteSide.Bid, q[0], q[1]))	100✔
62	.value();
63	return _.concat(asks, bids);	1✔
64	}
65
66	async send(order: Order): Promise<void> {
67	if (order.broker !== this.broker) {	5✔
68	throw new Error();	1✔
69	}
70	let request: NewOrderRequest;
71	if (order.cashMarginType === CashMarginType.NetOut) {	4✔
72	request = await this.getNetOutRequest(order);	2✔
73	} else {
74	const orderType = getBrokerOrderType(order);	2✔
75	request = {	2✔
76	pair: 'btc_jpy',
77	order_type: orderType,
78	amount: order.size,
79	rate: order.price
80	};
81	}
82	const reply = await this.brokerApi.newOrder(request);	4✔
83	if (!reply.success) {	4✔
84	throw new Error('Send failed.');	1✔
85	}
86	order.sentTime = reply.created_at;	3✔
87	order.status = OrderStatus.New;	3✔
88	order.brokerOrderId = reply.id;	3✔
89	order.lastUpdated = new Date();	3✔
90	}
91
92	private async getNetOutRequest(order: Order): Promise<NewOrderRequest> {
93	const openPositions = await this.brokerApi.getAllOpenLeveragePositions();	4✔
94	const targetSide = order.side === OrderSide.Buy ? 'sell' : 'buy';	4✔
95	const candidates = _(openPositions)	4✔
96	.filter(p => p.side === targetSide)	24✔
97	.filter(p => almostEqual(p.amount, order.size, 1))	12✔
98	.value();
99	const request = { pair: 'btc_jpy', rate: order.price };	4✔
100	if (candidates.length === 0) {	4✔
101	return {	2✔
102	...request,
103	order_type: order.side === OrderSide.Buy ? 'leverage_buy' : 'leverage_sell',	2!
104	amount: order.size
105	};
106	} else {
107	const targetPosition = _.last(candidates) as LeveragePosition;	2✔
108	return {	2✔
109	...request,
110	order_type: order.side === OrderSide.Buy ? 'close_short' : 'close_long',	2!
111	amount: targetPosition.amount,
112	position_id: Number(targetPosition.id)
113	};
114	}
115	}
116
117	async cancel(order: Order): Promise<void> {
118	const orderId = order.brokerOrderId;	2✔
119	const reply = await this.brokerApi.cancelOrder(orderId);	2✔
120	if (!reply.success) {	2✔
121	throw new Error(`Cancel ${orderId} failed.`);	1✔
122	}
123	order.lastUpdated = new Date();	1✔
124	order.status = OrderStatus.Canceled;	1✔
125	}
126
127	async refresh(order: Order): Promise<void> {
128	const reply = await this.brokerApi.getOpenOrders();	3✔
129	const brokerOrder = _.find(reply.orders, o => o.id === order.brokerOrderId);	3✔
130	if (brokerOrder !== undefined) {	3✔
131	if (brokerOrder.pending_amount === undefined \|\| brokerOrder.pending_amount === 0) {	2✔
132	throw new Error('Unexpected reply returned.');	1✔
133	}
134	order.filledSize = eRound(order.size - brokerOrder.pending_amount);	1✔
135	if (order.filledSize > 0) {	1!
136	order.status = OrderStatus.PartiallyFilled;	1✔
137	}
138	order.lastUpdated = new Date();	1✔
139	return;	1✔
140	}
141	const from = addMinutes(order.creationTime, -1);	1✔
142	const transactions = (await this.brokerApi.getTransactionsWithStartDate(from))	1✔
143	.filter(x => x.order_id === order.brokerOrderId);	1✔
144	if (transactions.length === 0) {	1!
145	this.log.warn('The order is not found in pending orders and historical orders.');	×
146	return;	×
147	}
148	order.executions = transactions.map((x) => {	1✔
149	const execution = new Execution(order);	1✔
150	execution.execTime = x.created_at;	1✔
151	execution.price = x.rate;	1✔
152	execution.size = Math.abs(x.funds.btc);	1✔
153	return execution;	1✔
154	});
155	order.filledSize = eRound(_.sumBy(order.executions, x => x.size));	1✔
156	order.status = almostEqual(order.filledSize, order.size, 1) ? OrderStatus.Filled : OrderStatus.Canceled;	1!
157	order.lastUpdated = new Date();	1✔
158	}
159	}

bitrinjani / r2 / 48

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