desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
':rtype: int'
| @property
def int_wallet_id(self):
| return ASSET_MAP[self._wallet_id]
|
':param timestamp: Float representation of a timestamp
:type timestamp: float
:raises ValueError: Thrown when one of the arguments are invalid'
| def __init__(self, timestamp):
| super(Timestamp, self).__init__()
if (not isinstance(timestamp, (float, int, long))):
raise ValueError('Timestamp must be a float or a long')
if (timestamp < 0):
raise ValueError('Timestamp can not be negative')
self._timestamp = float(timestamp)
|
'Create a timestamp with the time set to the current time
:return: A timestamp
:rtype: Timestamp'
| @classmethod
def now(cls):
| return cls(time.time())
|
'Return the length of the amount of ticks contained in all the price level of this side'
| def __len__(self):
| return len(self._tick_map)
|
'Return the price level corresponding to the given price
:param price: The price for which the price level needs to be returned
:type price: Price
:return: The price level
:rtype: PriceLevel'
| def get_price_level(self, price):
| assert isinstance(price, Price), type(price)
return self._price_map[price]
|
':param order_id: The order id of the tick
:type order_id: OrderId
:return: The tick
:rtype: TickEntry'
| def get_tick(self, order_id):
| assert isinstance(order_id, OrderId), type(order_id)
return (self._tick_map[order_id] if (order_id in self._tick_map) else None)
|
':param price: The price to create the level for
:param quantity_wallet_id: the id of the quantities stored in this price level
:type price: Price
:type quantity_wallet_id: str'
| def _create_price_level(self, price, quantity_wallet_id):
| assert isinstance(price, Price), type(price)
self._depth[(price.wallet_id, quantity_wallet_id)] += 1
price_level = PriceLevel(quantity_wallet_id)
self._price_level_list_map[(price.wallet_id, quantity_wallet_id)].insert(price, price_level)
self._price_map[price] = price_level
|
':param price: The price to remove the level for
:param quantity_wallet_id: the id of the quantities stored in this price level
:type price: Price
:type quantity_wallet_id: str'
| def _remove_price_level(self, price, quantity_wallet_id):
| assert isinstance(price, Price), type(price)
self._depth[(price.wallet_id, quantity_wallet_id)] -= 1
self._price_level_list_map[(price.wallet_id, quantity_wallet_id)].remove(price)
del self._price_map[price]
|
':param price: The price to check for
:type price: Price
:return: True if the price level exists, False otherwise
:rtype: bool'
| def _price_level_exists(self, price):
| assert isinstance(price, Price), type(price)
return (price in self._price_map)
|
':param order_id: The order id to search for
:type order_id: OrderId
:return: True if the tick exists, False otherwise
:rtype: bool'
| def tick_exists(self, order_id):
| assert isinstance(order_id, OrderId), type(order_id)
return (order_id in self._tick_map)
|
':param tick: The tick to insert
:type tick: Tick'
| def insert_tick(self, tick):
| assert isinstance(tick, Tick), type(tick)
if ((tick.price.wallet_id, tick.quantity.wallet_id) not in self._price_level_list_map):
self._price_level_list_map[(tick.price.wallet_id, tick.quantity.wallet_id)] = PriceLevelList()
self._depth[(tick.price.wallet_id, tick.quantity.wallet_id)] = 0
if... |
':param order_id: The order id of the tick that needs to be removed
:type order_id: OrderId'
| def remove_tick(self, order_id):
| assert isinstance(order_id, OrderId), type(order_id)
tick = self.get_tick(order_id)
tick.price_level().remove_tick(tick)
if (len(tick.price_level()) == 0):
self._remove_price_level(tick.price, tick.quantity.wallet_id)
del self._tick_map[order_id]
|
':return: PriceLevelList'
| def get_price_level_list(self, price_wallet_id, quantity_wallet_id):
| return self._price_level_list_map[(price_wallet_id, quantity_wallet_id)]
|
'Returns the combinations (price wallet id, quantity wallet id) available in the side.'
| def get_price_level_list_wallets(self):
| return self._price_level_list_map.keys()
|
'Return the maximum price that a tick is listed for on this side of the order book
:rtype: Price'
| def get_max_price(self, price_wallet_id, quantity_wallet_id):
| key = (price_wallet_id, quantity_wallet_id)
if ((key in self._depth) and (self._depth[key] > 0)):
return self.get_price_level_list(price_wallet_id, quantity_wallet_id).max_key()
else:
return None
|
'Return the minimum price that a tick is listed for on this side of the order book
:rtype: Price'
| def get_min_price(self, price_wallet_id, quantity_wallet_id):
| key = (price_wallet_id, quantity_wallet_id)
if ((key in self._depth) and (self._depth[key] > 0)):
return self.get_price_level_list(price_wallet_id, quantity_wallet_id).min_key()
else:
return None
|
'Return the price level for the maximum price
:rtype: PriceLevel'
| def get_max_price_list(self, price_wallet_id, quantity_wallet_id):
| key = (price_wallet_id, quantity_wallet_id)
if ((key in self._depth) and (self._depth[key] > 0)):
return self.get_price_level(self.get_max_price(price_wallet_id, quantity_wallet_id))
else:
return None
|
'Return the price level for the minimum price
:rtype: PriceLevel'
| def get_min_price_list(self, price_wallet_id, quantity_wallet_id):
| key = (price_wallet_id, quantity_wallet_id)
if ((key in self._depth) and (self._depth[key] > 0)):
return self.get_price_level(self.get_min_price(price_wallet_id, quantity_wallet_id))
else:
return None
|
'Return a list describing all ticks in this side.
:rtype: list'
| def get_list_representation(self):
| rlist = []
for (price_type, quantity_type) in self._price_level_list_map.keys():
rlist.append({'price_type': price_type, 'quantity_type': quantity_type, 'ticks': self._price_level_list_map[(price_type, quantity_type)].get_ticks_list()})
return rlist
|
':type order_repository: OrderRepository'
| def __init__(self, order_repository):
| super(OrderManager, self).__init__()
self._logger = logging.getLogger(self.__class__.__name__)
self._logger.info('Market OrderManager initialized')
assert isinstance(order_repository, OrderRepository), type(order_repository)
self.order_repository = order_repository
|
'Create an ask order (sell order)
:param price: The price for the order
:param quantity: The quantity of the order
:param timeout: The timeout of the order, when does the order need to be timed out
:type price: Price
:type quantity: Quantity
:type timeout: Timeout
:return: The order that is created
:rtype: Order'
| def create_ask_order(self, price, quantity, timeout):
| assert isinstance(price, Price), type(price)
assert isinstance(quantity, Quantity), type(quantity)
assert isinstance(timeout, Timeout), type(timeout)
order = Order(self.order_repository.next_identity(), price, quantity, timeout, Timestamp.now(), True)
self.order_repository.add(order)
self._logge... |
'Create a bid order (buy order)
:param price: The price for the order
:param quantity: The quantity of the order
:param timeout: The timeout of the order, when does the order need to be timed out
:type price: Price
:type quantity: Quantity
:type timeout: Timeout
:return: The order that is created
:rtype: Order'
| def create_bid_order(self, price, quantity, timeout):
| assert isinstance(price, Price), type(price)
assert isinstance(quantity, Quantity), type(quantity)
assert isinstance(timeout, Timeout), type(timeout)
order = Order(self.order_repository.next_identity(), price, quantity, timeout, Timestamp.now(), False)
self.order_repository.add(order)
self._logg... |
'Cancel an order that was created by the user.
:return: The order that is created
:rtype: Order'
| def cancel_order(self, order_id):
| assert isinstance(order_id, OrderId), type(order_id)
order = self.order_repository.find_by_id(order_id)
if order:
order.cancel()
self.order_repository.update(order)
self._logger.info(('Order cancelled with id: ' + str(order_id)))
|
':param trader_id: String representing the trader id
:type trader_id: str
:raises ValueError: Thrown when one of the arguments are invalid'
| def __init__(self, trader_id):
| super(TraderId, self).__init__()
if (not isinstance(trader_id, str)):
raise ValueError('Trader id must be a string')
try:
int(trader_id, 16)
except ValueError:
raise ValueError('Trader id must be hexadecimal')
self._trader_id = trader_id
|
':param message_number: String representing the number of a message
:type message_number: str
:raises ValueError: Thrown when one of the arguments are invalid'
| def __init__(self, message_number):
| super(MessageNumber, self).__init__()
if (not isinstance(message_number, str)):
raise ValueError('Message number must be a string')
self._message_number = message_number
|
':param trader_id: The trader id who created the message
:param message_number: The number of the message created
:type trader_id: TraderId
:type message_number: MessageNumber'
| def __init__(self, trader_id, message_number):
| super(MessageId, self).__init__()
assert isinstance(trader_id, TraderId), type(trader_id)
assert isinstance(message_number, MessageNumber), type(message_number)
self._trader_id = trader_id
self._message_number = message_number
|
':rtype: TraderId'
| @property
def trader_id(self):
| return self._trader_id
|
':rtype: MessageNumber'
| @property
def message_number(self):
| return self._message_number
|
'format: <trader_id>.<message_number>
:rtype: str'
| def __str__(self):
| return ('%s.%s' % (self._trader_id, self._message_number))
|
'Don\'t use this class directly, use on of its implementations
:param message_id: A message id to identify the message
:param timestamp: A timestamp when the message was created
:type message_id: MessageId
:type timestamp: Timestamp'
| def __init__(self, message_id, timestamp):
| super(Message, self).__init__()
assert isinstance(message_id, MessageId), type(message_id)
assert isinstance(timestamp, Timestamp), type(timestamp)
self._message_id = message_id
self._timestamp = timestamp
|
':rtype: MessageId'
| @property
def message_id(self):
| return self._message_id
|
':rtype: Timestamp'
| @property
def timestamp(self):
| return self._timestamp
|
':param wallet_address: String representation of a wallet address
:type wallet_address: str
:raises ValueError: Thrown when one of the arguments are invalid'
| def __init__(self, wallet_address):
| super(WalletAddress, self).__init__()
if (not isinstance(wallet_address, str)):
raise ValueError('Wallet address must be a string')
self._wallet_address = wallet_address
|
'Do not use this class directly
Make a subclass of this class with a specific implementation for a storage backend'
| def __init__(self):
| super(OrderRepository, self).__init__()
self._logger = logging.getLogger(self.__class__.__name__)
|
':param mid: Hex encoded version of the member id of this node
:type mid: str'
| def __init__(self, mid):
| super(MemoryOrderRepository, self).__init__()
self._logger.info('Memory order repository used')
try:
int(mid, 16)
except ValueError:
raise ValueError('Encoded member id must be hexadecimal')
self._mid = mid
self._next_id = 0
self._orders = {}
|
':rtype: [Order]'
| def find_all(self):
| return self._orders.values()
|
':param order_id: The order id to look for
:type order_id: OrderId
:return: The order or null if it cannot be found
:rtype: Order'
| def find_by_id(self, order_id):
| assert isinstance(order_id, OrderId), type(order_id)
self._logger.debug((('Order with the id: ' + str(order_id)) + ' was searched for in the order repository'))
return self._orders.get(order_id)
|
':type order: Order'
| def add(self, order):
| assert isinstance(order, Order), type(order)
self._logger.debug((('Order with the id: ' + str(order.order_id)) + ' was added to the order repository'))
self._orders[order.order_id] = order
|
':type order: Order'
| def update(self, order):
| assert isinstance(order, Order), type(order)
self._logger.debug((('Order with the id: ' + str(order.order_id)) + ' was updated to the order repository'))
self._orders[order.order_id] = order
|
':type order_id: OrderId'
| def delete_by_id(self, order_id):
| assert isinstance(order_id, OrderId), type(order_id)
self._logger.debug((('Order with the id: ' + str(order_id)) + ' was deleted from the order repository'))
del self._orders[order_id]
|
':rtype: OrderId'
| def next_identity(self):
| self._next_id += 1
return OrderId(TraderId(self._mid), OrderNumber(self._next_id))
|
':param mid: Hex encoded version of the member id of this node
:type mid: str'
| def __init__(self, mid, persistence):
| super(DatabaseOrderRepository, self).__init__()
self._logger.info('Memory order repository used')
try:
int(mid, 16)
except ValueError:
raise ValueError('Encoded member id must be hexadecimal')
self._mid = mid
self.persistence = persistence
|
':rtype: [Order]'
| def find_all(self):
| return self.persistence.get_all_orders()
|
':param order_id: The order id to look for
:type order_id: OrderId
:return: The order or null if it cannot be found
:rtype: Order'
| def find_by_id(self, order_id):
| assert isinstance(order_id, OrderId), type(order_id)
self._logger.debug((('Order with the id: ' + str(order_id)) + ' was searched for in the order repository'))
return self.persistence.get_order(order_id)
|
':param order: The order to add to the database
:type order: Order'
| def add(self, order):
| self.persistence.add_order(order)
|
':param order: The order to update
:type order: Order'
| def update(self, order):
| self.delete_by_id(order.order_id)
self.add(order)
|
':param order_id: The id of the order to remove'
| def delete_by_id(self, order_id):
| self.persistence.delete_order(order_id)
|
':rtype OrderId'
| def next_identity(self):
| return OrderId(TraderId(self._mid), OrderNumber(self.persistence.get_next_order_number()))
|
':param tick: A tick to represent in the order book
:param price_level: A price level to place the tick in
:type tick: Tick
:type price_level: PriceLevel'
| def __init__(self, tick, price_level):
| assert isinstance(tick, Tick), type(tick)
self._tick = tick
self._price_level = price_level
self._prev_tick = None
self._next_tick = None
|
':rtype: Tick'
| @property
def tick(self):
| return self._tick
|
':rtype: OrderId'
| @property
def order_id(self):
| return self._tick.order_id
|
':rtype: Price'
| @property
def price(self):
| return self._tick.price
|
':rtype: Quantity'
| @property
def quantity(self):
| return self._tick.quantity
|
':param new_quantity: The new quantity
:type new_quantity: Quantity'
| @quantity.setter
def quantity(self, new_quantity):
| assert isinstance(new_quantity, Quantity), type(new_quantity)
self._price_level.depth -= (self._tick.quantity - new_quantity)
self._tick.quantity = new_quantity
|
'Return if the tick is still valid
:return: True if valid, False otherwise
:rtype: bool'
| def is_valid(self):
| return self._tick.is_valid()
|
':return: The price level the tick was placed in
:rtype: PriceLevel'
| def price_level(self):
| return self._price_level
|
':rtype: TickEntry'
| @property
def prev_tick(self):
| return self._prev_tick
|
':param new_prev_tick: The new previous tick
:type new_prev_tick: TickEntry'
| @prev_tick.setter
def prev_tick(self, new_prev_tick):
| self._prev_tick = new_prev_tick
|
':rtype: TickEntry'
| @property
def next_tick(self):
| return self._next_tick
|
':param new_next_tick: The new previous tick
:type new_next_tick: TickEntry'
| @next_tick.setter
def next_tick(self, new_next_tick):
| self._next_tick = new_next_tick
|
'format: <quantity> @ <price>
:rtype: str'
| def __str__(self):
| return ('%s DCTB @ DCTB %s' % (str(self._tick.quantity), str(self._tick.price)))
|
':type price: Price
:type price_level: PriceLevel'
| def insert(self, price, price_level):
| assert isinstance(price, Price), type(price)
assert isinstance(price_level, PriceLevel), type(price_level)
self._price_list.append(price)
self._price_list.sort()
self._price_level_dictionary[price] = price_level
|
':type price: Price'
| def remove(self, price):
| assert isinstance(price, Price), type(price)
self._price_list.remove(price)
del self._price_level_dictionary[price]
|
'Returns (price, price_level) pair where price is successor to given price
:type price: Price
:rtype: (Price, PriceLevel)'
| def succ_item(self, price):
| assert isinstance(price, Price), type(price)
index = (self._price_list.index(price) + 1)
if (index >= len(self._price_list)):
raise IndexError
succ_price = self._price_list[index]
return (succ_price, self._price_level_dictionary[succ_price])
|
'Returns (price, price_level) pair where price is predecessor to given price
:type price: Price
:rtype: (Price, PriceLevel)'
| def prev_item(self, price):
| assert isinstance(price, Price), type(price)
index = (self._price_list.index(price) - 1)
if (index < 0):
raise IndexError
prev_price = self._price_list[index]
return (prev_price, self._price_level_dictionary[prev_price])
|
'Return the lowest price in the price level list
:rtype: Price'
| def min_key(self):
| return self._price_list[0]
|
'Return the highest price in the price level list
:rtype: Price'
| def max_key(self):
| return self._price_list[(-1)]
|
'Returns a sorted list of price, price_level tuples
:param reverse: When true returns the reversed sorted list of price, price_level tuples
:type reverse: bool
:rtype: List[(Price, PriceLevel)]'
| def items(self, reverse=False):
| items = []
for price in self._price_list:
if reverse:
items.insert(0, (price, self._price_level_dictionary[price]))
else:
items.append((price, self._price_level_dictionary[price]))
return items
|
'Returns a list describing all ticks.
:return: list'
| def get_ticks_list(self):
| ticks_list = []
for (_, price_level) in self.items():
for tick in price_level:
ticks_list.append(tick.tick.to_dictionary())
return ticks_list
|
':param mid: Hex encoded version of the member id of this node
:type mid: str'
| def __init__(self, mid):
| super(MemoryMessageRepository, self).__init__()
try:
int(mid, 16)
except ValueError:
raise ValueError('Encoded public key must be hexadecimal')
self._mid = mid
self._next_id = 0
|
':rtype: MessageId'
| def next_identity(self):
| self._next_id += 1
return MessageId(TraderId(self._mid), MessageNumber(str(self._next_id)))
|
'Sets up the persistence layer ready for use.
:param working_directory: Path to the working directory
that will contain the the db at working directory/DATABASE_PATH
:return:'
| def __init__(self, working_directory):
| super(MarketDB, self).__init__(path.join(working_directory, DATABASE_PATH))
self.open()
|
'Return all orders in the database.'
| def get_all_orders(self):
| db_result = self.execute(u'SELECT * FROM orders').fetchall()
return [Order.from_database(db_item, self.get_reserved_ticks(OrderId(TraderId(str(db_item[0])), OrderNumber(db_item[1])))) for db_item in db_result]
|
'Return an order with a specific id.'
| def get_order(self, order_id):
| db_result = self.execute(u'SELECT * FROM orders WHERE trader_id = ? AND order_number = ?', (unicode(order_id.trader_id), unicode(order_id.order_number))).fetchone()
return (Order.from_database(db_result, self.get_reserved_ticks(order_id)) if db_result else None)
|
'Add a specific order to the database'
| def add_order(self, order):
| self.execute(u'INSERT INTO orders (trader_id, order_number, price, price_type, quantity, quantity_type,traded_quantity, timeout, order_timestamp, completed_timestamp, is_ask, cancelled) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)', order.to_database())
self.commit()
for (reserv... |
'Delete a specific order from the database'
| def delete_order(self, order_id):
| self.execute(u'DELETE FROM orders WHERE trader_id = ? AND order_number = ?', (unicode(order_id.trader_id), unicode(order_id.order_number)))
self.delete_reserved_ticks(order_id)
|
'Return the next order number from the database'
| def get_next_order_number(self):
| highest_order_number = self.execute(u'SELECT MAX(order_number) FROM orders').fetchone()
if (not highest_order_number[0]):
return 1
return (highest_order_number[0] + 1)
|
'Delete all reserved ticks from a specific order'
| def delete_reserved_ticks(self, order_id):
| self.execute(u'DELETE FROM orders_reserved_ticks WHERE trader_id = ? AND order_number = ?', (unicode(order_id.trader_id), unicode(order_id.order_number)))
|
'Add a reserved tick to the database'
| def add_reserved_tick(self, order_id, reserved_order_id, quantity):
| self.execute(u'INSERT INTO orders_reserved_ticks (trader_id, order_number, reserved_trader_id, reserved_order_number,quantity, quantity_type) VALUES(?,?,?,?,?,?)', (unicode(order_id.trader_id), unicode(order_id.order_number), unicode(reserved_order_id.trader_id), unicode(reserved_order_id.or... |
'Get all reserved ticks for a specific order.'
| def get_reserved_ticks(self, order_id):
| db_results = self.execute(u'SELECT * FROM orders_reserved_ticks WHERE trader_id = ? AND order_number = ?', (unicode(order_id.trader_id), unicode(order_id.order_number))).fetchall()
return [(OrderId(TraderId(str(data[2])), OrderNumber(data[3])), Quantity(data[4], str(data[5]))) f... |
'Return all transactions in the database.'
| def get_all_transactions(self):
| db_result = self.execute(u'SELECT * FROM transactions').fetchall()
return [Transaction.from_database(db_item, self.get_payments(TransactionId(TraderId(str(db_item[0])), TransactionNumber(db_item[1])))) for db_item in db_result]
|
'Return a transaction with a specific id.'
| def get_transaction(self, transaction_id):
| db_result = self.execute(u'SELECT * FROM transactions WHERE trader_id = ? AND transaction_number = ?', (unicode(transaction_id.trader_id), unicode(transaction_id.transaction_number))).fetchone()
return (Transaction.from_database(db_result, self.get_payments(transaction_id)) if d... |
'Add a specific transaction to the database'
| def add_transaction(self, transaction):
| self.execute(u'INSERT INTO transactions (trader_id, transaction_number, order_trader_id, order_number,partner_trader_id, partner_order_number, price, price_type, transferred_price, quantity, quantity_type,transferred_quantity, transaction_timestamp, sent_wallet_info, rec... |
'Delete a specific transaction from the database'
| def delete_transaction(self, transaction_id):
| self.execute(u'DELETE FROM transactions WHERE trader_id = ? AND transaction_number = ?', (unicode(transaction_id.trader_id), unicode(transaction_id.transaction_number)))
self.delete_payments(transaction_id)
|
'Return the next transaction number from the database'
| def get_next_transaction_number(self):
| highest_transaction_number = self.execute(u'SELECT MAX(transaction_number) FROM transactions').fetchone()
if (not highest_transaction_number[0]):
return 1
return (highest_transaction_number[0] + 1)
|
'Add a specific transaction to the database'
| def add_payment(self, payment):
| self.execute(u'INSERT INTO payments (trader_id, message_number, transaction_trader_id, transaction_number, payment_id,transferee_quantity, quantity_type, transferee_price, price_type, address_from, address_to, timestamp,success) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?)', payment.t... |
'Return all payment tied to a specific transaction.'
| def get_payments(self, transaction_id):
| db_result = self.execute(u'SELECT * FROM payments WHERE transaction_trader_id = ? AND transaction_number = ?ORDER BY timestamp ASC', (unicode(transaction_id.trader_id), unicode(transaction_id.transaction_number))).fetchall()
return [Payment.from_database(db_item) for db... |
'Delete all payments that are associated with a specific transaction'
| def delete_payments(self, transaction_id):
| self.execute(u'DELETE FROM payments WHERE transaction_trader_id = ? AND transaction_number = ?', (unicode(transaction_id.trader_id), unicode(transaction_id.transaction_number)))
|
'Add a specific tick to the database'
| def add_tick(self, tick):
| self.execute(u'INSERT INTO ticks (trader_id, message_number, order_number, price, price_type, quantity,quantity_type, timeout, timestamp, is_ask, public_key, signature) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)', tick.to_database())
self.commit()
|
'Remove all ticks from the database.'
| def delete_all_ticks(self):
| self.execute(u'DELETE FROM ticks')
|
'Get all ticks present in the database.'
| def get_ticks(self):
| return [Tick.from_database(db_tick) for db_tick in self.execute(u'SELECT * FROM ticks').fetchall()]
|
'Ensure the proper schema is used by the database.
:param database_version: Current version of the database.
:return:'
| def check_database(self, database_version):
| assert isinstance(database_version, unicode)
assert database_version.isdigit()
assert (int(database_version) >= 0)
database_version = int(database_version)
if (database_version < LATEST_DB_VERSION):
self.executescript(schema)
self.commit()
return LATEST_DB_VERSION
|
'Return the IDs of all wallets in the market community.'
| def get_wallet_ids(self):
| return self.wallets.keys()
|
'Returns the address of the Dispersy instance. This method is here to make the experiments on the DAS5 succeed;
direct messaging is not possible there with a wan address so we are using the local address instead.'
| def get_dispersy_address(self):
| return (self.dispersy.lan_address if self.use_local_address else self.dispersy.wan_address)
|
'Returns the address of the wallet with a specific identifier. Raises a ValueError if that wallet is not
available.'
| def get_wallet_address(self, wallet_id):
| if ((wallet_id not in self.wallets) or (not self.wallets[wallet_id].created)):
raise ValueError(('Wallet %s not available' % wallet_id))
return self.wallets[wallet_id].get_address()
|
'Return a tuple of incoming and outgoing payment address of an order.'
| def get_order_addresses(self, order):
| if order.is_ask():
return (WalletAddress(self.wallets[order.price.wallet_id].get_address()), WalletAddress(self.wallets[order.total_quantity.wallet_id].get_address()))
else:
return (WalletAddress(self.wallets[order.total_quantity.wallet_id].get_address()), WalletAddress(self.wallets[order.price.... |
'Try to find a match for a specific order and send proposed trade messages if there is a match
:param order: The order to match'
| def match(self, order):
| if (not self.matching_enabled):
return
proposed_trades = self.matching_engine.match_order(order)
if proposed_trades:
self.order_manager.order_repository.update(order)
self.send_proposed_trade_messages(proposed_trades)
|
'Lookup the ip for the public key to send a message to a specific node
:param trader_id: The public key of the node to send to
:type trader_id: TraderId
:return: The ip and port tuple: (<ip>, <port>)
:rtype: tuple'
| def lookup_ip(self, trader_id):
| assert isinstance(trader_id, TraderId), type(trader_id)
return self.mid_register.get(trader_id)
|
'Update the public key to ip mapping
:param trader_id: The public key of the node
:param ip: The ip and port of the node
:type trader_id: TraderId
:type ip: tuple'
| def update_ip(self, trader_id, ip):
| assert isinstance(trader_id, TraderId), type(trader_id)
assert isinstance(ip, tuple), type(ip)
assert isinstance(ip[0], str)
assert isinstance(ip[1], int)
self._logger.debug('Updating ip of trader %s to (%s, %s)', trader_id, ip[0], ip[1])
self.mid_register[trader_id] = ip
|
'Create an ask order (sell order)
:param price: The price for the order in btc
:param price_wallet_id: The type of the price (i.e. EUR, BTC)
:param quantity: The quantity of the order
:param price_wallet_id: The type of the price (i.e. EUR, BTC)
:param timeout: The timeout of the order, when does the order need to be t... | def create_ask(self, price, price_wallet_id, quantity, quantity_wallet_id, timeout):
| self.verify_offer_creation(price, price_wallet_id, quantity, quantity_wallet_id)
price = Price(price, price_wallet_id)
quantity = Quantity(quantity, quantity_wallet_id)
timeout = Timeout(timeout)
order = self.order_manager.create_ask_order(price, quantity, timeout)
self.match(order)
tick = T... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.