Hummingbot Scripts

README.md

generate-volume.py

This script can be used with Hummingbot to:

1- Download latest books from specified exchange,

2- Subtrct/add delta from latest buy/sell,

3- Sell back based on order amount,

The aim is to see if this is a zero-sum game.

How to Use

You need API keys and stuf like that, but basically, let's say we wish to test this on Gate.io:

1- wget the scipt:

wget -qO- https://gist.githubusercontent.com/Chubek/11bdda35674af82cc3e9bc381bf9e465/raw/ab04056b1d8d2cd367beeed8f6eb1092622cf049/generate-volume.py > volume_generate.py

then:

from volume_generate import VolumeGenerateStrategy
from hummingbot.connector.exchange.gate_io.gate_io_exchange import GateIoExchange

gate_io = GateIoExchange(api_key="your_gateio_api_key", secret_key="your_gateio_secret_key")

exchanges = {"gate_io": gate_io}
trading_pair = "CHER-USDT"
delta = 0.01 
order_amount = 10 

volume_generate_strategy = VolumeGenerateStrategy(exchanges=exchanges, trading_pair=trading_pair, delta=delta, order_amount=order_amount)

volume_generate_strategy.start()

fix-discrepencies.py

This scripts fills in the discrepencies in the market. If a limit sell order is smaller than the price paid, it will fill it. Basically an arbitrage simulator.

How to Use

You need API keys and stuf like that, but basically, let's say we wish to test this on Gate.io:

1- wget the scipt:

wget -qO- h[ttps://gist.githubusercontent.com/Chubek/11bdda35674af82cc3e9bc381bf9e465/raw/ab04056b1d8d2cd367beeed8f6eb1092622cf049/generate-volume.py](https://gist.githubusercontent.com/Chubek/11bdda35674af82cc3e9bc381bf9e465/raw/d0ba87a2df09a18d281180ac49e11dcfca16be48/fix-discrepencies.py) > fix-discrepencies.py

2- Identical to the last one. Except you need two exchanges.

cross-check.py

It's an extension of check-discrepencies.py.

cross-check.py

from hummingbot.core.data_type.limit_order import LimitOrder
from hummingbot.core.data_type.order_book import OrderBook
from hummingbot.strategy.strategy_base import StrategyBase
from hummingbot.core.event.events import MarketEvent, BuyOrderCompletedEvent, SellOrderCompletedEvent
from hummingbot.core.event.event_listener import EventListener
from hummingbot.core.data_type.order_book_tracker import OrderBookTracker
from hummingbot.connector.exchange_base import ExchangeBase

class CrossMarketMatch(StrategyBase):
    def __init__(self, exchange_a: ExchangeBase, exchange_b: ExchangeBase, trading_pair, fee):
        super().__init__()
        self.exchange_a = exchange_a
        self.exchange_b = exchange_b
        self.trading_pair = trading_pair
        self.fee = fee
        self.order_books = {}
        self.combined_order_book = None
        self.add_event_listeners()

    def init(self):        
        self.exchange_a.connect()
        self.exchange_b.connect()
        self.log_info("Arbitrage Simulator initialized and starting...")

    def add_event_listeners(self):
        self.exchange_a.add_listener(MarketEvent.OrderBookUpdated, EventListener(self.on_order_book_updated))
        self.exchange_b.add_listener(MarketEvent.OrderBookUpdated, EventListener(self.on_order_book_updated))
        self.exchange_a.add_listener(MarketEvent.BuyOrderCompleted, EventListener(self.did_fill_buy_order))
        self.exchange_b.add_listener(MarketEvent.SellOrderCompleted, EventListener(self.did_fill_sell_order))

    def on_order_book_updated(self, event):
        self.order_books[event.exchange.name] = event.content
        self.update_combined_order_book()

    def update_combined_order_book(self):        
        all_bids = {}
        all_asks = {}

        for book in self.order_books.values():
            for bid in book.bids:
                price = bid.price
                size = bid.size
                all_bids[price] = all_bids.get(price, 0) + size
            
            for ask in book.asks:
                price = ask.price
                size = ask.size
                all_asks[price] = all_asks.get(price, 0) + size

        
        self.combined_order_book = OrderBook(bids=all_bids, asks=all_asks)
        self.check_arbitrage_opportunity()

    def check_arbitrage_opportunity(self):
        if not self.combined_order_book:
            return

        best_bid = max(self.combined_order_book.bids, key=lambda x: self.combined_order_book.bids[x])
        best_ask = min(self.combined_order_book.asks, key=lambda x: self.combined_order_book.asks[x])

        if self.combined_order_book.bids[best_bid] > self.combined_order_book.asks[best_ask]:
            profit_potential = (best_bid - best_ask) - self.fee
            if profit_potential > 0:
                self.execute_trades(best_ask, best_bid, self.combined_order_book.asks[best_ask])

    def execute_trades(self, ask_price, bid_price, volume):        
        self.exchange_b.buy(self.trading_pair, ask_price, volume)
        self.exchange_a.sell(self.trading_pair, bid_price, volume)
        self.log_info(f"Executed arbitrage trade: Buy on {self.exchange_b.name}, Sell on {self.exchange_a.name}")

    def did_fill_buy_order(self, event):        
        self.log_info(f"Buy order filled on {event.exchange.name}")

    def did_fill_sell_order(self, event):        
        self.log_info(f"Sell order filled on {event.exchange.name}")

    def stop(self):        
        self.exchange_a.disconnect()
        self.exchange_b.disconnect()
        self.log_info("Stopping the Arbitrage Simulator strategy.")

fix-discrepencies.py

from hummingbot.core.data_type.limit_order import LimitOrder
from hummingbot.core.data_type.order_book import OrderBook
from hummingbot.strategy.strategy_base import StrategyBase
from hummingbot.core.event.events import MarketEvent, BuyOrderCompletedEvent, SellOrderCompletedEvent
from hummingbot.core.event.event_listener import EventListener
from hummingbot.core.data_type.order_book_tracker import OrderBookTracker
from hummingbot.connector.exchange_base import ExchangeBase


class ArbitrageSimulator(StrategyBase):
    def __init__(self, exchange_a: ExchangeBase, exchange_b: ExchangeBase, trading_pair, fee):
        super().__init__()
        self.exchange_a = exchange_a
        self.exchange_b = exchange_b
        self.trading_pair = trading_pair
        self.fee = fee
        self.order_books = {
            self.exchange_a.name: None,
            self.exchange_b.name: None
        }

        self.add_event_listeners()

    def init(self):
        self.exchange_a.connect()
        self.exchange_b.connect()
        self.log_info("Arbitrage Simulator initialized and starting...")

    def add_event_listeners(self):
        self.exchange_a.add_listener(MarketEvent.OrderBookUpdated, EventListener(self.on_order_book_updated))
        self.exchange_b.add_listener(MarketEvent.OrderBookUpdated, EventListener(self.on_order_book_updated))
        self.exchange_a.add_listener(MarketEvent.BuyOrderCompleted, EventListener(self.did_fill_buy_order))
        self.exchange_b.add_listener(MarketEvent.SellOrderCompleted, EventListener(self.did_fill_sell_order))

    def on_order_book_updated(self, event):
        self.order_books[event.exchange.name] = event.content
        self.check_arbitrage_opportunity()

    def check_arbitrage_opportunity(self):
        order_book_a = self.order_books[self.exchange_a.name]
        order_book_b = self.order_books[self.exchange_b.name]

        if not order_book_a or not order_book_b:
            return

        best_bid_a = order_book_a.best_bid
        best_ask_b = order_book_b.best_ask

        if best_bid_a and best_ask_b and best_bid_a.price > best_ask_b.price:
            profit_potential = (best_bid_a.price - best_ask_b.price) - self.fee
            if profit_potential > 0:
                self.execute_trades(best_ask_b, best_bid_a)

    def execute_trades(self, ask_order, bid_order):
        buy_volume = min(ask_order.size, bid_order.size)
        self.exchange_b.buy(self.trading_pair, ask_order.price, buy_volume)
        self.exchange_a.sell(self.trading_pair, bid_order.price, buy_volume)
        self.log_info(f"Executed arbitrage trade: Buy on {self.exchange_b.name}, Sell on {self.exchange_a.name}")

    def did_fill_buy_order(self, event):
        self.log_info(f"Buy order filled on {event.exchange.name}")

    def did_fill_sell_order(self, event):
        self.log_info(f"Sell order filled on {event.exchange.name}")

    def stop(self):
        self.exchange_a.disconnect()
        self.exchange_b.disconnect()
        self.log_info("Stopping the Arbitrage Simulator strategy.")

generate-volume.py

from hummingbot.strategy.strategy_base import StrategyBase
from hummingbot.core.data_type.limit_order import LimitOrder
from hummingbot.core.data_type.order_book import OrderBook
from hummingbot.core.utils.async_utils import safe_ensure_future
from hummingbot.core.event.events import MarketEvent, BuyOrderCompletedEvent, SellOrderCompletedEvent, MarketEvent, OrderBookTradeEvent, OrderFilledEvent
from hummingbot.connector.exchange_base import ExchangeBase
from hummingbot.core.event.event_listener import EventListener
import asyncio


class VolumeGenerateStrategy(StrategyBase):
    def __init__(self, exchanges, trading_pair: str, delta: float, order_amount: float):
        super().__init__()
        self.trading_pair = trading_pair
        self.exchanges = exchanges
        self.delta = delta
        self.order_amount = order_amount

    def on_tick(self):
        for exchange_name, exchange in self.exchanges.items():
            safe_ensure_future(self.execute_trades_on_exchange(exchange, exchange_name))

    async def execute_trades_on_exchange(self, exchange: ExchangeBase, exchange_name: str):
        order_book = await exchange.get_order_book(self.trading_pair)
        top_buy = order_book.get_price_for_volume(True, 1).price
        top_sell = order_book.get_price_for_volume(False, 1).price
        buy_price = top_buy - self.delta
        sell_price = top_sell + self.delta
        self.logger().info(f"Placing orders on {exchange_name}: Buy at {buy_price}, Sell at {sell_price}")
        await exchange.place_limit_buy_order(self.trading_pair, buy_price, self.order_amount)
        await exchange.place_limit_sell_order(self.trading_pair, sell_price, self.order_amount)

        def start(self):
        self.logger().info("Starting Volume Generate Strategy")

        self.start_tick_loop(5.0)

        for exchange_name, exchange in self.exchanges.items():
            listener = EventListener()
            listener.add_callback(MarketEvent.OrderBookTrade, self.handle_trade_event)
            listener.add_callback(MarketEvent.OrderFilled, self.handle_order_filled)
            exchange.add_listener(listener)
            self._listeners.append(listener)

        self.logger().info("Volume Generate Strategy started successfully")

    def stop(self):

        self.logger().info("Stopping Volume Generate Strategy")
        for listener in self._listeners:
            listener.remove_all_callbacks()
        self._listeners.clear()
        self.stop_tick_loop()

    def on_tick(self):

        self.logger().info("Processing tick for Volume Generate Strategy")
        for exchange_name, exchange in self.exchanges.items():
            asyncio.ensure_future(self.execute_trades_on_exchange(exchange, exchange_name))

    def handle_trade_event(self, event: OrderBookTradeEvent):
        self.logger().info(f"Trade event received on {event.exchange}: {event.amount} at {event.price}")

    def handle_order_filled(self, event: OrderFilledEvent):
        self.logger().info(f"Order filled on {event.exchange}: {event.order_id} for {event.amount}")