def __init__(self, args: list):
parser = argparse.ArgumentParser(prog='0x-market-maker-chart')
parser.add_argument("--rpc-host", help="JSON-RPC host (default: `localhost')", default="localhost", type=str)
parser.add_argument("--rpc-port", help="JSON-RPC port (default: `8545')", default=8545, type=int)
parser.add_argument("--rpc-timeout", help="JSON-RPC timeout (in seconds, default: 60)", type=int, default=60)
parser.add_argument("--exchange-address", help="Ethereum address of the 0x contract", required=True, type=str)
parser.add_argument("--buy-token-address", help="Ethereum address of the buy token", required=True, type=str)
parser.add_argument("--buy-token-decimals", help="Number of decimals for the buy token", type=int, default=18)
parser.add_argument("--sell-token-address", help="Ethereum address of the sell token", required=True, type=str)
parser.add_argument("--sell-token-decimals", help="Number of decimals for the sell token", type=int, default=18)
parser.add_argument("--old-sell-token-address", help="Ethereum address of the old sell token", required=False, type=str)
parser.add_argument("--market-maker-address", help="Ethereum account of the market maker to analyze", required=True, type=str)
parser.add_argument("--gdax-price", help="GDAX product (ETH-USD, BTC-USD) to use as the price history source", type=str)
parser.add_argument("--price-feed", help="Price endpoint to use as the price history source", type=str)
parser.add_argument("--alternative-price-feed", help="Price endpoint to use as the alternative price history source", type=str)
parser.add_argument("--order-history", help="Order history endpoint from which to fetch our order history", type=str)
parser.add_argument("--past-blocks", help="Number of past blocks to analyze", required=True, type=int)
parser.add_argument("-o", "--output", help="Name of the filename to save to chart to."
" Will get displayed on-screen if empty", required=False, type=str)
self.arguments = parser.parse_args(args)
self.web3 = Web3(HTTPProvider(endpoint_uri=f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}",
request_kwargs={'timeout': self.arguments.rpc_timeout}))
self.infura = Web3(HTTPProvider(endpoint_uri=f"https://mainnet.infura.io/", request_kwargs={'timeout': 120}))
self.buy_token_address = Address(self.arguments.buy_token_address)
self.sell_token_address = Address(self.arguments.sell_token_address)
self.old_sell_token_address = Address(self.arguments.old_sell_token_address) if self.arguments.old_sell_token_address else None
self.sell_token_addresses = list(filter(lambda address: address is not None, [self.sell_token_address, self.old_sell_token_address]))
self.market_maker_address = Address(self.arguments.market_maker_address)
self.exchange = ZrxExchange(web3=self.web3, address=Address(self.arguments.exchange_address))
initialize_charting(self.arguments.output)
initialize_logging()
def init_zrx(self):
self.zrx_exchange = ZrxExchange(web3=self.web3, address=Address(self.arguments.exchange_address))
self.zrx_relayer_api = ZrxRelayerApi(exchange=self.zrx_exchange, api_server=self.arguments.relayer_api_server)
self.zrx_api = ZrxApi(zrx_exchange=self.zrx_exchange)
self.pair = Pair(sell_token_address=Address(self.arguments.sell_token_address),
sell_token_decimals=self.arguments.sell_token_decimals,
buy_token_address=Address(self.arguments.buy_token_address),
buy_token_decimals=self.arguments.buy_token_decimals)
def __init__(self, args: list):
parser = argparse.ArgumentParser(prog='radarrelay-market-maker-chart')
parser.add_argument("--rpc-host", help="JSON-RPC host (default: `localhost')", default="localhost", type=str)
parser.add_argument("--rpc-port", help="JSON-RPC port (default: `8545')", default=8545, type=int)
parser.add_argument("--exchange-address", help="Ethereum address of the 0x contract", required=True, type=str)
parser.add_argument("--sai-address", help="Ethereum address of the SAI token", required=True, type=str)
parser.add_argument("--weth-address", help="Ethereum address of the WETH token", required=True, type=str)
parser.add_argument("--market-maker-address", help="Ethereum account of the market maker to analyze", required=True, type=str)
parser.add_argument("--past-blocks", help="Number of past blocks to analyze", required=True, type=int)
parser.add_argument("-o", "--output", help="Name of the filename to save to chart to."
" Will get displayed on-screen if empty", required=False, type=str)
self.arguments = parser.parse_args(args)
self.web3 = Web3(HTTPProvider(endpoint_uri=f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}", request_kwargs={'timeout': 120}))
self.infura = Web3(HTTPProvider(endpoint_uri=f"https://mainnet.infura.io/", request_kwargs={'timeout': 120}))
self.sai_address = Address(self.arguments.sai_address)
self.weth_address = Address(self.arguments.weth_address)
self.market_maker_address = Address(self.arguments.market_maker_address)
self.exchange = ZrxExchange(web3=self.web3, address=Address(self.arguments.exchange_address))
if self.arguments.output:
import matplotlib
matplotlib.use('Agg')
def __init__(self, args: list, **kwargs):
parser = argparse.ArgumentParser(prog='0x-market-maker-keeper')
parser.add_argument("--rpc-host",
type=str,
default="localhost",
help="JSON-RPC host (default: `localhost')")
parser.add_argument("--rpc-port",
type=int,
default=8545,
help="JSON-RPC port (default: `8545')")
parser.add_argument("--rpc-timeout",
type=int,
default=10,
help="JSON-RPC timeout (in seconds, default: 10)")
parser.add_argument(
"--eth-from",
type=str,
required=True,
help="Ethereum account from which to send transactions")
parser.add_argument(
"--exchange-address",
type=str,
required=True,
help="Ethereum address of the 0x Exchange contract")
parser.add_argument("--relayer-api-server",
type=str,
required=True,
help="Address of the 0x Relayer API")
parser.add_argument(
"--relayer-per-page",
type=int,
default=100,
help=
"Number of orders to fetch per one page from the 0x Relayer API (default: 100)"
)
parser.add_argument("--buy-token-address",
type=str,
required=True,
help="Ethereum address of the buy token")
parser.add_argument("--sell-token-address",
type=str,
required=True,
help="Ethereum address of the sell token")
parser.add_argument("--config",
type=str,
required=True,
help="Bands configuration file")
parser.add_argument("--price-feed",
type=str,
required=True,
help="Source of price feed")
parser.add_argument(
"--price-feed-expiry",
type=int,
default=120,
help="Maximum age of the price feed (in seconds, default: 120)")
parser.add_argument("--spread-feed",
type=str,
help="Source of spread feed")
parser.add_argument(
"--spread-feed-expiry",
type=int,
default=3600,
help="Maximum age of the spread feed (in seconds, default: 3600)")
parser.add_argument(
"--order-expiry",
type=int,
required=True,
help="Expiration time of created orders (in seconds)")
parser.add_argument(
"--order-expiry-threshold",
type=int,
default=0,
help=
"How long before order expiration it is considered already expired (in seconds)"
)
parser.add_argument(
"--min-eth-balance",
type=float,
default=0,
help="Minimum ETH balance below which keeper will cease operation")
parser.add_argument(
'--cancel-on-shutdown',
dest='cancel_on_shutdown',
action='store_true',
help="Whether should cancel all open orders on keeper shutdown")
parser.add_argument("--gas-price",
type=int,
default=0,
help="Gas price (in Wei)")
parser.add_argument(
"--smart-gas-price",
dest='smart_gas_price',
action='store_true',
help=
"Use smart gas pricing strategy, based on the ethgasstation.info feed"
)
parser.add_argument("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3(
HTTPProvider(
endpoint_uri=
f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}",
request_kwargs={"timeout": self.arguments.rpc_timeout}))
self.web3.eth.defaultAccount = self.arguments.eth_from
self.our_address = Address(self.arguments.eth_from)
self.token_buy = ERC20Token(web3=self.web3,
address=Address(
self.arguments.buy_token_address))
self.token_sell = ERC20Token(web3=self.web3,
address=Address(
self.arguments.sell_token_address))
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.bands_config = ReloadableConfig(self.arguments.config)
self.gas_price = GasPriceFactory().create_gas_price(self.arguments)
self.price_feed = PriceFeedFactory().create_price_feed(self.arguments)
self.spread_feed = create_spread_feed(self.arguments)
self.history = History()
self.zrx_exchange = ZrxExchange(web3=self.web3,
address=Address(
self.arguments.exchange_address))
self.zrx_relayer_api = ZrxRelayerApi(
exchange=self.zrx_exchange,
api_server=self.arguments.relayer_api_server)
self.placed_orders = []
def __init__(self, args: list):
parser = argparse.ArgumentParser(prog='0x-market-maker-pnl')
parser.add_argument("--rpc-host",
help="JSON-RPC host (default: `localhost')",
default="localhost",
type=str)
parser.add_argument("--rpc-port",
help="JSON-RPC port (default: `8545')",
default=8545,
type=int)
parser.add_argument("--rpc-timeout",
help="JSON-RPC timeout (in seconds, default: 60)",
type=int,
default=60)
parser.add_argument("--exchange-address",
help="Ethereum address of the 0x contract",
required=True,
type=str)
parser.add_argument(
"--market-maker-address",
help="Ethereum account of the market maker to analyze",
required=True,
type=str)
parser.add_argument(
"--gdax-price",
help=
"GDAX product (ETH-USD, BTC-USD) to use as the price history source",
type=str)
parser.add_argument(
"--price-feed",
help="Price endpoint to use as the price history source",
type=str)
parser.add_argument("--price-history-file",
help="File to use as the price history source",
type=str)
parser.add_argument("--vwap-minutes",
help="Rolling VWAP window size (default: 240)",
type=int,
default=240)
parser.add_argument("--buy-token",
help="Name of the buy token",
required=True,
type=str)
parser.add_argument("--buy-token-address",
help="Ethereum address of the buy token",
required=True,
type=str)
parser.add_argument("--buy-token-decimals",
help="Number of decimals for the buy token",
type=int,
default=18)
parser.add_argument("--sell-token",
help="Name of the sell token",
required=True,
type=str)
parser.add_argument("--sell-token-address",
help="Ethereum address of the sell token",
required=True,
type=str)
parser.add_argument("--sell-token-decimals",
help="Number of decimals for the sell token",
type=int,
default=18)
parser.add_argument("--old-sell-token-address",
help="Ethereum address of the old sell token",
required=False,
type=str)
parser.add_argument("--past-blocks",
help="Number of past blocks to analyze",
required=True,
type=int)
parser.add_argument("-o",
"--output",
help="File to save the chart or the table to",
required=False,
type=str)
parser_mode = parser.add_mutually_exclusive_group(required=True)
parser_mode.add_argument('--text',
help="Show PnL as a text table",
dest='text',
action='store_true')
parser_mode.add_argument('--chart',
help="Show PnL on a cumulative graph",
dest='chart',
action='store_true')
self.arguments = parser.parse_args(args)
self.web3 = Web3(
HTTPProvider(
endpoint_uri=
f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}",
request_kwargs={'timeout': self.arguments.rpc_timeout}))
self.infura = Web3(
HTTPProvider(endpoint_uri=f"https://mainnet.infura.io/",
request_kwargs={'timeout': 120}))
self.buy_token_address = Address(self.arguments.buy_token_address)
self.sell_token_address = Address(self.arguments.sell_token_address)
self.old_sell_token_address = Address(
self.arguments.old_sell_token_address
) if self.arguments.old_sell_token_address else None
self.sell_token_addresses = list(
filter(lambda address: address is not None,
[self.sell_token_address, self.old_sell_token_address]))
self.market_maker_address = Address(
self.arguments.market_maker_address)
self.exchange = ZrxExchange(web3=self.web3,
address=Address(
self.arguments.exchange_address))
if self.arguments.chart and self.arguments.output:
import matplotlib
matplotlib.use('Agg')
logging.basicConfig(
format='%(asctime)-15s %(levelname)-8s %(message)s',
level=logging.INFO)
logging.getLogger("filelock").setLevel(logging.WARNING)
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(
"--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("--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.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.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='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(
"--eth-key-file",
type=str,
required=True,
help="File with the private key file for the Ethereum account")
parser.add_argument(
"--eth-password-file",
type=str,
required=True,
help="File with the private key password for the Ethereum account")
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(
"--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("--debug",
dest='debug',
action='store_true',
help="Enable debug output")
self.arguments = parser.parse_args(args)
setup_logging(self.arguments)
self.web3 = kwargs['web3'] if 'web3' in kwargs else Web3(
HTTPProvider(
endpoint_uri=
f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}",
request_kwargs={"timeout": self.arguments.rpc_timeout}))
self.web3.eth.defaultAccount = self.arguments.eth_from
self.our_address = Address(self.arguments.eth_from)
self.min_eth_balance = Wad.from_number(self.arguments.min_eth_balance)
self.bands_config = ReloadableConfig(self.arguments.config)
self.gas_price = GasPriceFactory().create_gas_price(self.arguments)
self.price_feed = PriceFeedFactory().create_price_feed(
self.arguments.price_feed, self.arguments.price_feed_expiry)
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,
self.arguments.eth_key_file,
self.read_password(self.arguments.eth_password_file))
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(
"--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(
"--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("--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)
if self.arguments.pair != 'USStocks-DAI':
self.pair = self.arguments.pair.upper()
else:
self.pair = self.arguments.pair
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.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.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 test_fail_when_no_contract_under_that_address(self):
# expect
with pytest.raises(Exception):
ZrxExchange(web3=self.web3, address=Address('0xdeadadd1e5500000000000000000000000000000'))
web3 = Web3(
HTTPProvider("http://localhost:8545", request_kwargs={"timeout": 600}))
web3.eth.defaultAccount = sys.argv[1]
EXCHANGE_ADDRESS = Address("0xdcdb42c9a256690bd153a7b409751adfc8dd5851")
DAI_ADDRESS = Address("0xd9ebebfdab08c643c5f2837632de920c70a56247")
ETH_ADDRESS = Address("0xaa7427d8f17d87a28f5e1ba3adbb270badbe1011")
FEE_ADDRESS = Address("0x61b9898c9b60a159fc91ae8026563cd226b7a0c1")
dai_wrapper = TEthfinexToken(web3, DAI_ADDRESS, "DAI")
# print(dai_wrapper.balance_of(Address(web3.eth.defaultAccount)))
# print(dai_wrapper.deposit(Wad.from_number(15)).transact())
# print(dai_wrapper.balance_of(Address(web3.eth.defaultAccount)))
# ethfinex_trustless = TEthfinexToken(web3, EXCHANGE_ADDRESS)
zrx_exchange = ZrxExchange(web3=web3, address=EXCHANGE_ADDRESS)
ethfinex_trustless_api = TEthfinexApi(zrx_exchange, 'https://api.ethfinex.com',
15.5)
# print(ethfinex_trustless_api.get_symbols())
# print(ethfinex_trustless_api.get_config())
# placed_order = ethfinex_trustless_api.place_order(False,
# DAI_ADDRESS,
# Wad.from_number(86.4),
# ETH_ADDRESS,
# Wad.from_number(0.8),
# FEE_ADDRESS,
# "DAIETH")
# print(f"Placed order {placed_order}")
# print(ethfinex_trustless_api.get_orders("tDAIUSD"))
# print(ethfinex_trustless_api.cancel_order(placed_order))
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, **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(
"--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=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
register_keys(self.web3, self.arguments.eth_key)
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 __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.web3, 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):
parser = argparse.ArgumentParser(prog='0x-market-maker-trades')
parser.add_argument("--rpc-host",
help="JSON-RPC host (default: `localhost')",
default="localhost",
type=str)
parser.add_argument("--rpc-port",
help="JSON-RPC port (default: `8545')",
default=8545,
type=int)
parser.add_argument("--rpc-timeout",
help="JSON-RPC timeout (in seconds, default: 60)",
type=int,
default=60)
parser.add_argument("--exchange-address",
help="Ethereum address of the 0x contract",
required=True,
type=str)
parser.add_argument(
"--exchange-name",
help="Exchange name for including in the JSON file",
required=True,
type=str)
parser.add_argument("--buy-token",
help="Name of the buy token",
required=True,
type=str)
parser.add_argument("--buy-token-address",
help="Ethereum address of the buy token",
required=True,
type=str)
parser.add_argument("--buy-token-decimals",
help="Number of decimals for the buy token",
type=int,
default=18)
parser.add_argument("--sell-token",
help="Name of the sell token",
required=True,
type=str)
parser.add_argument("--sell-token-address",
help="Ethereum address of the sell token",
required=True,
type=str)
parser.add_argument("--sell-token-decimals",
help="Number of decimals for the sell token",
type=int,
default=18)
parser.add_argument("--old-sell-token-address",
help="Ethereum address of the old sell token",
required=False,
type=str)
parser.add_argument(
"--market-maker-address",
help="Ethereum account of the market maker to analyze",
required=True,
type=str)
parser.add_argument("--past-blocks",
help="Number of past blocks to analyze",
required=True,
type=int)
parser.add_argument("-o",
"--output",
help="File to save the table or the JSON to",
required=False,
type=str)
parser_mode = parser.add_mutually_exclusive_group(required=True)
parser_mode.add_argument('--text',
help="List trades as a text table",
dest='text',
action='store_true')
parser_mode.add_argument('--json',
help="List trades as a JSON document",
dest='json',
action='store_true')
self.arguments = parser.parse_args(args)
self.web3 = Web3(
HTTPProvider(
endpoint_uri=
f"http://{self.arguments.rpc_host}:{self.arguments.rpc_port}",
request_kwargs={'timeout': self.arguments.rpc_timeout}))
self.infura = Web3(
HTTPProvider(endpoint_uri=f"https://mainnet.infura.io/",
request_kwargs={'timeout': 120}))
self.buy_token_address = Address(self.arguments.buy_token_address)
self.sell_token_address = Address(self.arguments.sell_token_address)
self.old_sell_token_address = Address(
self.arguments.old_sell_token_address
) if self.arguments.old_sell_token_address else None
self.sell_token_addresses = list(
filter(lambda address: address is not None,
[self.sell_token_address, self.old_sell_token_address]))
self.market_maker_address = Address(
self.arguments.market_maker_address)
self.exchange = ZrxExchange(web3=self.web3,
address=Address(
self.arguments.exchange_address))
logging.basicConfig(
format='%(asctime)-15s %(levelname)-8s %(message)s',
level=logging.INFO)
logging.getLogger("filelock").setLevel(logging.WARNING)
import logging
import sys
from web3 import Web3, HTTPProvider
from pyexchange.paradex import ParadexApi
from pymaker import Wad, Address
from pymaker.zrx import ZrxExchange
logging.basicConfig(format='%(asctime)-15s %(levelname)-8s %(message)s',
level=logging.INFO)
web3 = Web3(
HTTPProvider("http://localhost:8545", request_kwargs={"timeout": 600}))
web3.eth.defaultAccount = sys.argv[2]
zrx_exchange = ZrxExchange(
web3, Address('0x12459C951127e0c374FF9105DdA097662A027093'))
paradex = ParadexApi(zrx_exchange, 'https://api.paradex.io/consumer',
sys.argv[1], 15.5)
print(paradex.get_all_trades('WETH/DAI'))
exit(-1)
# print(paradex.ticker('WETH/DAI'))
print(paradex.get_balances())
print(paradex.get_balances())
print(paradex.get_balances())
print(paradex.get_balances())
print(paradex.get_balances())
print(paradex.get_balances())
# print(paradex.get_orders('WETH/DAI'))
import sys
from web3 import Web3, HTTPProvider
from pyexchange.theocean import TheOceanApi, Pair
from pymaker import Address, Wad
from pymaker.zrx import ZrxExchange
logging.basicConfig(format='%(asctime)-15s %(levelname)-8s %(message)s', level=logging.DEBUG)
logging.getLogger('urllib3.connectionpool').setLevel(logging.INFO)
logging.getLogger('requests.packages.urllib3.connectionpool').setLevel(logging.INFO)
web3 = Web3(HTTPProvider("http://localhost:8545", request_kwargs={"timeout": 600}))
web3.eth.defaultAccount = '0x00531a10c4fBD906313768d277585292AA7C923A'
zrx_exchange = ZrxExchange(web3, Address('0x90fe2af704b34e0224bf2299c838e04d4dcf1364'))
theocean = TheOceanApi(zrx_exchange, 'https://api.staging.theocean.trade/api', sys.argv[1], sys.argv[2], 9.5)
pair = Pair(Address('0x6ff6c0ff1d68b964901f986d4c9fa3ac68346570'), Address('0xd0a1e359811322d97991e03f863a0c30c2cf029c'))
print(theocean.get_market(pair))
# print(theocean.ticker(pair))
print(theocean.get_trades(pair, 1))
print(theocean.get_all_trades(pair, 1))
print(theocean.get_balance(pair.buy_token))