def __init__(self, args: list):
parser = argparse.ArgumentParser(prog='gateio-market-maker-keeper')
parser.add_argument("--gateio-api-server", type=str, default="https://data.gate.io",
help="Address of the Gate.io API server (default: 'https://data.gate.io')")
parser.add_argument("--gateio-api-key", type=str, required=True,
help="API key for the Gate.io API")
parser.add_argument("--gateio-secret-key", type=str, required=True,
help="Secret key for the Gate.io API")
parser.add_argument("--gateio-timeout", type=float, default=9.5,
help="Timeout for accessing the Gate.io API (in seconds, default: 9.5)")
parser.add_argument("--pair", type=str, required=True,
help="Token pair (sell/buy) on which the keeper will operate")
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("--debug", dest='debug', action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.bands_config = ReloadableConfig(self.arguments.config)
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.gateio_api = GateIOApi(api_server=self.arguments.gateio_api_server,
api_key=self.arguments.gateio_api_key,
secret_key=self.arguments.gateio_secret_key,
timeout=self.arguments.gateio_timeout)
self._last_order_creation = 0
def __init__(self, args: list):
parser = argparse.ArgumentParser(prog='erisx-market-maker-keeper')
parser.add_argument("--erisx-clearing-url",
type=str,
required=True,
help="Address of the ErisX clearing server")
parser.add_argument("--fix-trading-endpoint",
type=str,
required=True,
help="FIX endpoint for ErisX trading")
parser.add_argument("--fix-trading-user",
type=str,
required=True,
help="Account ID for ErisX trading")
parser.add_argument("--fix-marketdata-endpoint",
type=str,
required=True,
help="FIX endpoint for ErisX market data")
parser.add_argument("--fix-marketdata-user",
type=str,
required=True,
help="Account ID for ErisX market data")
parser.add_argument("--erisx-password",
type=str,
required=True,
help="password for FIX account")
parser.add_argument("--erisx-api-key",
type=str,
required=True,
help="API key for ErisX REST API")
parser.add_argument("--erisx-api-secret",
type=str,
required=True,
help="API secret for ErisX REST API")
parser.add_argument(
"--erisx-certs",
type=str,
default=None,
help=
"Client key pair used to authenticate to Production FIX endpoints")
parser.add_argument("--account-id",
type=int,
default=0,
help="ErisX account ID index")
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
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("--control-feed",
type=str,
help="Source of control feed")
parser.add_argument(
"--control-feed-expiry",
type=int,
default=86400,
help="Maximum age of the control feed (in seconds, default: 86400)"
)
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(
"--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.erisx_api = ErisxApi(
fix_trading_endpoint=self.arguments.fix_trading_endpoint,
fix_trading_user=self.arguments.fix_trading_user,
fix_marketdata_endpoint=self.arguments.fix_marketdata_endpoint,
fix_marketdata_user=self.arguments.fix_marketdata_user,
password=self.arguments.erisx_password,
clearing_url=self.arguments.erisx_clearing_url,
api_key=self.arguments.erisx_api_key,
api_secret=self.arguments.erisx_api_secret,
certs=self.arguments.erisx_certs,
account_id=self.arguments.account_id)
termination_time = time.time() + 15
while self.erisx_api.fix_trading.connection_state != FixConnectionState.LOGGED_IN and self.erisx_api.fix_marketdata.connection_state != FixConnectionState.LOGGED_IN:
time.sleep(0.3)
if time.time() > termination_time:
raise RuntimeError("Timed out while waiting to log in")
self.market_info = self.erisx_api.get_markets()
self.orders = self.erisx_api.get_orders(self.pair())
self._lock = threading.Lock()
super().__init__(self.arguments, self.erisx_api)
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("--relayer-api-server", type=str, required=True,
help="Address of the 0x Relayer API")
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("--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 will cease operation")
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("--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.tub = Tub(web3=self.web3, address=Address(self.arguments.tub_address))
self.sai = ERC20Token(web3=self.web3, address=self.tub.sai())
self.gem = ERC20Token(web3=self.web3, address=self.tub.gem())
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.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 __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='idex-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("--idex-address", type=str, required=True,
help="Ethereum address of the IDEX contract")
parser.add_argument("--idex-api-server", type=str, default='https://api.idex.market',
help="Address of the IDEX API server (default: 'https://api.idex.market')")
parser.add_argument("--idex-timeout", type=float, default=9.5,
help="Timeout for accessing the IDEX API (in seconds, default: 9.5)")
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("--eth-reserve", type=float, required=True,
help="Amount of ETH which will never be deposited so the keeper can cover gas")
parser.add_argument("--min-eth-balance", type=float, default=0,
help="Minimum ETH balance below which keeper will cease operation")
parser.add_argument("--min-eth-deposit", type=float, required=True,
help="Minimum amount of ETH that can be deposited in one transaction")
parser.add_argument("--min-sai-deposit", type=float, required=True,
help="Minimum amount of SAI that can be deposited in one transaction")
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")
parser.set_defaults(cancel_on_shutdown=False, withdraw_on_shutdown=False)
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.tub = Tub(web3=self.web3, address=Address(self.arguments.tub_address))
self.sai = ERC20Token(web3=self.web3, address=self.tub.sai())
self.gem = ERC20Token(web3=self.web3, address=self.tub.gem())
self.bands_config = ReloadableConfig(self.arguments.config)
self.eth_reserve = Wad.from_number(self.arguments.eth_reserve)
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.min_eth_deposit = Wad.from_number(self.arguments.min_eth_deposit)
self.min_sai_deposit = Wad.from_number(self.arguments.min_sai_deposit)
self.gas_price = GasPriceFactory().create_gas_price(self.arguments)
self.price_feed = PriceFeedFactory().create_price_feed(self.arguments, self.tub)
self.spread_feed = create_spread_feed(self.arguments)
self.order_history_reporter = create_order_history_reporter(self.arguments)
if self.eth_reserve <= self.min_eth_balance:
raise Exception("--eth-reserve must be higher than --min-eth-balance")
self.history = History()
self.idex = IDEX(self.web3, Address(self.arguments.idex_address))
self.idex_api = IDEXApi(self.idex, self.arguments.idex_api_server, self.arguments.idex_timeout)
def __init__(self, args: list):
parser = argparse.ArgumentParser(prog='gopax-market-maker-keeper')
parser.add_argument("--gopax-api-server", type=str, default="https://api.gopax.co.kr",
help="Address of the GOPAX API server (default: 'https://api.gopax.co.kr')")
parser.add_argument("--gopax-api-key", type=str, required=True,
help="API key for the GOPAX API")
parser.add_argument("--gopax-api-secret", type=str, required=True,
help="API secret for the GOPAX API")
parser.add_argument("--gopax-timeout", type=float, default=9.5,
help="Timeout for accessing the GOPAX API (in seconds, default: 9.5)")
parser.add_argument("--pair", type=str, required=True,
help="Token pair (sell/buy) on which the keeper will operate")
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("--debug", dest='debug', action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.history = History()
self.gopax_api = GOPAXApi(api_server=self.arguments.gopax_api_server,
api_key=self.arguments.gopax_api_key,
api_secret=self.arguments.gopax_api_secret,
timeout=self.arguments.gopax_timeout)
self.bands_config = ReloadableConfig(self.arguments.config)
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.order_book_manager = OrderBookManager(refresh_frequency=10)
self.order_book_manager.get_orders_with(self.get_orders)
self.order_book_manager.get_balances_with(lambda: self.gopax_api.get_balances())
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__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='tethfinex-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(
"--eth-key",
type=str,
nargs='*',
help=
"Ethereum private key(s) to use (e.g. 'key_file=aaa.json,pass_file=aaa.pass')"
)
parser.add_argument(
"--exchange-address",
type=str,
required=True,
help="Ethereum address of the 0x Exchange contract")
parser.add_argument("--tub-address",
type=str,
required=False,
help="Ethereum address of the Tub contract")
parser.add_argument(
"--tethfinex-api-server",
type=str,
default='https://api.ethfinex.com',
help=
"Address of the Trustless Ethfinex API server (default: 'https://api.ethfinex.com')"
)
parser.add_argument(
"--tethfinex-timeout",
type=float,
default=9.5,
help="Timeout for accessing the IDEX API (in seconds, default: 9.5)"
)
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
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("--control-feed",
type=str,
help="Source of control feed")
parser.add_argument(
"--control-feed-expiry",
type=int,
default=86400,
help="Maximum age of the control feed (in seconds, default: 86400)"
)
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("--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")
parser.set_defaults(cancel_on_shutdown=False,
withdraw_on_shutdown=False)
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)
register_keys(self.web3, self.arguments.eth_key)
tub = Tub(web3=self.web3, address=Address(self.arguments.tub_address)) \
if self.arguments.tub_address is not None else None
self.sai = ERC20Token(web3=self.web3, address=tub.sai())
self.price_feed = PriceFeedFactory().create_price_feed(
self.arguments, tub)
self.bands_config = ReloadableConfig(self.arguments.config)
self.gas_price = GasPriceFactory().create_gas_price(self.arguments)
self.spread_feed = create_spread_feed(self.arguments)
self.control_feed = create_control_feed(self.arguments)
self.order_history_reporter = create_order_history_reporter(
self.arguments)
self.history = History()
self.tethfinex_exchange = ZrxExchange(
web3=self.web3, address=Address(self.arguments.exchange_address))
self.tethfinex_api = TEthfinexApi(
self.tethfinex_exchange,
self.arguments.tethfinex_api_server,
timeout=self.arguments.tethfinex_timeout)
config = self.tethfinex_api.get_config()['0x']
self.fee_address = Address(config['ethfinexAddress'])
token_registry = config['tokenRegistry']
token_sell = self.token_sell()
token_buy = self.token_buy()
self.token_sell_wrapper = TEthfinexToken(
self.web3, Address(token_registry[token_sell]['wrapperAddress']),
token_sell)
self.token_buy_wrapper = TEthfinexToken(
self.web3, Address(token_registry[token_buy]['wrapperAddress']),
token_buy)
pair = self.pair()
self.order_book_manager = OrderBookManager(
refresh_frequency=self.arguments.refresh_frequency, max_workers=1)
self.order_book_manager.get_orders_with(
lambda: self.tethfinex_api.get_orders(pair))
self.order_book_manager.cancel_orders_with(
lambda order: self.tethfinex_api.cancel_order(order.order_id))
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__(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("--eth-key", type=str, nargs='*',
help="Ethereum private key(s) to use (e.g. 'key_file=aaa.json,pass_file=aaa.pass')")
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("--control-feed", type=str,
help="Source of control feed")
parser.add_argument("--control-feed-expiry", type=int, default=86400,
help="Maximum age of the control feed (in seconds, default: 86400)")
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("--ethgasstation-api-key", type=str, default=None, help="ethgasstation API key")
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)
register_keys(self.web3, self.arguments.eth_key)
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.control_feed = create_control_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__(self, args: list):
parser = argparse.ArgumentParser(prog='gateio-market-maker-keeper')
parser.add_argument(
"--gateio-api-server",
type=str,
default="https://data.gate.io",
help=
"Address of the Gate.io API server (default: 'https://data.gate.io')"
)
parser.add_argument("--gateio-api-key",
type=str,
required=True,
help="API key for the Gate.io API")
parser.add_argument("--gateio-secret-key",
type=str,
required=True,
help="Secret key for the Gate.io API")
parser.add_argument(
"--gateio-timeout",
type=float,
default=9.5,
help=
"Timeout for accessing the Gate.io API (in seconds, default: 9.5)")
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
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("--control-feed",
type=str,
help="Source of control feed")
parser.add_argument(
"--control-feed-expiry",
type=int,
default=86400,
help="Maximum age of the control feed (in seconds, default: 86400)"
)
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(
"--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.bands_config = ReloadableConfig(self.arguments.config)
self.price_feed = PriceFeedFactory().create_price_feed(self.arguments)
self.spread_feed = create_spread_feed(self.arguments)
self.control_feed = create_control_feed(self.arguments)
self.order_history_reporter = create_order_history_reporter(
self.arguments)
self.history = History()
self.gateio_api = GateIOApi(
api_server=self.arguments.gateio_api_server,
api_key=self.arguments.gateio_api_key,
secret_key=self.arguments.gateio_secret_key,
timeout=self.arguments.gateio_timeout)
self.order_book_manager = OrderBookManager(
refresh_frequency=self.arguments.refresh_frequency)
self.order_book_manager.get_orders_with(
lambda: self.gateio_api.get_orders(self.pair()))
self.order_book_manager.get_balances_with(
lambda: self.gateio_api.get_balances())
self.order_book_manager.cancel_orders_with(
lambda order: self.gateio_api.cancel_order(self.pair(), order.
order_id))
self.order_book_manager.enable_history_reporting(
self.order_history_reporter, self.our_buy_orders,
self.our_sell_orders)
self.order_book_manager.start()
self._last_order_creation = 0
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='mpx-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(
"--eth-key",
type=str,
nargs='*',
help=
"Ethereum private key(s) to use (e.g. 'key_file=aaa.json,pass_file=aaa.pass')"
)
parser.add_argument(
"--mpx-api-server",
type=str,
default='https://api.mpexchange.io',
help=
"Address of the MPX API server (default: 'https://api.mpexchange.io')"
)
parser.add_argument(
"--mpx-api-timeout",
type=float,
default=9.5,
help="Timeout for accessing the MPX API (in seconds, default: 9.5)"
)
parser.add_argument(
"--exchange-address",
type=str,
required=True,
help="Ethereum address of the Mpx Exchange contract")
parser.add_argument("--fee-address",
type=str,
required=True,
help="Ethereum address of the Mpx Fee contract")
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
parser.add_argument("--sell-token-address",
type=str,
required=True,
help="Ethereum address of the Sell Token")
parser.add_argument("--buy-token-address",
type=str,
required=True,
help="Ethereum address of the Buy Token")
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("--ethgasstation-api-key",
type=str,
default=None,
help="ethgasstation API key")
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("--control-feed",
type=str,
help="Source of control feed")
parser.add_argument(
"--control-feed-expiry",
type=int,
default=86400,
help="Maximum age of the control feed (in seconds, default: 86400)"
)
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(
"--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)
register_keys(self.web3, self.arguments.eth_key)
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.bands_config = ReloadableConfig(self.arguments.config)
self.price_max_decimals = None
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.control_feed = create_control_feed(self.arguments)
self.order_history_reporter = create_order_history_reporter(
self.arguments)
self.history = History()
self.zrx_exchange = ZrxExchangeV2(web3=self.web3,
address=Address(
self.arguments.exchange_address))
self.mpx_api = MpxApi(api_server=self.arguments.mpx_api_server,
zrx_exchange=self.zrx_exchange,
fee_recipient=Address(
self.arguments.fee_address),
timeout=self.arguments.mpx_api_timeout,
our_address=self.arguments.eth_from)
self.zrx_relayer_api = ZrxRelayerApiV2(
exchange=self.zrx_exchange,
api_server=self.arguments.mpx_api_server)
self.zrx_api = ZrxApiV2(zrx_exchange=self.zrx_exchange,
zrx_api=self.zrx_relayer_api)
markets = self.mpx_api.get_markets()['data']
market = next(
filter(
lambda item: item['attributes']['pair-name'] == self.arguments.
pair, markets))
self.pair = MpxPair(self.arguments.pair, self.token_buy.address,
int(market['attributes']['base-token-decimals']),
self.token_sell.address,
int(market['attributes']['quote-token-decimals']))
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.cancel_orders_with(self.cancel_order_function)
self.order_book_manager.place_orders_with(self.place_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__(self, args: list):
parser = argparse.ArgumentParser(prog='kucoin-market-maker-keeper')
parser.add_argument(
"--kucoin-api-server",
type=str,
default="https://openapi-v2.kucoin.com",
help=
"Address of the kucoin API server (default: 'https://openapi-v2.kucoin.com')"
)
parser.add_argument("--kucoin-api-key",
type=str,
required=True,
help="API key for the kucoin API")
parser.add_argument("--kucoin-secret-key",
type=str,
required=True,
help="Secret key for the kucoin API")
parser.add_argument("--kucoin-passphrase",
type=str,
required=True,
help="Passphrase for the kucoin API")
parser.add_argument(
"--kucoin-timeout",
type=float,
default=9.5,
help=
"Timeout for accessing the kucoin API (in seconds, default: 9.5)")
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
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("--control-feed",
type=str,
help="Source of control feed")
parser.add_argument(
"--control-feed-expiry",
type=int,
default=86400,
help="Maximum age of the control feed (in seconds, default: 86400)"
)
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(
"--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")
parser.add_argument(
"--telegram-log-config-file",
type=str,
required=False,
help=
"config file for send logs to telegram chat (e.g. 'telegram_conf.json')",
default=None)
parser.add_argument(
"--keeper-name",
type=str,
required=False,
help="market maker keeper name (e.g. 'Uniswap_V2_MDTETH')",
default="kocoin")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.bands_config = ReloadableConfig(self.arguments.config)
self.price_feed = PriceFeedFactory().create_price_feed(self.arguments)
self.spread_feed = create_spread_feed(self.arguments)
self.control_feed = create_control_feed(self.arguments)
self.order_history_reporter = create_order_history_reporter(
self.arguments)
self.history = History()
self.kucoin_api = KucoinApi(
api_server=self.arguments.kucoin_api_server,
api_key=self.arguments.kucoin_api_key,
secret_key=self.arguments.kucoin_secret_key,
api_passphrase=self.arguments.kucoin_passphrase,
timeout=self.arguments.kucoin_timeout)
self.order_book_manager = OrderBookManager(
refresh_frequency=self.arguments.refresh_frequency)
self.order_book_manager.get_orders_with(
lambda: self.kucoin_api.get_orders(self.pair()))
self.order_book_manager.get_balances_with(
lambda: self.kucoin_api.get_balances())
self.order_book_manager.cancel_orders_with(
lambda order: self.kucoin_api.cancel_order(order.order_id, order.
is_sell, self.pair()))
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__(self, args: list):
parser = argparse.ArgumentParser(prog='okex-market-stats')
parser.add_argument(
"--okex-api-server",
type=str,
default="https://www.okex.com",
help=
"Address of the OKEX API server (default: 'https://www.okex.com')")
parser.add_argument("--okex-api-key",
type=str,
required=True,
help="API key for the OKEX API")
parser.add_argument("--okex-secret-key",
type=str,
required=True,
help="Secret key for the OKEX API")
parser.add_argument("--okex-passphrase",
type=str,
required=True,
help="Passphrase for the OKEX API")
parser.add_argument(
"--okex-timeout",
type=float,
default=9.5,
help="Timeout for accessing the OKEX API (in seconds, default: 9.5)"
)
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
parser.add_argument("--config",
type=str,
required=True,
help="Bands configuration file")
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("--control-feed",
type=str,
help="Source of control feed")
parser.add_argument(
"--control-feed-expiry",
type=int,
default=86400,
help="Maximum age of the control feed (in seconds, default: 86400)"
)
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(
"--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.order_history_reporter = create_order_history_reporter(
self.arguments)
self.history = History()
self.okex_api = OKEXApi(api_server=self.arguments.okex_api_server,
api_key=self.arguments.okex_api_key,
secret_key=self.arguments.okex_secret_key,
passphrase=self.arguments.okex_passphrase,
timeout=self.arguments.okex_timeout)
self.order_book_manager = OrderBookManager(
refresh_frequency=self.arguments.refresh_frequency)
self.order_book_manager.get_orders_with(
lambda: self.okex_api.get_orders(self.pair()))
self.order_book_manager.get_balances_with(
lambda: self.okex_api.get_balances())
self.order_book_manager.cancel_orders_with(
lambda order: self.okex_api.cancel_order(self.pair(), order.
order_id))
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__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='oasis-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=False,
help="Ethereum address of the Tub contract")
parser.add_argument("--oasis-address", type=str, required=True,
help="Ethereum address of the OasisDEX contract")
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("--round-places", type=int, default=2,
help="Number of decimal places to round order prices to (default=2)")
parser.add_argument("--min-eth-balance", type=float, default=0,
help="Minimum ETH balance below which keeper will cease operation")
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.otc = MatchingMarket(web3=self.web3, address=Address(self.arguments.oasis_address))
tub = Tub(web3=self.web3, address=Address(self.arguments.tub_address)) \
if self.arguments.tub_address is not None else None
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, tub)
self.spread_feed = create_spread_feed(self.arguments)
self.order_history_reporter = create_order_history_reporter(self.arguments)
self.history = History()
self.order_book_manager = OrderBookManager(refresh_frequency=3)
self.order_book_manager.get_orders_with(lambda: self.our_orders())
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__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='gateio-market-maker-keeper')
parser.add_argument(
"--gateio-api-server",
type=str,
default="https://data.gate.io",
help=
"Address of the Gate.io API server (default: 'https://data.gate.io')"
)
parser.add_argument("--gateio-api-key",
type=str,
required=True,
help="API key for the Gate.io API")
parser.add_argument("--gateio-secret-key",
type=str,
required=True,
help="Secret key for the Gate.io API")
parser.add_argument(
"--gateio-timeout",
type=float,
default=9.5,
help=
"Timeout for accessing the Gate.io API (in seconds, default: 9.5)")
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
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("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.bands_config = ReloadableConfig(self.arguments.config)
self.price_feed = PriceFeedFactory().create_price_feed(
self.arguments.price_feed, self.arguments.price_feed_expiry)
self.history = History()
self.gateio_api = GateIOApi(
api_server=self.arguments.gateio_api_server,
api_key=self.arguments.gateio_api_key,
secret_key=self.arguments.gateio_secret_key,
timeout=self.arguments.gateio_timeout)
self._last_order_creation = 0
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='airswap-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("--orderserver-port",
type=str,
default='5004',
help="Port of the order server (default: '5004')")
parser.add_argument(
"--orderserver-host",
type=str,
default='127.0.0.1',
help="host of the order server (default: '127.0.0.1')")
parser.add_argument(
"--airswap-api-server",
type=str,
default='http://localhost:5005',
help="Address of the Airswap API (default: 'http://localhost:5005')"
)
parser.add_argument(
"--airswap-api-timeout",
type=float,
default=9.5,
help=
"Timeout for accessing the Airswap API (in seconds, default: 9.5)")
parser.add_argument(
"--eth-from",
type=str,
required=True,
help="Ethereum account from which to send transactions")
parser.add_argument(
"--eth-key",
type=str,
nargs='*',
help=
"Ethereum private key(s) to use (e.g. 'key_file=aaa.json,pass_file=aaa.pass')"
)
parser.add_argument(
"--exchange-address",
type=str,
required=True,
help="Ethereum address of the 0x Exchange contract")
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
parser.add_argument("--buy-token-address",
type=str,
required=True,
help="Ethereum address of the buy token")
parser.add_argument("--eth-sell-token-address",
type=str,
required=True,
help="eth Ethereum address of the sell token")
parser.add_argument("--weth-sell-token-address",
type=str,
required=True,
help="weth 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("--control-feed",
type=str,
help="Source of control feed")
parser.add_argument(
"--control-feed-expiry",
type=int,
default=86400,
help="Maximum age of the control feed (in seconds, default: 86400)"
)
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("--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)
register_keys(self.web3, self.arguments.eth_key)
self.airswap_api = AirswapApi(self.arguments.airswap_api_server,
self.arguments.airswap_api_timeout)
if self.arguments.buy_token_address == '0x0000000000000000000000000000000000000000':
self.token_buy = EthToken(web3=self.web3,
address=Address(
self.arguments.buy_token_address))
else:
self.token_buy = ERC20Token(web3=self.web3,
address=Address(
self.arguments.buy_token_address))
self.eth_token_sell = EthToken(
web3=self.web3,
address=Address(self.arguments.eth_sell_token_address))
self.weth_token_sell = ERC20Token(
web3=self.web3,
address=Address(self.arguments.weth_sell_token_address))
self.bands_config = ReloadableConfig(self.arguments.config)
self.price_feed = PriceFeedFactory().create_price_feed(self.arguments)
self.spread_feed = create_spread_feed(self.arguments)
self.control_feed = create_control_feed(self.arguments)
self.order_history_reporter = create_order_history_reporter(
self.arguments)
self.history = History()
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='bibox-market-maker-keeper')
parser.add_argument(
"--bibox-api-server",
type=str,
default="https://api.bibox.com",
help=
"Address of the Bibox API server (default: 'https://api.bibox.com')"
)
parser.add_argument("--bibox-api-key",
type=str,
required=True,
help="API key for the Bibox API")
parser.add_argument("--bibox-secret",
type=str,
required=True,
help="Secret for the Bibox API")
parser.add_argument(
"--bibox-timeout",
type=float,
default=9.5,
help=
"Timeout for accessing the Bibox API (in seconds, default: 9.5)")
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
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("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.bibox_api = BiboxApi(api_server=self.arguments.bibox_api_server,
api_key=self.arguments.bibox_api_key,
secret=self.arguments.bibox_secret,
timeout=self.arguments.bibox_timeout)
self.bands_config = ReloadableConfig(self.arguments.config)
self.price_feed = PriceFeedFactory().create_price_feed(
self.arguments.price_feed, self.arguments.price_feed_expiry, None)
self.order_book_manager = OrderBookManager(refresh_frequency=3)
self.order_book_manager.get_orders_with(
lambda: self.bibox_api.get_orders(pair=self.pair(), retry=True))
self.order_book_manager.get_balances_with(
lambda: self.bibox_api.coin_list(retry=True))
self.order_book_manager.start()
def __init__(self, args: list):
parser = argparse.ArgumentParser(prog='bibox-market-maker-keeper')
parser.add_argument("--config",
type=str,
required=True,
help="Bands configuration file")
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the surfer will operate")
parser.add_argument(
"--output-path",
type=str,
required=True,
help="output file path of the completed order result")
# reserved for old program
# 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(
"--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.orderlog = Logger(self.arguments.output_path + "SurferResult_" +
self.arguments.pair,
level='info')
try:
f = open(self.arguments.config, 'r')
config = json.loads(f.read())
f.close()
self.bibox_api = BiboxApi(api_server=config["bibox_api_server"],
api_key=config["bibox_api_key"],
secret=config["bibox_secret"],
timeout=config["bibox_timeout"])
for pair in config['pairs']:
if pair['pair'] == self.arguments.pair:
self.total_amount = pair["total_amount"]
# percent of total amount of each transaction or each order
self.each_order_percent = pair["each_order_percent"]
self.arbitrage_percent = pair["arbitrage_percent"]
# the order count of sell or buy bands must less than limit
self.band_order_limit = pair["band_order_limit"]
except Exception as e:
logging.getLogger().warning(
f"Config file is invalid ({e}). Treating the config file as it has no bands."
)
self.history = History()
self.bands_config = ReloadableConfig(self.arguments.config)
self.spread_feed = create_spread_feed(self.arguments)
self.order_history_reporter = create_order_history_reporter(
self.arguments)
self.local_orders = []
self.each_order_amount = self.total_amount * self.each_order_percent
# To implement abstract function with different exchanges API
self.order_book_manager = OrderBookManager(
refresh_frequency=self.arguments.refresh_frequency)
self.order_book_manager.get_orders_with(
lambda: self.bibox_api.get_orders(pair=self.pair(), retry=True))
self.order_book_manager.get_balances_with(
lambda: self.bibox_api.coin_list(retry=True))
self.order_book_manager.cancel_orders_with(
lambda order: self.bibox_api.cancel_order(order.order_id))
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__(self, args: list):
parser = argparse.ArgumentParser(prog='leverj-market-maker-keeper')
parser.add_argument(
"--leverj-api-server",
type=str,
default="https://test.leverj.io",
help=
"Address of the leverj API server (default: 'https://test.leverj.io')"
)
parser.add_argument("--account-id",
type=str,
default="",
help="Address of leverj api account id")
parser.add_argument("--api-key",
type=str,
default="",
help="Address of leverj api key")
parser.add_argument("--api-secret",
type=str,
default="",
help="Address of leverj api secret")
parser.add_argument(
"--leverj-timeout",
type=float,
default=9.5,
help=
"Timeout for accessing the Leverj API (in seconds, default: 9.5)")
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 watch our trades")
parser.add_argument(
"--eth-key",
type=str,
nargs='*',
help=
"Ethereum private key(s) to use (e.g. 'key_file=aaa.json,pass_file=aaa.pass')"
)
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("--control-feed",
type=str,
help="Source of control feed")
parser.add_argument(
"--control-feed-expiry",
type=int,
default=86400,
help="Maximum age of the control feed (in seconds, default: 86400)"
)
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(
"--refresh-frequency",
type=int,
default=3,
help="Order book refresh frequency (in seconds, default: 3)")
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
parser.add_argument("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
if "infura" in self.arguments.rpc_host:
self.web3 = Web3(
HTTPProvider(
endpoint_uri=f"http://{self.arguments.rpc_host}",
request_kwargs={"timeout": self.arguments.rpc_timeout}))
else:
self.web3 = 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
register_keys(self.web3, self.arguments.eth_key)
setup_logging(self.arguments)
self.bands_config = ReloadableConfig(self.arguments.config)
self.price_feed = PriceFeedFactory().create_price_feed(self.arguments)
self.spread_feed = create_spread_feed(self.arguments)
self.control_feed = create_control_feed(self.arguments)
self.order_history_reporter = create_order_history_reporter(
self.arguments)
self.history = History()
self.leverj_api = LeverjAPI(
web3=self.web3,
api_server=self.arguments.leverj_api_server,
account_id=self.arguments.account_id,
api_key=self.arguments.api_key,
api_secret=self.arguments.api_secret,
timeout=self.arguments.leverj_timeout)
self.order_book_manager = OrderBookManager(
refresh_frequency=self.arguments.refresh_frequency)
self.order_book_manager.get_orders_with(
lambda: self.leverj_api.get_orders(self.pair()))
self.order_book_manager.get_balances_with(
lambda: self.leverj_api.get_balances())
self.order_book_manager.cancel_orders_with(
lambda order: self.leverj_api.cancel_order(order.order_id))
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__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='paradex-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("--paradex-api-server", type=str, default='https://api.paradex.io/consumer',
help="Address of the Paradex API (default: 'https://api.paradex.io/consumer')")
parser.add_argument("--paradex-api-key", type=str, required=True,
help="API key for the Paradex API")
parser.add_argument("--paradex-api-timeout", type=float, default=9.5,
help="Timeout for accessing the Paradex API (in seconds, default: 9.5)")
parser.add_argument("--pair", type=str, required=True,
help="Token pair (sell/buy) on which the keeper will operate")
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("--min-eth-balance", type=float, default=0,
help="Minimum ETH balance below which keeper will cease operation")
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.pair = self.arguments.pair.upper()
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.price_max_decimals = None
self.amount_max_decimals = None
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.paradex_api = ParadexApi(self.zrx_exchange,
self.arguments.paradex_api_server,
self.arguments.paradex_api_key,
self.arguments.paradex_api_timeout)
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='theocean-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(
"--eth-key",
type=str,
nargs='*',
help=
"Ethereum private key(s) to use (e.g. 'key_file=aaa.json,pass_file=aaa.pass')"
)
parser.add_argument(
"--exchange-address",
type=str,
required=True,
help="Ethereum address of the 0x Exchange contract")
parser.add_argument(
"--theocean-api-server",
type=str,
default='https://api.theocean.trade/api',
help=
"Address of the TheOcean API (default: 'https://api.theocean.trade/api')"
)
parser.add_argument("--theocean-api-key",
type=str,
required=True,
help="API key for the TheOcean API")
parser.add_argument("--theocean-api-secret",
type=str,
required=True,
help="API secret for the TheOcean API")
parser.add_argument(
"--theocean-api-timeout",
type=float,
default=9.5,
help=
"Timeout for accessing the TheOcean API (in seconds, default: 9.5)"
)
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("--control-feed",
type=str,
help="Source of control feed")
parser.add_argument(
"--control-feed-expiry",
type=int,
default=86400,
help="Maximum age of the control feed (in seconds, default: 86400)"
)
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("--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)
register_keys(self.web3, self.arguments.eth_key)
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.pair = Pair(self.token_sell.address, self.token_buy.address)
self.bands_config = ReloadableConfig(self.arguments.config)
self.price_max_decimals = None
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.control_feed = create_control_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.theocean_api = TheOceanApi(self.zrx_exchange,
self.arguments.theocean_api_server,
self.arguments.theocean_api_key,
self.arguments.theocean_api_secret,
self.arguments.theocean_api_timeout)
self.order_book_manager = OrderBookManager(
refresh_frequency=self.arguments.refresh_frequency)
self.order_book_manager.get_orders_with(
lambda: self.theocean_api.get_orders(self.pair))
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(
lambda order: self.theocean_api.cancel_order(order.order_id))
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__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='uniswap-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(
"--eth-key",
type=str,
nargs='*',
help=
"Ethereum private key(s) to use (e.g. 'key_file=aaa.json,pass_file=aaa.pass')"
)
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
parser.add_argument("--token-config",
type=str,
required=True,
help="Token configuration file")
parser.add_argument("--price-feed",
type=str,
required=True,
help="Source of price feed")
parser.add_argument(
"--price-feed-accepted-delay",
type=int,
default=60,
help=
"Number of seconds the keeper will tolerate the price feed being null before removing liquidity"
)
parser.add_argument(
"--price-feed-expiry",
type=int,
default=86400,
help="Maximum age of the price feed (in seconds, default: 86400)")
parser.add_argument("--ethgasstation-api-key",
type=str,
default=None,
help="ethgasstation API key")
parser.add_argument("--gas-price",
type=int,
default=9000000000,
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(
"--max-add-liquidity-slippage",
type=int,
default=2,
help=
"Maximum percentage off the desired amount of liquidity to add in add_liquidity()"
)
parser.add_argument(
"--accepted-price-slippage-up",
type=float,
required=True,
help=
"Percentage difference between Uniswap exchange rate and aggregated price above which liquidity would be added"
)
parser.add_argument(
"--accepted-price-slippage-down",
type=float,
required=True,
help=
"Percentage difference between Uniswap exchange rate and aggregated price below which liquidity would be added"
)
parser.add_argument("--target-a-min-balance",
type=float,
required=True,
help="Minimum balance of token A to maintain.")
parser.add_argument("--target-a-max-balance",
type=float,
required=True,
help="Minimum balance of token A to maintain.")
parser.add_argument("--target-b-min-balance",
type=float,
required=True,
help="Minimum balance of token B to maintain.")
parser.add_argument("--target-b-max-balance",
type=float,
required=True,
help="Minimum balance of token B to maintain.")
parser.add_argument(
"--factory-address",
type=str,
default="0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
help=
"Address of the UniswapV2 Factory smart contract used to create new pools"
)
parser.add_argument(
"--router-address",
type=str,
default="0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
help=
"Address of the UniswapV2 RouterV2 smart contract used to handle liquidity management"
)
parser.add_argument(
"--initial-delay",
type=int,
default=10,
help="Initial number of seconds to wait before placing liquidity")
parser.add_argument("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
if self.arguments.rpc_host.startswith("http"):
endpoint_uri = f"{self.arguments.rpc_host}:{self.arguments.rpc_port}"
else:
endpoint_uri = f"https://{self.arguments.rpc_host}:{self.arguments.rpc_port}"
self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3(
HTTPProvider(
endpoint_uri=endpoint_uri,
request_kwargs={"timeout": self.arguments.rpc_timeout}))
self.web3.eth.defaultAccount = self.arguments.eth_from
if 'web3' not in kwargs:
register_keys(self.web3, self.arguments.eth_key)
# TODO: Add a more sophisticated regex for different variants of eth on the exchange
# Record if eth is in pair, so can check which liquidity method needs to be used
self.is_eth = 'ETH' in self.pair()
# Identify which token is ETH, so we can provide the arguments to Uniswap Router in expected order
self.eth_position = 1
if self.is_eth:
self.eth_position = 0 if self.pair().split('-')[0] == 'ETH' else 1
self.reloadable_config = ReloadableConfig(self.arguments.token_config)
self._last_config_dict = None
self._last_config = None
self.token_config = self.get_token_config().token_config
self.token_a, self.token_b = self.instantiate_tokens(self.pair())
self.gas_price = GasPriceFactory().create_gas_price(self.arguments)
self.price_feed = PriceFeedFactory().create_price_feed(self.arguments)
self.price_feed_accepted_delay = self.arguments.price_feed_accepted_delay
self.control_feed = create_control_feed(self.arguments)
self.spread_feed = create_spread_feed(self.arguments)
# testing_feed_price is used by the integration tests in tests/test_uniswapv2.py, to test different pricing scenarios
# as the keeper consistently checks the price, some long running state variable is needed to
self.testing_feed_price = False
self.test_price = Wad.from_number(0)
self.uniswap = UniswapV2(self.web3, self.token_a, self.token_b,
Address(self.web3.eth.defaultAccount),
Address(self.arguments.router_address),
Address(self.arguments.factory_address))
self.uniswap_current_exchange_price = self.uniswap.get_exchange_rate()
self.feed_price_null_counter = 0
# set target min and max amounts for each side of the pair
# balance doesnt exceed some level, as an effective stop loss against impermanent loss
self.target_a_min_balance = Wad.from_number(
self.arguments.target_a_min_balance)
self.target_a_max_balance = Wad.from_number(
self.arguments.target_a_max_balance)
self.target_b_min_balance = Wad.from_number(
self.arguments.target_b_min_balance)
self.target_b_max_balance = Wad.from_number(
self.arguments.target_b_max_balance)
self.accepted_price_slippage_up = Wad.from_number(
self.arguments.accepted_price_slippage_up / 100)
self.accepted_price_slippage_down = Wad.from_number(
self.arguments.accepted_price_slippage_down / 100)
self.max_add_liquidity_slippage = Wad.from_number(
self.arguments.max_add_liquidity_slippage / 100)
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='etherdelta-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("--etherdelta-address",
type=str,
required=True,
help="Ethereum address of the EtherDelta contract")
parser.add_argument(
"--etherdelta-socket",
type=str,
required=True,
help="Ethereum address of the EtherDelta API socket")
parser.add_argument(
"--etherdelta-number-of-attempts",
type=int,
default=3,
help=
"Number of attempts of running the tool to talk to the EtherDelta API socket"
)
parser.add_argument(
"--etherdelta-retry-interval",
type=int,
default=10,
help=
"Retry interval for sending orders over the EtherDelta API socket")
parser.add_argument(
"--etherdelta-timeout",
type=int,
default=120,
help="Timeout for sending orders over the EtherDelta API socket")
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("--order-age",
type=int,
required=True,
help="Age of created orders (in blocks)")
parser.add_argument(
"--order-expiry-threshold",
type=int,
default=0,
help=
"Remaining order age (in blocks) at which order is considered already expired, which"
" means the keeper will send a new replacement order slightly ahead"
)
parser.add_argument(
"--order-no-cancel-threshold",
type=int,
default=0,
help=
"Remaining order age (in blocks) below which keeper does not try to cancel orders,"
" assuming that they will probably expire before the cancel transaction gets mined"
)
parser.add_argument(
"--eth-reserve",
type=float,
required=True,
help=
"Amount of ETH which will never be deposited so the keeper can cover gas"
)
parser.add_argument(
"--min-eth-balance",
type=float,
default=0,
help="Minimum ETH balance below which keeper will cease operation")
parser.add_argument(
"--min-eth-deposit",
type=float,
required=True,
help=
"Minimum amount of ETH that can be deposited in one transaction")
parser.add_argument(
"--min-sai-deposit",
type=float,
required=True,
help=
"Minimum amount of SAI that can be deposited in one transaction")
parser.add_argument(
'--cancel-on-shutdown',
dest='cancel_on_shutdown',
action='store_true',
help=
"Whether should cancel all open orders on EtherDelta on keeper shutdown"
)
parser.add_argument(
'--withdraw-on-shutdown',
dest='withdraw_on_shutdown',
action='store_true',
help=
"Whether should withdraw all tokens from EtherDelta 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")
parser.set_defaults(cancel_on_shutdown=False,
withdraw_on_shutdown=False)
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.tub = Tub(web3=self.web3,
address=Address(self.arguments.tub_address))
self.sai = ERC20Token(web3=self.web3, address=self.tub.sai())
self.gem = ERC20Token(web3=self.web3, address=self.tub.gem())
self.bands_config = ReloadableConfig(self.arguments.config)
self.eth_reserve = Wad.from_number(self.arguments.eth_reserve)
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.min_eth_deposit = Wad.from_number(self.arguments.min_eth_deposit)
self.min_sai_deposit = Wad.from_number(self.arguments.min_sai_deposit)
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)
if self.eth_reserve <= self.min_eth_balance:
raise Exception(
"--eth-reserve must be higher than --min-eth-balance")
assert (self.arguments.order_expiry_threshold >= 0)
assert (self.arguments.order_no_cancel_threshold >=
self.arguments.order_expiry_threshold)
self.history = History()
self.etherdelta = EtherDelta(web3=self.web3,
address=Address(
self.arguments.etherdelta_address))
self.etherdelta_api = EtherDeltaApi(
client_tool_directory="lib/pymaker/utils/etherdelta-client",
client_tool_command="node main.js",
api_server=self.arguments.etherdelta_socket,
number_of_attempts=self.arguments.etherdelta_number_of_attempts,
retry_interval=self.arguments.etherdelta_retry_interval,
timeout=self.arguments.etherdelta_timeout)
self.our_orders = list()
def __init__(self, args: list):
parser = argparse.ArgumentParser(prog='bibox-market-maker-keeper')
parser.add_argument(
"--bibox-api-server",
type=str,
default="https://api.bibox.com",
help=
"Address of the Bibox API server (default: 'https://api.bibox.com')"
)
parser.add_argument("--bibox-api-key",
type=str,
required=True,
help="API key for the Bibox API")
parser.add_argument("--bibox-secret",
type=str,
required=True,
help="Secret for the Bibox API")
parser.add_argument(
"--bibox-timeout",
type=float,
default=9.5,
help=
"Timeout for accessing the Bibox API (in seconds, default: 9.5)")
parser.add_argument(
"--pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
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(
"--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")
parser.add_argument("--base_price",
type=str,
default=0.00205375,
help="base price while initial base price ")
parser.add_argument("--total_amount",
type=str,
default=5,
help="the total assets for investing ")
parser.add_argument(
"--transaction_percent",
type=str,
default=0.02,
help=
"percent of total amount of each transaction or each order, fix percent 2%"
)
parser.add_argument(
"--arbitrage_percent",
type=str,
default=0.005,
help=
"the percent of current pirce as margin between two adjacent price orders, 0.5%"
)
parser.add_argument(
"--order_num",
type=str,
default=3,
help="the number of orders in each sell and buy bands ")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.history = History()
self.bibox_api = BiboxApi(api_server=self.arguments.bibox_api_server,
api_key=self.arguments.bibox_api_key,
secret=self.arguments.bibox_secret,
timeout=self.arguments.bibox_timeout)
self.bands_config = ReloadableConfig(self.arguments.config)
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.local_orders = []
self.base_price = 0.00105040
self.total_amount = 2000
self.each_order_percent = 0.05 # percent of total amount of each transaction or each order
self.arbitrage_percent = 0.005
self.band_order_limit = 3 # the order count of sell or buy bands must less than limit
self.each_order_amount = self.total_amount * self.each_order_percent
# To implement abstract function with different exchanges API
self.order_book_manager = OrderBookManager(
refresh_frequency=self.arguments.refresh_frequency)
self.order_book_manager.get_orders_with(
lambda: self.bibox_api.get_orders(pair=self.pair(), retry=True))
self.order_book_manager.get_balances_with(
lambda: self.bibox_api.coin_list(retry=True))
self.order_book_manager.cancel_orders_with(
lambda order: self.bibox_api.cancel_order(order.order_id))
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__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='etherdelta-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("--etherdelta-address", type=str, required=True,
help="Ethereum address of the EtherDelta contract")
parser.add_argument("--etherdelta-socket", type=str, required=True,
help="Ethereum address of the EtherDelta API socket")
parser.add_argument("--etherdelta-number-of-attempts", type=int, default=3,
help="Number of attempts of running the tool to talk to the EtherDelta API socket")
parser.add_argument("--etherdelta-retry-interval", type=int, default=10,
help="Retry interval for sending orders over the EtherDelta API socket")
parser.add_argument("--etherdelta-timeout", type=int, default=120,
help="Timeout for sending orders over the EtherDelta API socket")
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-age", type=int, required=True,
help="Age of created orders (in blocks)")
parser.add_argument("--order-expiry-threshold", type=int, default=0,
help="Remaining order age (in blocks) at which order is considered already expired, which"
" means the keeper will send a new replacement order slightly ahead")
parser.add_argument("--order-no-cancel-threshold", type=int, default=0,
help="Remaining order age (in blocks) below which keeper does not try to cancel orders,"
" assuming that they will probably expire before the cancel transaction gets mined")
parser.add_argument("--eth-reserve", type=float, required=True,
help="Amount of ETH which will never be deposited so the keeper can cover gas")
parser.add_argument("--min-eth-balance", type=float, default=0,
help="Minimum ETH balance below which keeper will cease operation")
parser.add_argument("--min-eth-deposit", type=float, required=True,
help="Minimum amount of ETH that can be deposited in one transaction")
parser.add_argument("--min-sai-deposit", type=float, required=True,
help="Minimum amount of SAI that can be deposited in one transaction")
parser.add_argument('--cancel-on-shutdown', dest='cancel_on_shutdown', action='store_true',
help="Whether should cancel all open orders on EtherDelta on keeper shutdown")
parser.add_argument('--withdraw-on-shutdown', dest='withdraw_on_shutdown', action='store_true',
help="Whether should withdraw all tokens from EtherDelta 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")
parser.set_defaults(cancel_on_shutdown=False, withdraw_on_shutdown=False)
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.tub = Tub(web3=self.web3, address=Address(self.arguments.tub_address))
self.sai = ERC20Token(web3=self.web3, address=self.tub.sai())
self.gem = ERC20Token(web3=self.web3, address=self.tub.gem())
self.bands_config = ReloadableConfig(self.arguments.config)
self.eth_reserve = Wad.from_number(self.arguments.eth_reserve)
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.min_eth_deposit = Wad.from_number(self.arguments.min_eth_deposit)
self.min_sai_deposit = Wad.from_number(self.arguments.min_sai_deposit)
self.gas_price = GasPriceFactory().create_gas_price(self.arguments)
self.price_feed = PriceFeedFactory().create_price_feed(self.arguments, self.tub)
self.spread_feed = create_spread_feed(self.arguments)
self.order_history_reporter = create_order_history_reporter(self.arguments)
if self.eth_reserve <= self.min_eth_balance:
raise Exception("--eth-reserve must be higher than --min-eth-balance")
assert(self.arguments.order_expiry_threshold >= 0)
assert(self.arguments.order_no_cancel_threshold >= self.arguments.order_expiry_threshold)
self.history = History()
self.etherdelta = EtherDelta(web3=self.web3, address=Address(self.arguments.etherdelta_address))
self.etherdelta_api = EtherDeltaApi(client_tool_directory="lib/pymaker/utils/etherdelta-client",
client_tool_command="node main.js",
api_server=self.arguments.etherdelta_socket,
number_of_attempts=self.arguments.etherdelta_number_of_attempts,
retry_interval=self.arguments.etherdelta_retry_interval,
timeout=self.arguments.etherdelta_timeout)
self.our_orders = list()
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='imtoken-pricing-server')
parser.add_argument("--http-address",
type=str,
default='',
help="Address of the Imtoken Pricing server")
parser.add_argument("--http-port",
type=int,
default=8777,
help="Port of the Imtoken Pricing server")
parser.add_argument(
"--imtoken-api-server",
type=str,
default='http://localhost:8157',
help=
"Address of the Imtoken API server (default: 'http://localhost:8157')"
)
parser.add_argument(
"--imtoken-api-timeout",
type=float,
default=9.5,
help=
"Timeout for accessing the Imtoken API (in seconds, default: 9.5)")
parser.add_argument("--config",
type=str,
required=True,
help="Bands configuration file")
parser.add_argument("--order-cache-maxsize",
type=int,
default=100000,
help="Maximum size of orders cache")
parser.add_argument("--order-cache-ttl",
type=int,
default=10,
help="Orders time to live")
parser.add_argument("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.cache = TTLCache(maxsize=self.arguments.order_cache_maxsize,
ttl=self.arguments.order_cache_ttl)
with open(self.arguments.config) as json_file:
data = json.load(json_file)
pairs, configs = self._parse_configs(data=data)
application = tornado.web.Application([
(r"/pairs", PairsHandler, dict(token_pairs=pairs)),
(r"/indicativePrice", IndicativePriceHandler,
dict(pairs=pairs, configs=configs, cache=self.cache)),
(r"/price", PriceHandler,
dict(pairs=pairs, configs=configs, cache=self.cache)),
(r"/deal", DealHandler, dict(cache=self.cache,
schema=deal_schema())),
])
application.listen(port=self.arguments.http_port,
address=self.arguments.http_address)
tornado.ioloop.IOLoop.current().start()
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='idex-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("--idex-address", type=str, required=True,
help="Ethereum address of the IDEX contract")
parser.add_argument("--idex-api-server", type=str, default='https://api.idex.market',
help="Address of the IDEX API server (default: 'https://api.idex.market')")
parser.add_argument("--idex-timeout", type=float, default=9.5,
help="Timeout for accessing the IDEX API (in seconds, default: 9.5)")
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("--eth-reserve", type=float, required=True,
help="Amount of ETH which will never be deposited so the keeper can cover gas")
parser.add_argument("--min-eth-balance", type=float, default=0,
help="Minimum ETH balance below which keeper will cease operation")
parser.add_argument("--min-eth-deposit", type=float, required=True,
help="Minimum amount of ETH that can be deposited in one transaction")
parser.add_argument("--min-sai-deposit", type=float, required=True,
help="Minimum amount of SAI that can be deposited in one transaction")
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")
parser.set_defaults(cancel_on_shutdown=False, withdraw_on_shutdown=False)
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.tub = Tub(web3=self.web3, address=Address(self.arguments.tub_address))
self.sai = ERC20Token(web3=self.web3, address=self.tub.sai())
self.gem = ERC20Token(web3=self.web3, address=self.tub.gem())
self.bands_config = ReloadableConfig(self.arguments.config)
self.eth_reserve = Wad.from_number(self.arguments.eth_reserve)
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.min_eth_deposit = Wad.from_number(self.arguments.min_eth_deposit)
self.min_sai_deposit = Wad.from_number(self.arguments.min_sai_deposit)
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)
if self.eth_reserve <= self.min_eth_balance:
raise Exception("--eth-reserve must be higher than --min-eth-balance")
self.history = History()
self.idex = IDEX(self.web3, Address(self.arguments.idex_address))
self.idex_api = IDEXApi(self.idex, self.arguments.idex_api_server, self.arguments.idex_timeout)
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='oasis-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=False,
help="Ethereum address of the Tub contract")
parser.add_argument("--oasis-address",
type=str,
required=True,
help="Ethereum address of the OasisDEX contract")
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(
"--round-places",
type=int,
default=2,
help="Number of decimal places to round order prices to (default=2)"
)
parser.add_argument(
"--min-eth-balance",
type=float,
default=0,
help="Minimum ETH balance below which keeper will cease operation")
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.otc = MatchingMarket(web3=self.web3,
address=Address(
self.arguments.oasis_address))
tub = Tub(web3=self.web3, address=Address(self.arguments.tub_address)) \
if self.arguments.tub_address is not None else None
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, tub)
self.spread_feed = create_spread_feed(self.arguments)
self.history = History()
self.order_book_manager = OrderBookManager(refresh_frequency=3)
self.order_book_manager.get_orders_with(lambda: self.our_orders())
self.order_book_manager.start()
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 __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='imtoken-pricing-server')
parser.add_argument("--http-address",
type=str,
default='',
help="Address of the Imtoken Pricing server")
parser.add_argument("--http-port",
type=int,
default=8777,
help="Port of the Imtoken Pricing server")
parser.add_argument(
"--imtoken-api-server",
type=str,
default='http://localhost:8157',
help=
"Address of the Imtoken API server (default: 'http://localhost:8157')"
)
parser.add_argument(
"--imtoken-api-timeout",
type=float,
default=9.5,
help=
"Timeout for accessing the Imtoken API (in seconds, default: 9.5)")
parser.add_argument(
"--base-pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
parser.add_argument("--base-config",
type=str,
required=True,
help="Bands configuration file")
parser.add_argument(
"--counter-pair",
type=str,
required=True,
help="Token pair (sell/buy) on which the keeper will operate")
parser.add_argument("--counter-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("--control-feed",
type=str,
help="Source of control feed")
parser.add_argument(
"--control-feed-expiry",
type=int,
default=86400,
help="Maximum age of the control feed (in seconds, default: 86400)"
)
parser.add_argument("--order-cache-maxsize",
type=int,
default=100000,
help="Maximum size of orders cache")
parser.add_argument("--order-cache-ttl",
type=int,
default=10,
help="Orders time to live")
parser.add_argument("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.cache = TTLCache(maxsize=self.arguments.order_cache_maxsize,
ttl=self.arguments.order_cache_ttl)
self.base_bands_config = ReloadableConfig(self.arguments.base_config)
self.counter_bands_config = ReloadableConfig(
self.arguments.counter_config)
self.price_feed = PriceFeedFactory().create_price_feed(self.arguments)
self.spread_feed = create_spread_feed(self.arguments)
self.control_feed = create_control_feed(self.arguments)
self.history = History()
pair = ImtokenPair(self.arguments.base_pair,
self.arguments.counter_pair)
application = tornado.web.Application([
(r"/pairs", PairsHandler, dict(pair=pair)),
(r"/indicativePrice", IndicativePriceHandler,
dict(pair=pair,
base_bands_config=self.base_bands_config,
counter_bands_config=self.counter_bands_config,
price_feed=self.price_feed,
spread_feed=self.spread_feed,
control_feed=self.control_feed,
history=self.history,
cache=self.cache)),
(r"/price", PriceHandler,
dict(pair=pair,
base_bands_config=self.base_bands_config,
counter_bands_config=self.counter_bands_config,
price_feed=self.price_feed,
spread_feed=self.spread_feed,
control_feed=self.control_feed,
history=self.history,
cache=self.cache)),
(r"/deal", DealHandler, dict(cache=self.cache,
schema=deal_schema())),
])
application.listen(port=self.arguments.http_port,
address=self.arguments.http_address)
tornado.ioloop.IOLoop.current().start()