All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.knowm.xchange.bithumb.BithumbAdapters Maven / Gradle / Ivy

package org.knowm.xchange.bithumb;

import java.math.BigDecimal;
import java.math.MathContext;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import org.knowm.xchange.bithumb.dto.account.BithumbAccount;
import org.knowm.xchange.bithumb.dto.account.BithumbBalance;
import org.knowm.xchange.bithumb.dto.account.BithumbOrder;
import org.knowm.xchange.bithumb.dto.account.BithumbOrderDetail;
import org.knowm.xchange.bithumb.dto.marketdata.BithumbOrderbook;
import org.knowm.xchange.bithumb.dto.marketdata.BithumbOrderbookEntry;
import org.knowm.xchange.bithumb.dto.marketdata.BithumbTicker;
import org.knowm.xchange.bithumb.dto.marketdata.BithumbTickersReturn;
import org.knowm.xchange.bithumb.dto.marketdata.BithumbTransactionHistory;
import org.knowm.xchange.bithumb.dto.trade.BithumbUserTransaction;
import org.knowm.xchange.currency.Currency;
import org.knowm.xchange.currency.CurrencyPair;
import org.knowm.xchange.dto.Order;
import org.knowm.xchange.dto.account.AccountInfo;
import org.knowm.xchange.dto.account.Balance;
import org.knowm.xchange.dto.account.Wallet;
import org.knowm.xchange.dto.marketdata.OrderBook;
import org.knowm.xchange.dto.marketdata.Ticker;
import org.knowm.xchange.dto.marketdata.Trade;
import org.knowm.xchange.dto.marketdata.Trades;
import org.knowm.xchange.dto.trade.LimitOrder;
import org.knowm.xchange.dto.trade.MarketOrder;
import org.knowm.xchange.dto.trade.OpenOrders;
import org.knowm.xchange.dto.trade.UserTrade;
import org.knowm.xchange.dto.trade.UserTrades;

public final class BithumbAdapters {
  public static final String SEARCH_BUY = "1";
  public static final String SEARCH_SELL = "2";

  /** private Constructor */
  private BithumbAdapters() {}

  public static OrderBook adaptOrderBook(BithumbOrderbook orderbook) {

    final CurrencyPair currencyPair =
        new CurrencyPair(orderbook.getOrderCurrency(), orderbook.getPaymentCurrency());

    return new OrderBook(
        new Date(orderbook.getTimestamp()),
        createOrder(currencyPair, orderbook.getAsks(), Order.OrderType.ASK),
        createOrder(currencyPair, orderbook.getBids(), Order.OrderType.BID));
  }

  private static List createOrder(
      CurrencyPair currencyPair, List orders, Order.OrderType orderType) {
    return orders.stream()
        .map(order -> createOrder(currencyPair, orderType, order.getQuantity(), order.getPrice()))
        .collect(Collectors.toList());
  }

  private static LimitOrder createOrder(
      CurrencyPair currencyPair,
      Order.OrderType orderType,
      BigDecimal originalAmount,
      BigDecimal limitPrice) {
    return new LimitOrder(orderType, originalAmount, currencyPair, "", null, limitPrice);
  }

  public static AccountInfo adaptAccountInfo(BithumbAccount account, BithumbBalance balance) {

    List balances = new ArrayList<>();
    balances.add(
        new Balance(
            Currency.KRW, balance.getTotalKrw(), balance.getAvailableKrw(), balance.getInUseKrw()));

    for (String currency : balance.getCurrencies()) {
      final Balance xchangeBalance =
          new Balance(
              Currency.getInstance(currency),
              balance.getTotal(currency),
              balance.getAvailable(currency),
              balance.getFrozen(currency));
      balances.add(xchangeBalance);
    }
    return new AccountInfo(null, account.getTradeFee(), Wallet.Builder.from(balances).build());
  }

  public static Ticker adaptTicker(BithumbTicker bithumbTicker, CurrencyPair currencyPair) {
    return new Ticker.Builder()
        .currencyPair(currencyPair)
        .ask(bithumbTicker.getSellPrice())
        .bid(bithumbTicker.getBuyPrice())
        .high(bithumbTicker.getMaxPrice())
        .low(bithumbTicker.getMinPrice())
        .last(bithumbTicker.getClosingPrice())
        .open(bithumbTicker.getOpeningPrice())
        .vwap(bithumbTicker.getAveragePrice())
        .volume(bithumbTicker.getUnitsTraded())
        .timestamp(new Date(bithumbTicker.getDate()))
        .build();
  }

  public static List adaptTickers(BithumbTickersReturn bithumbTickers) {
    return bithumbTickers.getTickers().entrySet().stream()
        .map(
            tickerEntry -> {
              final CurrencyPair currencyPair =
                  new CurrencyPair(tickerEntry.getKey(), Currency.KRW.getCurrencyCode());
              return adaptTicker(tickerEntry.getValue(), currencyPair);
            })
        .collect(Collectors.toList());
  }

  public static Trades adaptTransactions(
      List bithumbTrades, CurrencyPair currencyPair) {
    final List trades =
        bithumbTrades.stream()
            .map(trade -> adaptTransactionHistory(trade, currencyPair))
            .collect(Collectors.toList());
    return new Trades(trades);
  }

  public static Trade adaptTransactionHistory(
      BithumbTransactionHistory trade, CurrencyPair currencyPair) {

    return new Trade.Builder()
        .id(String.valueOf(trade.getTimestamp().getTime()))
        .instrument(currencyPair)
        .originalAmount(trade.getUnitsTraded())
        .price(trade.getPrice())
        .type(adaptOrderType(trade.getType()))
        .timestamp(trade.getTimestamp())
        .build();
  }

  private static Order.OrderType adaptOrderType(OrderType orderType) {
    return orderType == OrderType.bid ? Order.OrderType.BID : Order.OrderType.ASK;
  }

  public static OpenOrders adaptOrders(List bithumbOrders) {
    final List orders =
        bithumbOrders.stream().map(BithumbAdapters::adaptOrder).collect(Collectors.toList());
    return new OpenOrders(orders);
  }

  public static LimitOrder adaptOrder(BithumbOrder order) {
    final CurrencyPair currencyPair =
        adaptCurrencyPair(order.getOrderCurrency(), order.getPaymentCurrency());
    final Order.OrderType orderType = adaptOrderType(order.getType());

    Order.OrderStatus status = Order.OrderStatus.UNKNOWN;
    if (order.getUnitsRemaining().compareTo(order.getUnits()) == 0) {
      status = Order.OrderStatus.NEW;
    } else if (order.getUnitsRemaining().compareTo(BigDecimal.ZERO) == 0) {
      status = Order.OrderStatus.FILLED;
    } else {
      status = Order.OrderStatus.PARTIALLY_FILLED;
    }

    return new LimitOrder.Builder(orderType, currencyPair)
        .id(String.valueOf(order.getOrderId()))
        .limitPrice(order.getPrice())
        .originalAmount(order.getUnits())
        .remainingAmount(order.getUnitsRemaining())
        .orderStatus(status)
        .timestamp(new Date(order.getOrderDate() / 1000L))
        .build();
  }

  public static UserTrades adaptUserTrades(
      List transactions, CurrencyPair currencyPair) {
    final List userTrades =
        transactions.stream()
            .filter(BithumbUserTransaction::isBuyOrSell)
            .map(transaction -> adaptUserTrade(transaction, currencyPair))
            .collect(Collectors.toList());
    return new UserTrades(userTrades, Trades.TradeSortType.SortByTimestamp);
  }

  private static UserTrade adaptUserTrade(
      BithumbUserTransaction bithumbTransaction, CurrencyPair currencyPair) {

    return UserTrade.builder()
        .currencyPair(currencyPair)
        .originalAmount(bithumbTransaction.getUnits())
        .type(adaptTransactionSearch(bithumbTransaction.getSearch()))
        .feeAmount(bithumbTransaction.getFee())
        .feeCurrency(currencyPair.counter)
        .price(bithumbTransaction.getPrice())
        .timestamp(new Date(bithumbTransaction.getTransferDate() / 1000L))
        .build();
  }

  public static Order adaptOrderDetail(BithumbOrderDetail order, String id) {
    final CurrencyPair currencyPair =
        adaptCurrencyPair(order.getOrderCurrency(), order.getPaymentCurrency());
    final Order.OrderType orderType = adaptOrderType(order.getType());
    Order.OrderStatus status = adaptStatus(order.getOrderStatus());

    BigDecimal fees =
        order.getContract().stream()
            .map(BithumbOrderDetail.Contract::getFee)
            .reduce(BigDecimal.ZERO, BigDecimal::add);

    BigDecimal cumulative =
        order.getContract().stream()
            .map(BithumbOrderDetail.Contract::getUnits)
            .reduce(BigDecimal.ZERO, BigDecimal::add);

    BigDecimal averagePrice =
        cumulative.compareTo(BigDecimal.ZERO) != 0
            ? order.getContract().stream()
                .map(contract -> contract.getUnits().multiply(contract.getPrice()))
                .reduce(BigDecimal.ZERO, BigDecimal::add)
                .divide(cumulative, MathContext.DECIMAL32)
            : null;

    if (order.getOrderPrice() == null) {
      return new MarketOrder.Builder(orderType, currencyPair)
          .id(id)
          .orderStatus(status)
          .originalAmount(order.getOrderQty())
          .cumulativeAmount(cumulative)
          .averagePrice(averagePrice)
          .fee(fees)
          .build();
    } else {
      return new LimitOrder.Builder(orderType, currencyPair)
          .id(id)
          .limitPrice(order.getOrderPrice())
          .orderStatus(status)
          .originalAmount(order.getOrderQty())
          .cumulativeAmount(cumulative)
          .averagePrice(averagePrice)
          .fee(fees)
          .build();
    }
  }

  private static Order.OrderType adaptTransactionSearch(String search) {
    switch (search) {
      case SEARCH_BUY:
        return Order.OrderType.BID;
      case SEARCH_SELL:
        return Order.OrderType.ASK;
      default:
        return null;
    }
  }

  public enum OrderType {
    bid,
    ask
  }

  private static Order.OrderStatus adaptStatus(String orderStatus) {
    switch (orderStatus) {
      case "Pending":
        return Order.OrderStatus.NEW;
      case "Completed":
        return Order.OrderStatus.FILLED;
      case "P":
        return Order.OrderStatus.PARTIALLY_FILLED;
      case "Cancel":
        return Order.OrderStatus.CANCELED;
      default:
        return Order.OrderStatus.UNKNOWN;
    }
  }

  public static CurrencyPair adaptCurrencyPair(String orderCurrency, String paymentCurrency) {
    return new CurrencyPair(orderCurrency, paymentCurrency);
  }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy