class ZrxMarketMakerKeeper:
"""Keeper acting as a market maker on any 0x exchange implementing the Standard 0x Relayer API V0."""
logger = logging.getLogger()
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='0x-market-maker-keeper')
parser.add_argument("--rpc-host",
type=str,
default="localhost",
help="JSON-RPC host (default: `localhost')")
parser.add_argument("--rpc-port",
type=int,
default=8545,
help="JSON-RPC port (default: `8545')")
parser.add_argument("--rpc-timeout",
type=int,
default=10,
help="JSON-RPC timeout (in seconds, default: 10)")
parser.add_argument(
"--eth-from",
type=str,
required=True,
help="Ethereum account from which to send transactions")
parser.add_argument(
"--exchange-address",
type=str,
required=True,
help="Ethereum address of the 0x Exchange contract")
parser.add_argument("--relayer-api-server",
type=str,
required=True,
help="Address of the 0x Relayer API")
parser.add_argument(
"--relayer-per-page",
type=int,
default=100,
help=
"Number of orders to fetch per one page from the 0x Relayer API (default: 100)"
)
parser.add_argument("--buy-token-address",
type=str,
required=True,
help="Ethereum address of the buy token")
parser.add_argument("--sell-token-address",
type=str,
required=True,
help="Ethereum address of the sell token")
parser.add_argument("--config",
type=str,
required=True,
help="Bands configuration file")
parser.add_argument("--price-feed",
type=str,
required=True,
help="Source of price feed")
parser.add_argument(
"--price-feed-expiry",
type=int,
default=120,
help="Maximum age of the price feed (in seconds, default: 120)")
parser.add_argument("--spread-feed",
type=str,
help="Source of spread feed")
parser.add_argument(
"--spread-feed-expiry",
type=int,
default=3600,
help="Maximum age of the spread feed (in seconds, default: 3600)")
parser.add_argument(
"--order-expiry",
type=int,
required=True,
help="Expiration time of created orders (in seconds)")
parser.add_argument(
"--order-expiry-threshold",
type=int,
default=0,
help=
"How long before order expiration it is considered already expired (in seconds)"
)
parser.add_argument(
"--min-eth-balance",
type=float,
default=0,
help="Minimum ETH balance below which keeper will cease operation")
parser.add_argument(
'--cancel-on-shutdown',
dest='cancel_on_shutdown',
action='store_true',
help="Whether should cancel all open orders on keeper shutdown")
parser.add_argument("--gas-price",
type=int,
default=0,
help="Gas price (in Wei)")
parser.add_argument(
"--smart-gas-price",
dest='smart_gas_price',
action='store_true',
help=
"Use smart gas pricing strategy, based on the ethgasstation.info feed"
)
parser.add_argument("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3(
HTTPProvider(
endpoint_uri=
f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}",
request_kwargs={"timeout": self.arguments.rpc_timeout}))
self.web3.eth.defaultAccount = self.arguments.eth_from
self.our_address = Address(self.arguments.eth_from)
self.token_buy = ERC20Token(web3=self.web3,
address=Address(
self.arguments.buy_token_address))
self.token_sell = ERC20Token(web3=self.web3,
address=Address(
self.arguments.sell_token_address))
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.bands_config = ReloadableConfig(self.arguments.config)
self.gas_price = GasPriceFactory().create_gas_price(self.arguments)
self.price_feed = PriceFeedFactory().create_price_feed(self.arguments)
self.spread_feed = create_spread_feed(self.arguments)
self.history = History()
self.zrx_exchange = ZrxExchange(web3=self.web3,
address=Address(
self.arguments.exchange_address))
self.zrx_relayer_api = ZrxRelayerApi(
exchange=self.zrx_exchange,
api_server=self.arguments.relayer_api_server)
self.placed_orders = []
def main(self):
with Lifecycle(self.web3) as lifecycle:
lifecycle.initial_delay(10)
lifecycle.on_startup(self.startup)
lifecycle.every(15, self.synchronize_orders)
lifecycle.on_shutdown(self.shutdown)
def startup(self):
self.approve()
@retry(delay=5, logger=logger)
def shutdown(self):
if self.arguments.cancel_on_shutdown:
self.cancel_orders(self.our_orders())
def approve(self):
self.zrx_exchange.approve([self.token_sell, self.token_buy],
directly(gas_price=self.gas_price))
def our_total_balance(self, token: ERC20Token) -> Wad:
return token.balance_of(self.our_address)
def our_orders(self) -> list:
api_orders = self.zrx_relayer_api.get_orders_by_maker(
self.our_address, self.arguments.relayer_per_page)
all_orders = list(set(self.placed_orders + api_orders))
return self.remove_old_orders(all_orders)
def remove_old_orders(self, orders: list) -> list:
current_timestamp = int(time.time())
orders = list(
filter(
lambda order: order.expiration > current_timestamp - self.
arguments.order_expiry_threshold, orders))
orders = list(
filter(
lambda order: self.zrx_exchange.get_unavailable_buy_amount(
order) < order.buy_amount, orders))
return orders
def our_sell_orders(self, our_orders: list) -> list:
return list(
filter(
lambda order: order.buy_token == self.token_buy.address and
order.pay_token == self.token_sell.address, our_orders))
def our_buy_orders(self, our_orders: list) -> list:
return list(
filter(
lambda order: order.buy_token == self.token_sell.address and
order.pay_token == self.token_buy.address, our_orders))
def synchronize_orders(self):
if eth_balance(self.web3, self.our_address) < self.min_eth_balance:
self.logger.warning(
"Keeper ETH balance below minimum. Cancelling all orders.")
self.cancel_orders(self.our_orders())
return
bands = Bands(self.bands_config, self.spread_feed, self.history)
our_orders = self.our_orders()
target_price = self.price_feed.get_price()
# Cancel orders
cancellable_orders = bands.cancellable_orders(
our_buy_orders=self.our_buy_orders(our_orders),
our_sell_orders=self.our_sell_orders(our_orders),
target_price=target_price)
if len(cancellable_orders) > 0:
self.cancel_orders(cancellable_orders)
return
# Balances returned by `our_total_balance` still contain amounts "locked"
# by currently open orders, so we need to explicitly subtract these amounts.
our_buy_balance = self.our_total_balance(
self.token_buy) - Bands.total_amount(
self.our_buy_orders(our_orders))
our_sell_balance = self.our_total_balance(
self.token_sell) - Bands.total_amount(
self.our_sell_orders(our_orders))
# Place new orders
self.place_orders(
bands.new_orders(our_buy_orders=self.our_buy_orders(our_orders),
our_sell_orders=self.our_sell_orders(our_orders),
our_buy_balance=our_buy_balance,
our_sell_balance=our_sell_balance,
target_price=target_price)[0])
def cancel_orders(self, orders):
synchronize([
self.zrx_exchange.cancel_order(order).transact_async(
gas_price=self.gas_price) for order in orders
])
def place_orders(self, new_orders):
for new_order in new_orders:
pay_token = self.token_sell if new_order.is_sell else self.token_buy
buy_token = self.token_buy if new_order.is_sell else self.token_sell
zrx_order = self.zrx_exchange.create_order(
pay_token=pay_token.address,
pay_amount=new_order.pay_amount,
buy_token=buy_token.address,
buy_amount=new_order.buy_amount,
expiration=int(time.time()) + self.arguments.order_expiry)
zrx_order = self.zrx_relayer_api.calculate_fees(zrx_order)
zrx_order = self.zrx_exchange.sign_order(zrx_order)
if self.zrx_relayer_api.submit_order(zrx_order):
self.placed_orders = self.remove_old_orders(self.placed_orders)
self.placed_orders.append(zrx_order)
class RadarRelayMarketMakerKeeper:
"""Keeper acting as a market maker on RadarRelay, on the WETH/SAI pair."""
logger = logging.getLogger()
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='radarrelay-market-maker-keeper')
parser.add_argument("--rpc-host",
type=str,
default="localhost",
help="JSON-RPC host (default: `localhost')")
parser.add_argument("--rpc-port",
type=int,
default=8545,
help="JSON-RPC port (default: `8545')")
parser.add_argument("--rpc-timeout",
type=int,
default=10,
help="JSON-RPC timeout (in seconds, default: 10)")
parser.add_argument(
"--eth-from",
type=str,
required=True,
help="Ethereum account from which to send transactions")
parser.add_argument("--tub-address",
type=str,
required=True,
help="Ethereum address of the Tub contract")
parser.add_argument(
"--exchange-address",
type=str,
required=True,
help="Ethereum address of the 0x Exchange contract")
parser.add_argument("--weth-address",
type=str,
required=True,
help="Ethereum address of the WETH token")
parser.add_argument("--relayer-api-server",
type=str,
required=True,
help="Address of the 0x Relayer API")
parser.add_argument("--config",
type=str,
required=True,
help="Buy/sell bands configuration file")
parser.add_argument(
"--price-feed",
type=str,
help=
"Source of price feed. Tub price feed will be used if not specified"
)
parser.add_argument(
"--price-feed-expiry",
type=int,
default=120,
help="Maximum age of non-Tub price feed (in seconds, default: 120)"
)
parser.add_argument(
"--order-expiry",
type=int,
required=True,
help="Expiration time of created orders (in seconds)")
parser.add_argument(
"--order-expiry-threshold",
type=int,
default=0,
help=
"Order expiration time at which order is considered already expired (in seconds)"
)
parser.add_argument(
"--min-eth-balance",
type=float,
default=0,
help=
"Minimum ETH balance below which keeper with either terminate or not start at all"
)
parser.add_argument(
'--cancel-on-shutdown',
dest='cancel_on_shutdown',
action='store_true',
help=
"Whether should cancel all open orders on RadarRelay on keeper shutdown"
)
parser.add_argument("--gas-price",
type=int,
default=0,
help="Gas price (in Wei)")
parser.add_argument(
"--gas-price-increase",
type=int,
help="Gas price increase (in Wei) if no confirmation within"
" `--gas-price-increase-every` seconds")
parser.add_argument(
"--gas-price-increase-every",
type=int,
default=120,
help="Gas price increase frequency (in seconds, default: 120)")
parser.add_argument("--gas-price-max",
type=int,
help="Maximum gas price (in Wei)")
parser.add_argument("--gas-price-file",
type=str,
help="Gas price configuration file")
parser.add_argument(
"--smart-gas-price",
dest='smart_gas_price',
action='store_true',
help=
"Use smart gas pricing strategy, based on the ethgasstation.info feed"
)
parser.add_argument("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3(
HTTPProvider(
endpoint_uri=
f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}",
request_kwargs={"timeout": self.arguments.rpc_timeout}))
self.web3.eth.defaultAccount = self.arguments.eth_from
self.our_address = Address(self.arguments.eth_from)
self.tub = Tub(web3=self.web3,
address=Address(self.arguments.tub_address))
self.vox = Vox(web3=self.web3, address=self.tub.vox())
self.sai = ERC20Token(web3=self.web3, address=self.tub.sai())
self.ether_token = ERC20Token(web3=self.web3,
address=Address(
self.arguments.weth_address))
logging.basicConfig(
format='%(asctime)-15s %(levelname)-8s %(message)s',
level=(logging.DEBUG if self.arguments.debug else logging.INFO))
logging.getLogger('urllib3.connectionpool').setLevel(logging.INFO)
logging.getLogger('requests.packages.urllib3.connectionpool').setLevel(
logging.INFO)
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.bands_config = ReloadableConfig(self.arguments.config)
self.gas_price = GasPriceFactory().create_gas_price(self.arguments)
self.price_feed = PriceFeedFactory().create_price_feed(
self.arguments.price_feed, self.arguments.price_feed_expiry,
self.tub, self.vox)
self.radar_relay = ZrxExchange(web3=self.web3,
address=Address(
self.arguments.exchange_address))
self.radar_relay_api = ZrxRelayerApi(
exchange=self.radar_relay,
api_server=self.arguments.relayer_api_server)
def main(self):
with Lifecycle(self.web3) as lifecycle:
lifecycle.initial_delay(10)
lifecycle.on_startup(self.startup)
lifecycle.every(15, self.synchronize_orders)
lifecycle.on_shutdown(self.shutdown)
def startup(self):
self.approve()
@retry(delay=5, logger=logger)
def shutdown(self):
if self.arguments.cancel_on_shutdown:
self.cancel_orders(self.our_orders())
def approve(self):
"""Approve 0x to access our tokens, so we can sell it on the exchange."""
self.radar_relay.approve(
[self.token_sell(), self.token_buy()],
directly(gas_price=self.gas_price))
def price(self) -> Wad:
return self.price_feed.get_price()
def token_sell(self) -> ERC20Token:
return self.ether_token
def token_buy(self) -> ERC20Token:
return self.sai
def our_balance(self, token: ERC20Token) -> Wad:
return token.balance_of(self.our_address)
def our_orders(self) -> list:
our_orders = self.radar_relay_api.get_orders_by_maker(self.our_address)
current_timestamp = int(time.time())
our_orders = list(
filter(
lambda order: order.expiration > current_timestamp - self.
arguments.order_expiry_threshold, our_orders))
our_orders = list(
filter(
lambda order: self.radar_relay.get_unavailable_buy_amount(
order) < order.buy_amount, our_orders))
return our_orders
def our_sell_orders(self, our_orders: list) -> list:
return list(
filter(
lambda order: order.buy_token == self.token_buy().address and
order.pay_token == self.token_sell().address, our_orders))
def our_buy_orders(self, our_orders: list) -> list:
return list(
filter(
lambda order: order.buy_token == self.token_sell().address and
order.pay_token == self.token_buy().address, our_orders))
def synchronize_orders(self):
"""Update our positions in the order book to reflect keeper parameters."""
if eth_balance(self.web3, self.our_address) < self.min_eth_balance:
self.logger.warning(
"Keeper ETH balance below minimum. Cancelling all orders.")
self.cancel_orders(self.our_orders())
return
bands = Bands(self.bands_config)
our_orders = self.our_orders()
target_price = self.price()
if target_price is None:
self.logger.warning(
"Cancelling all orders as no price feed available.")
self.cancel_orders(our_orders)
return
# Cancel orders
cancellable_orders = bands.cancellable_orders(
our_buy_orders=self.our_buy_orders(our_orders),
our_sell_orders=self.our_sell_orders(our_orders),
target_price=target_price)
if len(cancellable_orders) > 0:
self.cancel_orders(cancellable_orders)
return
# Place new orders
self.create_orders(
bands.new_orders(
our_buy_orders=self.our_buy_orders(our_orders),
our_sell_orders=self.our_sell_orders(our_orders),
our_buy_balance=self.our_balance(self.token_buy()),
our_sell_balance=self.our_balance(self.token_sell()),
target_price=target_price))
def cancel_orders(self, orders):
"""Cancel orders asynchronously."""
synchronize([
self.radar_relay.cancel_order(order).transact_async(
gas_price=self.gas_price) for order in orders
])
def create_orders(self, orders):
"""Create and submit orders synchronously."""
for order in orders:
pay_token = self.token_sell() if order.is_sell else self.token_buy(
)
buy_token = self.token_buy() if order.is_sell else self.token_sell(
)
order = self.radar_relay.create_order(pay_token=pay_token.address,
pay_amount=order.pay_amount,
buy_token=buy_token.address,
buy_amount=order.buy_amount,
expiration=int(time.time()) +
self.arguments.order_expiry)
order = self.radar_relay_api.calculate_fees(order)
order = self.radar_relay.sign_order(order)
self.radar_relay_api.submit_order(order)
class ZrxMarketMakerKeeper:
"""Keeper acting as a market maker on any 0x exchange implementing the Standard 0x Relayer API V0."""
logger = logging.getLogger()
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='0x-market-maker-keeper')
parser.add_argument("--rpc-host", type=str, default="localhost",
help="JSON-RPC host (default: `localhost')")
parser.add_argument("--rpc-port", type=int, default=8545,
help="JSON-RPC port (default: `8545')")
parser.add_argument("--rpc-timeout", type=int, default=10,
help="JSON-RPC timeout (in seconds, default: 10)")
parser.add_argument("--eth-from", type=str, required=True,
help="Ethereum account from which to send transactions")
parser.add_argument("--exchange-address", type=str, required=True,
help="Ethereum address of the 0x Exchange contract")
parser.add_argument("--relayer-api-server", type=str, required=True,
help="Address of the 0x Relayer API")
parser.add_argument("--relayer-per-page", type=int, default=100,
help="Number of orders to fetch per one page from the 0x Relayer API (default: 100)")
parser.add_argument("--buy-token-address", type=str, required=True,
help="Ethereum address of the buy token")
parser.add_argument("--sell-token-address", type=str, required=True,
help="Ethereum address of the sell token")
parser.add_argument("--config", type=str, required=True,
help="Bands configuration file")
parser.add_argument("--price-feed", type=str, required=True,
help="Source of price feed")
parser.add_argument("--price-feed-expiry", type=int, default=120,
help="Maximum age of the price feed (in seconds, default: 120)")
parser.add_argument("--spread-feed", type=str,
help="Source of spread feed")
parser.add_argument("--spread-feed-expiry", type=int, default=3600,
help="Maximum age of the spread feed (in seconds, default: 3600)")
parser.add_argument("--order-history", type=str,
help="Endpoint to report active orders to")
parser.add_argument("--order-history-every", type=int, default=30,
help="Frequency of reporting active orders (in seconds, default: 30)")
parser.add_argument("--order-expiry", type=int, required=True,
help="Expiration time of created orders (in seconds)")
parser.add_argument("--order-expiry-threshold", type=int, default=0,
help="How long before order expiration it is considered already expired (in seconds)")
parser.add_argument("--min-eth-balance", type=float, default=0,
help="Minimum ETH balance below which keeper will cease operation")
parser.add_argument('--cancel-on-shutdown', dest='cancel_on_shutdown', action='store_true',
help="Whether should cancel all open orders on keeper shutdown")
parser.add_argument("--gas-price", type=int, default=0,
help="Gas price (in Wei)")
parser.add_argument("--smart-gas-price", dest='smart_gas_price', action='store_true',
help="Use smart gas pricing strategy, based on the ethgasstation.info feed")
parser.add_argument("--debug", dest='debug', action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3(HTTPProvider(endpoint_uri=f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}",
request_kwargs={"timeout": self.arguments.rpc_timeout}))
self.web3.eth.defaultAccount = self.arguments.eth_from
self.our_address = Address(self.arguments.eth_from)
self.token_buy = ERC20Token(web3=self.web3, address=Address(self.arguments.buy_token_address))
self.token_sell = ERC20Token(web3=self.web3, address=Address(self.arguments.sell_token_address))
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.bands_config = ReloadableConfig(self.arguments.config)
self.gas_price = GasPriceFactory().create_gas_price(self.arguments)
self.price_feed = PriceFeedFactory().create_price_feed(self.arguments)
self.spread_feed = create_spread_feed(self.arguments)
self.order_history_reporter = create_order_history_reporter(self.arguments)
self.history = History()
self.zrx_exchange = ZrxExchange(web3=self.web3, address=Address(self.arguments.exchange_address))
self.zrx_relayer_api = ZrxRelayerApi(exchange=self.zrx_exchange, api_server=self.arguments.relayer_api_server)
self.placed_orders = []
def main(self):
with Lifecycle(self.web3) as lifecycle:
lifecycle.initial_delay(10)
lifecycle.on_startup(self.startup)
lifecycle.every(15, self.synchronize_orders)
lifecycle.on_shutdown(self.shutdown)
def startup(self):
self.approve()
@retry(delay=5, logger=logger)
def shutdown(self):
if self.arguments.cancel_on_shutdown:
self.cancel_orders(self.our_orders())
def approve(self):
self.zrx_exchange.approve([self.token_sell, self.token_buy], directly(gas_price=self.gas_price))
def our_total_balance(self, token: ERC20Token) -> Wad:
return token.balance_of(self.our_address)
def our_orders(self) -> list:
api_orders = self.zrx_relayer_api.get_orders_by_maker(self.our_address, self.arguments.relayer_per_page)
all_orders = list(set(self.placed_orders + api_orders))
return self.remove_old_orders(all_orders)
def remove_old_orders(self, orders: list) -> list:
current_timestamp = int(time.time())
orders = list(filter(lambda order: order.expiration > current_timestamp - self.arguments.order_expiry_threshold, orders))
orders = list(filter(lambda order: self.zrx_exchange.get_unavailable_buy_amount(order) < order.buy_amount, orders))
return orders
def our_sell_orders(self, our_orders: list) -> list:
return list(filter(lambda order: order.buy_token == self.token_buy.address and
order.pay_token == self.token_sell.address, our_orders))
def our_buy_orders(self, our_orders: list) -> list:
return list(filter(lambda order: order.buy_token == self.token_sell.address and
order.pay_token == self.token_buy.address, our_orders))
def synchronize_orders(self):
if eth_balance(self.web3, self.our_address) < self.min_eth_balance:
self.logger.warning("Keeper ETH balance below minimum. Cancelling all orders.")
self.cancel_orders(self.our_orders())
return
bands = Bands(self.bands_config, self.spread_feed, self.history)
our_orders = self.our_orders()
target_price = self.price_feed.get_price()
# Cancel orders
cancellable_orders = bands.cancellable_orders(our_buy_orders=self.our_buy_orders(our_orders),
our_sell_orders=self.our_sell_orders(our_orders),
target_price=target_price)
if len(cancellable_orders) > 0:
self.cancel_orders(cancellable_orders)
return
# Balances returned by `our_total_balance` still contain amounts "locked"
# by currently open orders, so we need to explicitly subtract these amounts.
our_buy_balance = self.our_total_balance(self.token_buy) - Bands.total_amount(self.our_buy_orders(our_orders))
our_sell_balance = self.our_total_balance(self.token_sell) - Bands.total_amount(self.our_sell_orders(our_orders))
# Place new orders
self.place_orders(bands.new_orders(our_buy_orders=self.our_buy_orders(our_orders),
our_sell_orders=self.our_sell_orders(our_orders),
our_buy_balance=our_buy_balance,
our_sell_balance=our_sell_balance,
target_price=target_price)[0])
def cancel_orders(self, orders):
synchronize([self.zrx_exchange.cancel_order(order).transact_async(gas_price=self.gas_price) for order in orders])
def place_orders(self, new_orders):
for new_order in new_orders:
pay_token = self.token_sell if new_order.is_sell else self.token_buy
buy_token = self.token_buy if new_order.is_sell else self.token_sell
zrx_order = self.zrx_exchange.create_order(pay_token=pay_token.address, pay_amount=new_order.pay_amount,
buy_token=buy_token.address, buy_amount=new_order.buy_amount,
expiration=int(time.time()) + self.arguments.order_expiry)
zrx_order = self.zrx_relayer_api.calculate_fees(zrx_order)
zrx_order = self.zrx_exchange.sign_order(zrx_order)
if self.zrx_relayer_api.submit_order(zrx_order):
self.placed_orders = self.remove_old_orders(self.placed_orders)
self.placed_orders.append(zrx_order)
class ZrxMarketMakerKeeper:
"""Keeper acting as a market maker on any 0x exchange implementing the Standard 0x Relayer API V0."""
logger = logging.getLogger()
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='0x-market-maker-keeper')
parser.add_argument("--rpc-host", type=str, default="localhost",
help="JSON-RPC host (default: `localhost')")
parser.add_argument("--rpc-port", type=int, default=8545,
help="JSON-RPC port (default: `8545')")
parser.add_argument("--rpc-timeout", type=int, default=10,
help="JSON-RPC timeout (in seconds, default: 10)")
parser.add_argument("--eth-from", type=str, required=True,
help="Ethereum account from which to send transactions")
parser.add_argument("--exchange-address", type=str, required=True,
help="Ethereum address of the 0x Exchange contract")
parser.add_argument("--relayer-api-server", type=str, required=True,
help="Address of the 0x Relayer API")
parser.add_argument("--relayer-per-page", type=int, default=100,
help="Number of orders to fetch per one page from the 0x Relayer API (default: 100)")
parser.add_argument("--buy-token-address", type=str, required=True,
help="Ethereum address of the buy token")
parser.add_argument("--buy-token-decimals", type=int, default=18,
help="Number of decimals of the buy token")
parser.add_argument("--sell-token-address", type=str, required=True,
help="Ethereum address of the sell token")
parser.add_argument("--sell-token-decimals", type=int, default=18,
help="Number of decimals of the sell token")
parser.add_argument("--config", type=str, required=True,
help="Bands configuration file")
parser.add_argument("--price-feed", type=str, required=True,
help="Source of price feed")
parser.add_argument("--price-feed-expiry", type=int, default=120,
help="Maximum age of the price feed (in seconds, default: 120)")
parser.add_argument("--spread-feed", type=str,
help="Source of spread feed")
parser.add_argument("--spread-feed-expiry", type=int, default=3600,
help="Maximum age of the spread feed (in seconds, default: 3600)")
parser.add_argument("--order-history", type=str,
help="Endpoint to report active orders to")
parser.add_argument("--order-history-every", type=int, default=30,
help="Frequency of reporting active orders (in seconds, default: 30)")
parser.add_argument("--order-expiry", type=int, required=True,
help="Expiration time of created orders (in seconds)")
parser.add_argument("--order-expiry-threshold", type=int, default=0,
help="How long before order expiration it is considered already expired (in seconds)")
parser.add_argument("--use-full-balances", dest='use_full_balances', action='store_true',
help="Do not subtract the amounts locked by current orders from available balances")
parser.add_argument("--min-eth-balance", type=float, default=0,
help="Minimum ETH balance below which keeper will cease operation")
parser.add_argument('--cancel-on-shutdown', dest='cancel_on_shutdown', action='store_true',
help="Whether should cancel all open orders on keeper shutdown")
parser.add_argument("--remember-own-orders", dest='remember_own_orders', action='store_true',
help="Whether should the keeper remember his own submitted orders")
parser.add_argument("--gas-price", type=int, default=0,
help="Gas price (in Wei)")
parser.add_argument("--smart-gas-price", dest='smart_gas_price', action='store_true',
help="Use smart gas pricing strategy, based on the ethgasstation.info feed")
parser.add_argument("--refresh-frequency", type=int, default=3,
help="Order book refresh frequency (in seconds, default: 3)")
parser.add_argument("--debug", dest='debug', action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3(HTTPProvider(endpoint_uri=f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}",
request_kwargs={"timeout": self.arguments.rpc_timeout}))
self.web3.eth.defaultAccount = self.arguments.eth_from
self.our_address = Address(self.arguments.eth_from)
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.bands_config = ReloadableConfig(self.arguments.config)
self.gas_price = GasPriceFactory().create_gas_price(self.arguments)
self.price_feed = PriceFeedFactory().create_price_feed(self.arguments)
self.spread_feed = create_spread_feed(self.arguments)
self.order_history_reporter = create_order_history_reporter(self.arguments)
self.history = History()
# Delegate 0x specific init to a function to permit overload for 0xv2
self.zrx_exchange = None
self.zrx_relayer_api = None
self.zrx_api = None
self.pair = None
self.init_zrx()
self.placed_zrx_orders = []
self.placed_zrx_orders_lock = Lock()
self.order_book_manager = OrderBookManager(refresh_frequency=self.arguments.refresh_frequency)
self.order_book_manager.get_orders_with(lambda: self.get_orders())
self.order_book_manager.get_balances_with(lambda: self.get_balances())
self.order_book_manager.place_orders_with(self.place_order_function)
self.order_book_manager.cancel_orders_with(self.cancel_order_function)
self.order_book_manager.enable_history_reporting(self.order_history_reporter, self.our_buy_orders, self.our_sell_orders)
self.order_book_manager.start()
def init_zrx(self):
self.zrx_exchange = ZrxExchange(web3=self.web3, address=Address(self.arguments.exchange_address))
self.zrx_relayer_api = ZrxRelayerApi(exchange=self.zrx_exchange, api_server=self.arguments.relayer_api_server)
self.zrx_api = ZrxApi(zrx_exchange=self.zrx_exchange)
self.pair = Pair(sell_token_address=Address(self.arguments.sell_token_address),
sell_token_decimals=self.arguments.sell_token_decimals,
buy_token_address=Address(self.arguments.buy_token_address),
buy_token_decimals=self.arguments.buy_token_decimals)
def main(self):
with Lifecycle(self.web3) as lifecycle:
lifecycle.initial_delay(10)
lifecycle.on_startup(self.startup)
lifecycle.every(1, self.synchronize_orders)
lifecycle.on_shutdown(self.shutdown)
def startup(self):
self.approve()
def shutdown(self):
self.order_book_manager.cancel_all_orders(final_wait_time=60)
def approve(self):
token_buy = ERC20Token(web3=self.web3, address=Address(self.pair.buy_token_address))
token_sell = ERC20Token(web3=self.web3, address=Address(self.pair.sell_token_address))
self.zrx_exchange.approve([token_sell, token_buy], directly(gas_price=self.gas_price))
def remove_expired_orders(self, orders: list) -> list:
current_timestamp = int(time.time())
return list(filter(lambda order: order.zrx_order.expiration > current_timestamp - self.arguments.order_expiry_threshold, orders))
def remove_expired_zrx_orders(self, zrx_orders: list) -> list:
current_timestamp = int(time.time())
return list(filter(lambda order: order.expiration > current_timestamp - self.arguments.order_expiry_threshold, zrx_orders))
def remove_filled_or_cancelled_zrx_orders(self, zrx_orders: list) -> list:
return list(filter(lambda order: self.zrx_exchange.get_unavailable_buy_amount(order) < order.buy_amount, zrx_orders))
def get_orders(self) -> list:
def remove_old_zrx_orders(zrx_orders: list) -> list:
return self.remove_filled_or_cancelled_zrx_orders(self.remove_expired_zrx_orders(zrx_orders))
with self.placed_zrx_orders_lock:
self.placed_zrx_orders = remove_old_zrx_orders(self.placed_zrx_orders)
api_zrx_orders = remove_old_zrx_orders(self.zrx_relayer_api.get_orders_by_maker(self.our_address, self.arguments.relayer_per_page))
with self.placed_zrx_orders_lock:
zrx_orders = list(set(self.placed_zrx_orders + api_zrx_orders))
return self.zrx_api.get_orders(self.pair, zrx_orders)
def get_balances(self):
balances = self.zrx_api.get_balances(self.pair)
return balances[0], balances[1], eth_balance(self.web3, self.our_address)
def our_total_sell_balance(self, balances) -> Wad:
return balances[0]
def our_total_buy_balance(self, balances) -> Wad:
return balances[1]
def our_eth_balance(self, balances) -> Wad:
return balances[2]
def our_sell_orders(self, our_orders: list) -> list:
return list(filter(lambda order: order.is_sell, our_orders))
def our_buy_orders(self, our_orders: list) -> list:
return list(filter(lambda order: not order.is_sell, our_orders))
def synchronize_orders(self):
bands = Bands.read(self.bands_config, self.spread_feed, self.history)
order_book = self.order_book_manager.get_order_book()
target_price = self.price_feed.get_price()
# We filter out expired orders from the order book snapshot. The reason for that is that
# it allows us to replace expired orders faster. Without it, we would have to wait
# for the next order book refresh in order to realize an order has expired. Unfortunately,
# in case of 0x order book refresh can be quite slow as it involves making multiple calls
# to the Ethereum node.
#
# By filtering out expired orders here, we can replace them the next `synchronize_orders`
# tick after they expire. Which is ~ 1s delay, instead of avg ~ 5s without this trick.
orders = self.remove_expired_orders(order_book.orders)
if self.our_eth_balance(order_book.balances) < self.min_eth_balance:
self.logger.warning("Keeper ETH balance below minimum. Cancelling all orders.")
self.order_book_manager.cancel_all_orders()
return
# Cancel orders
cancellable_orders = bands.cancellable_orders(our_buy_orders=self.our_buy_orders(orders),
our_sell_orders=self.our_sell_orders(orders),
target_price=target_price)
if len(cancellable_orders) > 0:
self.order_book_manager.cancel_orders(cancellable_orders)
return
# Do not place new orders if order book state is not confirmed
if order_book.orders_being_placed or order_book.orders_being_cancelled:
self.logger.debug("Order book is in progress, not placing new orders")
return
# Balances returned by `our_total_***_balance` still contain amounts "locked"
# by currently open orders, so we need to explicitly subtract these amounts.
if self.arguments.use_full_balances:
our_buy_balance = self.our_total_buy_balance(order_book.balances)
our_sell_balance = self.our_total_sell_balance(order_book.balances)
else:
our_buy_balance = self.our_total_buy_balance(order_book.balances) - Bands.total_amount(self.our_buy_orders(orders))
our_sell_balance = self.our_total_sell_balance(order_book.balances) - Bands.total_amount(self.our_sell_orders(orders))
# Place new orders
self.order_book_manager.place_orders(bands.new_orders(our_buy_orders=self.our_buy_orders(orders),
our_sell_orders=self.our_sell_orders(orders),
our_buy_balance=our_buy_balance,
our_sell_balance=our_sell_balance,
target_price=target_price)[0])
def place_order_function(self, new_order: NewOrder):
assert(isinstance(new_order, NewOrder))
zrx_order = self.zrx_api.place_order(pair=self.pair,
is_sell=new_order.is_sell,
price=new_order.price,
amount=new_order.amount,
expiration=int(time.time()) + self.arguments.order_expiry)
zrx_order = self.zrx_relayer_api.calculate_fees(zrx_order)
zrx_order = self.zrx_exchange.sign_order(zrx_order)
if self.zrx_relayer_api.submit_order(zrx_order):
if self.arguments.remember_own_orders:
with self.placed_zrx_orders_lock:
self.placed_zrx_orders.append(zrx_order)
order = self.zrx_api.get_orders(self.pair, [zrx_order])[0]
return order
else:
return None
def cancel_order_function(self, order):
transact = self.zrx_exchange.cancel_order(order.zrx_order).transact(gas_price=self.gas_price)
return transact is not None and transact.successful
class RadarRelayMarketMakerKeeper:
"""Keeper acting as a market maker on RadarRelay, on the WETH/SAI pair."""
logger = logging.getLogger('radarrelay-market-maker-keeper')
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='radarrelay-market-maker-keeper')
parser.add_argument("--rpc-host",
type=str,
default="localhost",
help="JSON-RPC host (default: `localhost')")
parser.add_argument("--rpc-port",
type=int,
default=8545,
help="JSON-RPC port (default: `8545')")
parser.add_argument(
"--eth-from",
type=str,
required=True,
help="Ethereum account from which to send transactions")
parser.add_argument("--tub-address",
type=str,
required=True,
help="Ethereum address of the Tub contract")
parser.add_argument(
"--exchange-address",
type=str,
required=True,
help="Ethereum address of the 0x Exchange contract")
parser.add_argument("--weth-address",
type=str,
required=True,
help="Ethereum address of the WETH token")
parser.add_argument("--relayer-api-server",
type=str,
required=True,
help="Address of the 0x Relayer API")
parser.add_argument("--config",
type=str,
required=True,
help="Buy/sell bands configuration file")
parser.add_argument(
"--price-feed",
type=str,
help=
"Source of price feed. Tub price feed will be used if not specified"
)
parser.add_argument(
"--order-expiry",
type=int,
required=True,
help="Expiration time of created orders (in seconds)")
parser.add_argument(
"--order-expiry-threshold",
type=int,
default=0,
help=
"Order expiration time at which order is considered already expired (in seconds)"
)
parser.add_argument(
"--min-eth-balance",
type=float,
default=0,
help=
"Minimum ETH balance below which keeper with either terminate or not start at all"
)
parser.add_argument(
'--cancel-on-shutdown',
dest='cancel_on_shutdown',
action='store_true',
help=
"Whether should cancel all open orders on RadarRelay on keeper shutdown"
)
parser.add_argument("--gas-price",
type=int,
default=0,
help="Gas price (in Wei)")
parser.add_argument("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3(
HTTPProvider(
endpoint_uri=
f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}"))
self.web3.eth.defaultAccount = self.arguments.eth_from
self.our_address = Address(self.arguments.eth_from)
self.tub = Tub(web3=self.web3,
address=Address(self.arguments.tub_address))
self.vox = Vox(web3=self.web3, address=self.tub.vox())
self.sai = ERC20Token(web3=self.web3, address=self.tub.sai())
self.ether_token = ERC20Token(web3=self.web3,
address=Address(
self.arguments.weth_address))
logging.basicConfig(
format='%(asctime)-15s %(levelname)-8s %(message)s',
level=(logging.DEBUG if self.arguments.debug else logging.INFO))
self.bands_config = ReloadableConfig(self.arguments.config)
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.price_feed = PriceFeedFactory().create_price_feed(
self.arguments.price_feed, self.tub, self.vox)
self.radar_relay = ZrxExchange(web3=self.web3,
address=Address(
self.arguments.exchange_address))
self.radar_relay_api = ZrxRelayerApi(
exchange=self.radar_relay,
api_server=self.arguments.relayer_api_server)
def main(self):
with Web3Lifecycle(self.web3) as lifecycle:
self.lifecycle = lifecycle
lifecycle.initial_delay(10)
lifecycle.on_startup(self.startup)
lifecycle.every(15, self.synchronize_orders)
lifecycle.every(60 * 60, self.print_balances)
lifecycle.on_shutdown(self.shutdown)
def startup(self):
self.approve()
def shutdown(self):
if self.arguments.cancel_on_shutdown:
self.cancel_orders(self.our_orders())
def print_balances(self):
sai_owned = self.sai.balance_of(self.our_address)
weth_owned = self.ether_token.balance_of(self.our_address)
self.logger.info(
f"Keeper balances are {sai_owned} SAI, {weth_owned} + 0x-WETH")
def approve(self):
"""Approve 0x to access our 0x-WETH and SAI, so we can sell it on the exchange."""
self.radar_relay.approve([self.ether_token, self.sai], directly())
def our_orders(self) -> list:
our_orders = self.radar_relay_api.get_orders_by_maker(self.our_address)
current_timestamp = int(time.time())
our_orders = list(
filter(
lambda order: order.expiration > current_timestamp - self.
arguments.order_expiry_threshold, our_orders))
our_orders = list(
filter(
lambda order: self.radar_relay.get_unavailable_buy_amount(
order) < order.buy_amount, our_orders))
return our_orders
def our_sell_orders(self, our_orders: list) -> list:
return list(
filter(
lambda order: order.buy_token == self.sai.address and order.
pay_token == self.ether_token.address, our_orders))
def our_buy_orders(self, our_orders: list) -> list:
return list(
filter(
lambda order: order.buy_token == self.ether_token.address and
order.pay_token == self.sai.address, our_orders))
def synchronize_orders(self):
"""Update our positions in the order book to reflect keeper parameters."""
if eth_balance(self.web3, self.our_address) < self.min_eth_balance:
self.lifecycle.terminate(
"Keeper balance is below the minimum, terminating.")
self.cancel_orders(self.our_orders())
return
bands = Bands(self.bands_config)
our_orders = self.our_orders()
target_price = self.price_feed.get_price()
if target_price is None:
self.logger.warning(
"Cancelling all orders as no price feed available.")
self.cancel_orders(our_orders)
return
self.cancel_orders(
itertools.chain(
bands.excessive_buy_orders(self.our_buy_orders(our_orders),
target_price),
bands.excessive_sell_orders(self.our_sell_orders(our_orders),
target_price),
bands.outside_orders(self.our_buy_orders(our_orders),
self.our_sell_orders(our_orders),
target_price)))
self.top_up_bands(our_orders, bands.buy_bands, bands.sell_bands,
target_price)
def cancel_orders(self, orders):
"""Cancel orders asynchronously."""
synchronize([
self.radar_relay.cancel_order(order).transact_async(
gas_price=self.gas_price()) for order in orders
])
def excessive_orders_in_band(self, band, orders: list, target_price: Wad):
"""Return orders which need to be cancelled to bring the total order amount in the band below maximum."""
# if total amount of orders in this band is greater than the maximum, we cancel them all
#
# if may not be the best solution as cancelling only some of them could bring us below
# the maximum, but let's stick to it for now
orders_in_band = [
order for order in orders if band.includes(order, target_price)
]
return orders_in_band if self.total_amount(
orders_in_band) > band.max_amount else []
def top_up_bands(self, our_orders: list, buy_bands: list, sell_bands: list,
target_price: Wad):
"""Create new buy and sell orders in all send and buy bands if necessary."""
self.top_up_buy_bands(our_orders, buy_bands, target_price)
self.top_up_sell_bands(our_orders, sell_bands, target_price)
def top_up_sell_bands(self, our_orders: list, sell_bands: list,
target_price: Wad):
"""Ensure our WETH engagement is not below minimum in all sell bands. Place new orders if necessary."""
our_balance = self.ether_token.balance_of(
self.our_address) #TODO deduct orders / or maybe not...?
for band in sell_bands:
orders = [
order for order in self.our_sell_orders(our_orders)
if band.includes(order, target_price)
]
total_amount = self.total_amount(orders)
if total_amount < band.min_amount:
have_amount = Wad.min(band.avg_amount - total_amount,
our_balance)
if (have_amount >= band.dust_cutoff) and (have_amount >
Wad(0)):
our_balance = our_balance - have_amount #TODO I think this line is unnecessary here
want_amount = have_amount * round(
band.avg_price(target_price))
if want_amount > Wad(0):
order = self.radar_relay.create_order(
pay_token=self.ether_token.address,
pay_amount=have_amount,
buy_token=self.sai.address,
buy_amount=want_amount,
expiration=int(time.time()) +
self.arguments.order_expiry)
order = self.radar_relay_api.calculate_fees(order)
order = self.radar_relay.sign_order(order)
self.radar_relay_api.submit_order(order)
def top_up_buy_bands(self, our_orders: list, buy_bands: list,
target_price: Wad):
"""Ensure our SAI engagement is not below minimum in all buy bands. Place new orders if necessary."""
our_balance = self.sai.balance_of(
self.our_address) #TODO deduct orders / or maybe not...?
for band in buy_bands:
orders = [
order for order in self.our_buy_orders(our_orders)
if band.includes(order, target_price)
]
total_amount = self.total_amount(orders)
if total_amount < band.min_amount:
have_amount = Wad.min(band.avg_amount - total_amount,
our_balance)
if (have_amount >= band.dust_cutoff) and (have_amount >
Wad(0)):
our_balance = our_balance - have_amount #TODO I think this line is unnecessary here
want_amount = have_amount / round(
band.avg_price(target_price))
if want_amount > Wad(0):
order = self.radar_relay.create_order(
pay_token=self.sai.address,
pay_amount=have_amount,
buy_token=self.ether_token.address,
buy_amount=want_amount,
expiration=int(time.time()) +
self.arguments.order_expiry)
order = self.radar_relay_api.calculate_fees(order)
order = self.radar_relay.sign_order(order)
self.radar_relay_api.submit_order(order)
def total_amount(self, orders):
pay_amount_available = lambda order: order.pay_amount - (
self.radar_relay.get_unavailable_buy_amount(
order) * order.pay_amount / order.buy_amount)
return reduce(operator.add, map(pay_amount_available, orders), Wad(0))
def gas_price(self) -> GasPrice:
if self.arguments.gas_price > 0:
return FixedGasPrice(self.arguments.gas_price)
else:
return DefaultGasPrice()
