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(
"--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("--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(
"--oasis-support-address",
type=str,
required=False,
help="Ethereum address of the OasisDEX support 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("--buy-token-name",
type=str,
required=True,
help="Ethereum address of the buy token")
parser.add_argument("--sell-token-name",
type=str,
required=True,
help="Ethereum address of the sell token")
parser.add_argument("--buy-token-decimals",
type=int,
required=True,
help="Ethereum address of the buy token")
parser.add_argument("--sell-token-decimals",
type=int,
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(
"--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("--ethgasstation-api-key",
type=str,
default=None,
help="ethgasstation API key")
parser.add_argument(
"--refresh-frequency",
type=int,
default=10,
help="Order book refresh frequency (in seconds, default: 10)")
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
register_keys(self.web3, self.arguments.eth_key)
self.our_address = Address(self.arguments.eth_from)
self.otc = MatchingMarket(
web3=self.web3,
address=Address(self.arguments.oasis_address),
support_address=Address(self.arguments.oasis_support_address)
if self.arguments.oasis_support_address else None)
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.buy_token = Token(name=self.arguments.buy_token_name,
address=Address(
self.arguments.buy_token_address),
decimals=self.arguments.buy_token_decimals)
self.sell_token = Token(name=self.arguments.sell_token_name,
address=Address(
self.arguments.sell_token_address),
decimals=self.arguments.sell_token_decimals)
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.web3, self.arguments)
self.price_feed = PriceFeedFactory().create_price_feed(
self.arguments, tub)
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.order_book_manager = OrderBookManager(
refresh_frequency=self.arguments.refresh_frequency)
self.order_book_manager.get_orders_with(lambda: self.our_orders())
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, **kwargs):
parser = argparse.ArgumentParser(prog='radarrelay-market-maker-keeper')
parser.add_argument("--rpc-host",
type=str,
default="localhost",
help="JSON-RPC host (default: `localhost')")
parser.add_argument("--rpc-port",
type=int,
default=8545,
help="JSON-RPC port (default: `8545')")
parser.add_argument("--rpc-timeout",
type=int,
default=10,
help="JSON-RPC timeout (in seconds, default: 10)")
parser.add_argument(
"--eth-from",
type=str,
required=True,
help="Ethereum account from which to send transactions")
parser.add_argument("--tub-address",
type=str,
required=True,
help="Ethereum address of the Tub contract")
parser.add_argument(
"--exchange-address",
type=str,
required=True,
help="Ethereum address of the 0x Exchange contract")
parser.add_argument("--weth-address",
type=str,
required=True,
help="Ethereum address of the WETH token")
parser.add_argument("--relayer-api-server",
type=str,
required=True,
help="Address of the 0x Relayer API")
parser.add_argument("--config",
type=str,
required=True,
help="Buy/sell bands configuration file")
parser.add_argument(
"--price-feed",
type=str,
help=
"Source of price feed. Tub price feed will be used if not specified"
)
parser.add_argument(
"--price-feed-expiry",
type=int,
default=120,
help="Maximum age of non-Tub price feed (in seconds, default: 120)"
)
parser.add_argument(
"--order-expiry",
type=int,
required=True,
help="Expiration time of created orders (in seconds)")
parser.add_argument(
"--order-expiry-threshold",
type=int,
default=0,
help=
"Order expiration time at which order is considered already expired (in seconds)"
)
parser.add_argument(
"--min-eth-balance",
type=float,
default=0,
help=
"Minimum ETH balance below which keeper with either terminate or not start at all"
)
parser.add_argument(
'--cancel-on-shutdown',
dest='cancel_on_shutdown',
action='store_true',
help=
"Whether should cancel all open orders on RadarRelay on keeper shutdown"
)
parser.add_argument("--gas-price",
type=int,
default=0,
help="Gas price (in Wei)")
parser.add_argument(
"--gas-price-increase",
type=int,
help="Gas price increase (in Wei) if no confirmation within"
" `--gas-price-increase-every` seconds")
parser.add_argument(
"--gas-price-increase-every",
type=int,
default=120,
help="Gas price increase frequency (in seconds, default: 120)")
parser.add_argument("--gas-price-max",
type=int,
help="Maximum gas price (in Wei)")
parser.add_argument("--gas-price-file",
type=str,
help="Gas price configuration file")
parser.add_argument(
"--smart-gas-price",
dest='smart_gas_price',
action='store_true',
help=
"Use smart gas pricing strategy, based on the ethgasstation.info feed"
)
parser.add_argument("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3(
HTTPProvider(
endpoint_uri=
f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}",
request_kwargs={"timeout": self.arguments.rpc_timeout}))
self.web3.eth.defaultAccount = self.arguments.eth_from
self.our_address = Address(self.arguments.eth_from)
self.tub = Tub(web3=self.web3,
address=Address(self.arguments.tub_address))
self.vox = Vox(web3=self.web3, address=self.tub.vox())
self.sai = ERC20Token(web3=self.web3, address=self.tub.sai())
self.ether_token = ERC20Token(web3=self.web3,
address=Address(
self.arguments.weth_address))
logging.basicConfig(
format='%(asctime)-15s %(levelname)-8s %(message)s',
level=(logging.DEBUG if self.arguments.debug else logging.INFO))
logging.getLogger('urllib3.connectionpool').setLevel(logging.INFO)
logging.getLogger('requests.packages.urllib3.connectionpool').setLevel(
logging.INFO)
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.bands_config = ReloadableConfig(self.arguments.config)
self.gas_price = GasPriceFactory().create_gas_price(self.arguments)
self.price_feed = PriceFeedFactory().create_price_feed(
self.arguments.price_feed, self.arguments.price_feed_expiry,
self.tub, self.vox)
self.radar_relay = ZrxExchange(web3=self.web3,
address=Address(
self.arguments.exchange_address))
self.radar_relay_api = ZrxRelayerApi(
exchange=self.radar_relay,
api_server=self.arguments.relayer_api_server)
def __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 our_available_balance(self, token: ERC20Token) -> Wad:
return token.balance_of(self.our_address)
def our_available_balance(self, token: ERC20Token) -> Wad:
return token.balance_of(self.our_address)
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(
"--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.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 = []
self.placed_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, **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.web3, 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 our_total_balance(self, token: ERC20Token) -> Wad:
return token.balance_of(self.our_address)
def approve(self, approval_function, source: Address):
assert (callable(approval_function))
assert isinstance(source, Address)
approval_function(ERC20Token(web3=self.web3, address=source),
self.address, self.__class__.__name__)
def our_available_balance(self, token: ERC20Token) -> Wad:
if token.symbol() == self.buy_token.name:
return self.buy_token.normalize_amount(token.balance_of(self.our_address))
else:
return self.sell_token.normalize_amount(token.balance_of(self.our_address))
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='ddex-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(
"--ddex-api-server",
type=str,
default='https://api.ddex.io',
help="Address of the Ddex API (default: 'https://api.ddex.io')")
parser.add_argument(
"--ddex-api-timeout",
type=float,
default=9.5,
help="Timeout for accessing the Ddex 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("--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.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.ddex_api = DdexApi(self.web3, self.arguments.ddex_api_server,
self.arguments.ddex_api_timeout)
self.order_book_manager = OrderBookManager(
refresh_frequency=self.arguments.refresh_frequency, max_workers=1)
self.order_book_manager.get_orders_with(
lambda: self.ddex_api.get_orders(self.pair))
self.order_book_manager.cancel_orders_with(
lambda order: self.ddex_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 approve(self, source: Address, approval_function, **kwargs):
"""Approve the pot to access Dai from our Urns"""
assert isinstance(source, Address)
assert(callable(approval_function))
approval_function(ERC20Token(web3=self.web3, address=source), self.address, self.__class__.__name__, **kwargs)
def __init__(self, args, **kwargs):
"""Pass in arguements assign necessary variables/objects and instantiate other Classes"""
parser = argparse.ArgumentParser("simple-arbitrage-keeper")
parser.add_argument("--rpc-host",
type=str,
default="localhost",
help="JSON-RPC host (default: `localhost: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 address from which to send transactions; checksummed (e.g. '0x12AebC')"
)
parser.add_argument(
"--eth-key",
type=str,
nargs='*',
required=True,
help=
"Ethereum private key(s) to use (e.g. 'key_file=/path/to/keystore.json,pass_file=/path/to/passphrase.txt')"
)
parser.add_argument(
"--uniswap-entry-exchange",
type=str,
required=True,
help=
"Ethereum address of the Uniswap Exchange contract for the entry token market; checksummed (e.g. '0x12AebC')"
)
parser.add_argument(
"--uniswap-arb-exchange",
type=str,
required=True,
help=
"Ethereum address of the Uniswap Exchange contract for the arb token market; checksummed (e.g. '0x12AebC')"
)
parser.add_argument(
"--oasis-address",
type=str,
required=True,
help=
"Ethereum address of the OasisDEX contract; checksummed (e.g. '0x12AebC')"
)
parser.add_argument(
"--oasis-api-endpoint",
type=str,
required=True,
help=
"Endpoint of of the Oasis V2 REST API (e.g. 'https://kovan-api.oasisdex.com' )"
)
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(
"--tx-manager",
type=str,
required=True,
help=
"Ethereum address of the TxManager contract to use for multi-step arbitrage; checksummed (e.g. '0x12AebC')"
)
parser.add_argument(
"--gas-price",
type=int,
default=0,
help=
"Gas price in Wei (default: node default), (e.g. 1000000000 for 1 GWei)"
)
parser.add_argument(
"--entry-token",
type=str,
required=True,
help=
"The token address that the bot starts and ends with in every transaction; checksummed (e.g. '0x12AebC')"
)
parser.add_argument(
"--arb-token",
type=str,
required=True,
help=
"The token address that arbitraged between both exchanges; checksummed (e.g. '0x12AebC')"
)
parser.add_argument(
"--arb-token-name",
type=str,
required=True,
help=
"The token name that arbitraged between both exchanges (e.g. 'SAI', 'WETH', 'REP')"
)
parser.add_argument(
"--min-profit",
type=int,
required=True,
help=
"Ether amount of minimum profit (in base token) from one arbitrage operation (e.g. 1 for 1 Sai min profit)"
)
parser.add_argument(
"--max-engagement",
type=int,
required=True,
help=
"Ether amount of maximum engagement (in base token) in one arbitrage operation (e.g. 100 for 100 Sai max engagement)"
)
parser.add_argument(
"--max-errors",
type=int,
default=100,
help=
"Maximum number of allowed errors before the keeper terminates (default: 100)"
)
parser.add_argument("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
self.web3: Web3 = kwargs['web3'] if 'web3' in kwargs else web3_via_http(
endpoint_uri=self.arguments.rpc_host,
timeout=self.arguments.rpc_timeout)
self.web3.eth.defaultAccount = self.arguments.eth_from
register_keys(self.web3, self.arguments.eth_key)
self.our_address = Address(self.arguments.eth_from)
# self.sai = ERC20Token(web3=self.web3, address=Address('0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359')) # Mainnet Sai
# self.dai = ERC20Token(web3=self.web3, address=Address('0x6b175474e89094c44da98b954eedeac495271d0f')) # Mainnet Dai
self.ksai = ERC20Token(
web3=self.web3,
address=Address(
'0xC4375B7De8af5a38a93548eb8453a498222C4fF2')) #Kovan Sai
self.kdai = ERC20Token(
web3=self.web3,
address=Address(
'0x4F96Fe3b7A6Cf9725f59d353F723c1bDb64CA6Aa')) #Kovan Dai
self.entry_token = ERC20Token(web3=self.web3,
address=Address(
self.arguments.entry_token))
self.arb_token = ERC20Token(web3=self.web3,
address=Address(self.arguments.arb_token))
self.arb_token.name = self.arguments.arb_token_name \
if self.arguments.arb_token_name != 'WETH' else 'ETH'
self.uniswap_entry_exchange = UniswapWrapper(self.web3, self.entry_token.address, Address(self.arguments.uniswap_entry_exchange)) \
if self.arguments.uniswap_entry_exchange is not None else None
self.uniswap_arb_exchange = UniswapWrapper(self.web3, self.arb_token.address, Address(self.arguments.uniswap_arb_exchange)) \
if self.arguments.uniswap_arb_exchange is not None else None
self.oasis_api_endpoint = OasisAPI(api_server=self.arguments.oasis_api_endpoint,
entry_token_name=self.token_name(self.entry_token.address),
arb_token_name=self.arb_token.name) \
if self.arguments.oasis_api_endpoint is not None else None
self.oasis = MatchingMarket(web3=self.web3,
address=Address(
self.arguments.oasis_address))
self.min_profit = Wad(int(self.arguments.min_profit * 10**18))
self.max_engagement = Wad(int(self.arguments.max_engagement * 10**18))
self.max_errors = self.arguments.max_errors
self.errors = 0
if self.arguments.tx_manager:
self.tx_manager = TxManager(web3=self.web3,
address=Address(
self.arguments.tx_manager))
if self.tx_manager.owner() != self.our_address:
raise Exception(
f"The TxManager has to be owned by the address the keeper is operating from."
)
else:
self.tx_manager = None
logging.basicConfig(
format='%(asctime)-15s %(levelname)-8s %(message)s',
level=(logging.DEBUG if self.arguments.debug else logging.INFO))
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("--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")
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='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(
"--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("--oasis-address",
type=str,
required=True,
help="Ethereum address of the OasisDEX contract")
parser.add_argument("--config",
type=str,
required=True,
help="Buy/sell bands configuration file")
parser.add_argument(
"--price-feed",
type=str,
help=
"Source of price feed. Tub price feed will be used if not specified"
)
parser.add_argument(
"--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 with either terminate or not start at all"
)
parser.add_argument("--gas-price",
type=int,
default=0,
help="Gas price (in Wei)")
parser.add_argument(
"--gas-price-increase",
type=int,
help="Gas price increase (in Wei) if no confirmation within"
" `--gas-price-increase-every` seconds")
parser.add_argument(
"--gas-price-increase-every",
type=int,
default=120,
help="Gas price increase frequency (in seconds, default: 120)")
parser.add_argument("--gas-price-max",
type=int,
help="Maximum gas price (in Wei)")
parser.add_argument("--gas-price-file",
type=str,
help="Gas price configuration file")
parser.add_argument(
"--smart-gas-price",
dest='smart_gas_price',
action='store_true',
help=
"Use smart gas pricing strategy, based on the ethgasstation.info feed"
)
parser.add_argument("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3(
HTTPProvider(
endpoint_uri=
f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}"))
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))
self.tub = Tub(web3=self.web3,
address=Address(self.arguments.tub_address))
self.vox = Vox(web3=self.web3, address=self.tub.vox())
self.sai = ERC20Token(web3=self.web3, address=self.tub.sai())
self.gem = ERC20Token(web3=self.web3, address=self.tub.gem())
logging.basicConfig(
format='%(asctime)-15s %(levelname)-8s %(message)s',
level=(logging.DEBUG if self.arguments.debug else logging.INFO))
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.bands_config = ReloadableConfig(self.arguments.config)
self.gas_price = GasPriceFactory().create_gas_price(self.arguments)
self.price_feed = PriceFeedFactory().create_price_feed(
self.arguments.price_feed, self.tub, self.vox)
def __init__(self, args, **kwargs):
parser = argparse.ArgumentParser("arbitrage-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("--tap-address",
type=str,
required=True,
help="Ethereum address of the Tap contract")
parser.add_argument(
"--exchange-address",
type=str,
help="Ethereum address of the 0x Exchange contract")
parser.add_argument("--oasis-address",
type=str,
required=True,
help="Ethereum address of the OasisDEX contract")
parser.add_argument(
"--oasis-support-address",
type=str,
required=False,
help="Ethereum address of the OasisDEX support contract")
parser.add_argument("--relayer-api-server",
type=str,
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(
"--tx-manager",
type=str,
help=
"Ethereum address of the TxManager contract to use for multi-step arbitrage"
)
parser.add_argument("--gas-price",
type=int,
default=0,
help="Gas price in Wei (default: node default)")
parser.add_argument(
"--base-token",
type=str,
required=True,
help="The token all arbitrage sequences will start and end with")
parser.add_argument(
"--min-profit",
type=float,
required=True,
help="Minimum profit (in base token) from one arbitrage operation")
parser.add_argument(
"--max-engagement",
type=float,
required=True,
help="Maximum engagement (in base token) in one arbitrage operation"
)
parser.add_argument(
"--max-errors",
type=int,
default=100,
help=
"Maximum number of allowed errors before the keeper terminates (default: 100)"
)
parser.add_argument("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3(
HTTPProvider(
endpoint_uri=
f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}",
request_kwargs={"timeout": self.arguments.rpc_timeout}))
self.web3.eth.defaultAccount = self.arguments.eth_from
self.our_address = Address(self.arguments.eth_from)
self.tub = Tub(web3=self.web3,
address=Address(self.arguments.tub_address))
self.tap = Tap(web3=self.web3,
address=Address(self.arguments.tap_address))
self.gem = ERC20Token(web3=self.web3, address=self.tub.gem())
self.sai = ERC20Token(web3=self.web3, address=self.tub.sai())
self.skr = ERC20Token(web3=self.web3, address=self.tub.skr())
self.zrx_exchange = ZrxExchange(web3=self.web3, address=Address(self.arguments.exchange_address)) \
if self.arguments.exchange_address is not None else None
self.zrx_relayer_api = ZrxRelayerApi(exchange=self.zrx_exchange, api_server=self.arguments.relayer_api_server) \
if self.arguments.relayer_api_server is not None else None
self.otc = MatchingMarket(
web3=self.web3,
address=Address(self.arguments.oasis_address),
support_address=Address(self.arguments.oasis_support_address)
if self.arguments.oasis_support_address is not None else None)
self.base_token = ERC20Token(web3=self.web3,
address=Address(
self.arguments.base_token))
self.min_profit = Wad.from_number(self.arguments.min_profit)
self.max_engagement = Wad.from_number(self.arguments.max_engagement)
self.max_errors = self.arguments.max_errors
self.errors = 0
if self.arguments.tx_manager:
self.tx_manager = TxManager(web3=self.web3,
address=Address(
self.arguments.tx_manager))
if self.tx_manager.owner() != self.our_address:
raise Exception(
f"The TxManager has to be owned by the address the keeper is operating from."
)
else:
self.tx_manager = None
logging.basicConfig(
format='%(asctime)-15s %(levelname)-8s %(message)s',
level=(logging.DEBUG if self.arguments.debug else logging.INFO))
def our_total_balance(self, token: ERC20Token) -> Wad:
return token.balance_of(self.our_address)
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)
