def setUp(self):
self.clock: Clock = Clock(ClockMode.BACKTEST,
start_time=self.start_time,
end_time=self.end_time)
self.order_book_loader: BinanceOrderBookLoaderV2 = BinanceOrderBookLoaderV2(
"BTCUSDT", "BTC", "USDT")
self.order_book: OrderBook = self.order_book_loader.order_book
self.clock.add_iterator(self.order_book_loader)
def main():
# Define the data cache path.
hummingsim.set_data_path(os.path.join(os.environ["PWD"], "data"))
# Define the parameters for the backtest.
start = pd.Timestamp("2019-01-01", tz="UTC")
end = pd.Timestamp("2019-01-02", tz="UTC")
binance_trading_pair = ("ETHUSDT", "ETH", "USDT")
# ddex_trading_pair = ("WETH-DAI", "WETH", "DAI")
binance_market = BacktestMarket()
ddex_market = BacktestMarket()
binance_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001,
AssetType.QUOTE_CURRENCY, 0.001, {})
ddex_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001,
AssetType.QUOTE_CURRENCY, 0.001, {})
binance_loader = BinanceOrderBookLoaderV2(*binance_trading_pair)
#ddex_loader = DDEXOrderBookLoader(*ddex_trading_pair)
binance_market.add_data(binance_loader)
#ddex_market.add_data(ddex_loader)
binance_market.set_quantization_param(
QuantizationParams("ETHUSDT", 5, 3, 5, 3))
#ddex_market.set_quantization_param(QuantizationParams("WETH-DAI", 5, 3, 5, 3))
market_pair = PureMarketPair(*([binance_market] +
list(binance_trading_pair)))
strategy = PureMarketMakingStrategy(
[market_pair],
order_size=50000,
bid_place_threshold=0.003,
ask_place_threshold=0.003,
logging_options=PureMarketMakingStrategy.OPTION_LOG_ALL)
clock = Clock(ClockMode.BACKTEST,
tick_size=60,
start_time=start.timestamp(),
end_time=end.timestamp())
clock.add_iterator(binance_market)
#clock.add_iterator(ddex_market)
clock.add_iterator(strategy)
binance_market.set_balance("ETH", 100000.0)
binance_market.set_balance("USDT", 100000000.0)
ddex_market.set_balance("WETH", 100000.0)
ddex_market.set_balance("DAI", 1000.0)
current = start.timestamp()
step = 60
while current <= end.timestamp():
current += step
clock.backtest_til(current)
print("clock ticked")
binance_loader.close()
def setUp(self):
# self.weth_dai_data = DDEXOrderBookLoader("WETH-DAI", "WETH", "DAI")
self.pair_data = BinanceOrderBookLoaderV2(self.market_name, "ETH", "USDT")
# self.pair_data = HuobiOrderBookLoader(self.market_name, "", "")
self.clock = Clock(ClockMode.BACKTEST, 1.0, self.start.timestamp(), self.end.timestamp())
self.market = BacktestMarket()
# self.market.add_data(self.weth_dai_data)
self.market.add_data(self.pair_data)
self.market.set_balance(self.quote, 200.0)
self.market.set_balance(self.base, 20000.0)
self.clock.add_iterator(self.market)
def main():
# Define the data cache path.
hummingsim.set_data_path(os.path.join(os.environ["PWD"], "data"))
# Define the parameters for the backtest.
start = pd.Timestamp("2018-12-12", tz="UTC")
end = pd.Timestamp("2019-01-12", tz="UTC")
binance_symbol = ("ETHUSDT", "ETH", "USDT")
ddex_symbol = ("WETH-DAI", "WETH", "DAI")
binance_market = BacktestMarket()
ddex_market = BacktestMarket()
binance_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001,
AssetType.QUOTE_CURRENCY, 0.001, {})
ddex_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001,
AssetType.QUOTE_CURRENCY, 0.001, {})
binance_loader = BinanceOrderBookLoaderV2(*binance_symbol)
ddex_loader = DDEXOrderBookLoader(*ddex_symbol)
binance_market.add_data(binance_loader)
ddex_market.add_data(ddex_loader)
binance_market.set_quantization_param(
QuantizationParams("ETHUSDT", 5, 3, 5, 3))
ddex_market.set_quantization_param(
QuantizationParams("WETH-DAI", 5, 3, 5, 3))
market_pair = CrossExchangeMarketPair(*([ddex_market] + list(ddex_symbol) +
[binance_market] +
list(binance_symbol)))
strategy = CrossExchangeMarketMakingStrategy(
[market_pair],
0.003,
logging_options=CrossExchangeMarketMakingStrategy.
OPTION_LOG_MAKER_ORDER_FILLED)
clock = Clock(ClockMode.BACKTEST,
start_time=start.timestamp(),
end_time=end.timestamp())
clock.add_iterator(binance_market)
clock.add_iterator(ddex_market)
clock.add_iterator(strategy)
binance_market.set_balance("ETH", 10.0)
binance_market.set_balance("USDT", 1000.0)
ddex_market.set_balance("WETH", 10.0)
ddex_market.set_balance("DAI", 1000.0)
clock.backtest()
binance_loader.close()
ddex_loader.close()
def binance_printout():
ethusdt_data: BinanceOrderBookLoaderV2 = BinanceOrderBookLoaderV2("ETHUSDT", "ETH", "USDT")
eoseth_data: BinanceOrderBookLoaderV2 = BinanceOrderBookLoaderV2("EOSETH", "EOS", "ETH")
trxeth_data: BinanceOrderBookLoaderV2 = BinanceOrderBookLoaderV2("TRXETH", "TRX", "ETH")
market: Market = BacktestMarket()
market.add_data(ethusdt_data, eoseth_data, trxeth_data)
market.set_balance("ETH", 20.0)
market.set_balance("EOS", 0.0)
market.set_balance("TRX", 0.0)
print("Beginning Balance:", market.get_all_balances())
start: pd.Timestamp = pd.Timestamp("2018-12-03", tz="UTC")
end: pd.Timestamp = pd.Timestamp("2018-12-04", tz="UTC")
clock: Clock = Clock(ClockMode.BACKTEST, 600.0, start.timestamp(), end.timestamp())
#clock: Clock = Clock(ClockMode.BACKTEST, 1.0, start.timestamp(), end.timestamp())
print_out_strategy: PrintOutStrategy2 = PrintOutStrategy2(market)
clock.add_iterator(market)
clock.add_iterator(print_out_strategy)
clock.backtest()
print("End Balance:", market.get_all_balances())
ethusdt_data.close()
eoseth_data.close()
trxeth_data.close()
from hummingsim.backtest.market_config import (MarketConfig, AssetType)
from hummingbot.strategy.arbitrage import (ArbitrageStrategy,
ArbitrageMarketPair)
# Define the data cache path.
hummingsim.set_data_path(os.path.join(os.environ["PWD"], "data"))
# Define the parameters for the backtest.
start = pd.Timestamp("2018-12-21-00:29:06", tz="UTC")
end = pd.Timestamp("2019-12-24-00:43:00", tz="UTC")
binance_trading_pair = ("ETHUSDT", "ETH", "USDT")
ddex_trading_pair = ("WETH-DAI", "WETH", "DAI")
binance_market = BacktestMarket()
ddex_market = BacktestMarket()
binance_loader = BinanceOrderBookLoaderV2(*binance_trading_pair)
ddex_loader = DDEXOrderBookLoader(*ddex_trading_pair)
binance_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001,
AssetType.QUOTE_CURRENCY, 0.001, {})
ddex_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001,
AssetType.QUOTE_CURRENCY, 0.001, {})
binance_market.add_data(binance_loader)
ddex_market.add_data(ddex_loader)
binance_market.set_quantization_param(QuantizationParams(
"ETHUSDT", 5, 3, 5, 3))
ddex_market.set_quantization_param(QuantizationParams("WETH-DAI", 5, 3, 5, 3))
market_pair1 = ArbitrageMarketPair(*([ddex_market] + list(ddex_trading_pair) +
# Define the data cache path.
hummingsim.set_data_path(os.path.join(os.environ["PWD"], "data"))
# Define the parameters for the backtest.
start = pd.Timestamp("2018-12-21-00:29:06", tz="UTC")
end = pd.Timestamp("2019-12-24-00:43:00", tz="UTC")
binance_symbol = ("ETHUSDT", "ETH", "USDT")
ddex_symbol = ("WETH-DAI", "WETH", "DAI")
from hummingbot.strategy.arbitrage import (ArbitrageStrategy,
ArbitrageMarketPair)
binance_market = BacktestMarket()
ddex_market = BacktestMarket()
binance_loader = BinanceOrderBookLoaderV2(*binance_symbol)
ddex_loader = DDEXOrderBookLoader(*ddex_symbol)
binance_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001,
AssetType.QUOTE_CURRENCY, 0.001, {})
ddex_market.config = MarketConfig(AssetType.BASE_CURRENCY, 0.001,
AssetType.QUOTE_CURRENCY, 0.001, {})
binance_market.add_data(binance_loader)
ddex_market.add_data(ddex_loader)
binance_market.set_quantization_param(QuantizationParams(
"ETHUSDT", 5, 3, 5, 3))
ddex_market.set_quantization_param(QuantizationParams("WETH-DAI", 5, 3, 5, 3))
market_pair1 = ArbitrageMarketPair(*([ddex_market] + list(ddex_symbol) +