Example #1
0
def main(
    pair: str,
    depth: int,
    theta: float,
    window_size: int,
    sleep_seconds: int,
    position_size: float,
):
    """
    Load and log price information from kraken
    """

    sobi_strategy = SobiStrategy(window_size=window_size,
                                 theta=theta,
                                 depth=depth,
                                 position_size=position_size)
    backtester = Backtest()
    data_center = DataCenter(pair=pair)

    while True:
        # query latest data from exchange
        market_state = data_center.get_market_data()

        # update indicators and signals
        sobi_strategy.update_market_state(current_state=market_state)
        desired_position = sobi_strategy.desired_position

        # create orders and calculate pnl
        backtester.update_market_state(market_state)
        backtester.rebalance_position(desired_position)
        pnl = backtester.get_current_profit()
        last_order = backtester.get_last_order()

        # log output to console
        log_info = dict(
            time_rfc=market_state["time"],
            midprice=market_state["order_book"].midprice,
            best_bid=market_state["order_book"].best_bid,
            best_ask=market_state["order_book"].best_ask,
            **sobi_strategy.indicators,
            **sobi_strategy.signals,
            last_order=last_order,
            pnl=pnl,
        )
        log_msg = ut.get_log_msg(log_info)
        logging.info(log_msg)

        # conform to krakens call rate limit
        time.sleep(sleep_seconds)
Example #2
0
def run_iteration(pair: str, strategy: Strategy, engine: Backtest,
                  data_center: DataCenter):
    """
    Run one round trip
    --> Gather and updat data
    --> Recalculate strategy indicators and signals
    --> rebalance position if necessary
    """

    # query latest data from exchange
    market_state = data_center.get_market_data()

    # update indicators and signals
    strategy.update_market_state(current_state=market_state)
    desired_position = strategy.desired_position

    # create orders and calculate pnl
    engine.update_market_state(market_state)
    engine.rebalance_position(desired_position)
    pnl = engine.get_current_profit()
    last_order = engine.get_last_order()

    # log output to console
    log_info = dict(
        time_rfc=market_state["time"],
        midprice=market_state["order_book"].midprice,
        best_bid=market_state["order_book"].best_bid,
        best_ask=market_state["order_book"].best_ask,
        **strategy.indicators,
        current_signal=strategy.trade_signal,
        last_order=last_order,
        pnl=pnl,
    )
    log_msg = ut.get_log_msg(log_info)
    logging.info(log_msg)

    # conform to krakens call rate limit
    time.sleep(strategy.sleep_seconds)
Example #3
0
def main(
    payload: dict,
    window_size: int,
    adx_threshold: int,
    sleep_seconds: int,
    position_size: float,
):
    """
    Load and log price information from kraken
    """

    trend_strategy = TrendStrategy(window_size=window_size,
                                   adx_threshold=adx_threshold)
    backtester = Backtest()

    while True:

        # krakens server time
        server_time_rfc, server_time_unix = kraken.get_server_time()

        # last 720 open high low close periods
        ohlc: np.array = kraken.get_ohlc(payload, interval=1)
        _, bids, asks = kraken.get_orderbook(payload)
        best_bid, best_ask, midprice = ut.calc_midprice(bids, asks)

        market_state = dict(
            time=server_time_unix,
            ohlc=ohlc,
            best_bid=best_bid,
            best_ask=best_ask,
            midprice=midprice,
        )

        # check if all data is available -> if not, continue iterations
        # do stuff
        trend_strategy.update_market_state(market_state)
        trend_strategy.update_indicators()
        trend_strategy.update_signals()

        indicators = trend_strategy.get_indicators()
        signals = trend_strategy.get_signals()

        # order routing
        desired_position = signals["current"] * position_size
        backtester.update_market_state(market_state)
        backtester.rebalance_position(desired_position)
        pnl = backtester.get_current_profit()
        last_order = backtester.get_last_order()

        current_state = dict(
            time_rfc=server_time_rfc,
            ohlc=market_state["ohlc"][-1],
            best_bid=best_bid,
            best_ask=best_ask,
            **indicators,
            **signals,
            last_order=last_order,
            pnl=pnl,
        )

        # log output to console
        log_msg = ut.get_log_msg(current_state)
        logging.info(log_msg)

        # conform to krakens call rate limit
        time.sleep(sleep_seconds)