def create_bid(self, price, quantity):
"""
Create a bid with a specific price and quantity
"""
new_bid = Bid(OrderId(TraderId('2'), OrderNumber(self.bid_count)),
Price(price, 'BTC'), Quantity(quantity, 'MC'),
Timeout(30), Timestamp.now())
self.bid_count += 1
return new_bid
def test_subtraction(self):
# Test for subtraction
self.assertEqual(Quantity(10, 'MC'), self.quantity2 - self.quantity1)
self.assertFalse(self.quantity2 is (self.quantity1 - self.quantity1))
self.assertEqual(NotImplemented, self.quantity1.__sub__(10))
self.assertEqual(NotImplemented,
self.quantity1.__sub__(self.quantity3))
with self.assertRaises(ValueError):
self.quantity1 - self.quantity2
def test_add_payment(self):
"""
Test the addition of a payment to a transaction
"""
self.transaction.add_payment(self.payment)
self.assertEqual(self.transaction.transferred_price, Price(2, 'BTC'))
self.assertEqual(self.transaction.transferred_quantity,
Quantity(3, 'MC'))
self.assertTrue(self.transaction.payments)
def test_to_network(self):
# Test for to network
self.assertEquals(
(TraderId('1'),
(TraderId('0'), MessageNumber('message_number'), OrderNumber(1),
TraderId('1'), OrderNumber(2), self.proposed_trade.proposal_id,
Price(63400, 'BTC'), Quantity(30,
'MC'), Timestamp(1462224447.117))),
self.proposed_trade.to_network())
def get_reserved_ticks(self, order_id):
"""
Get all reserved ticks for a specific order.
"""
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)))
return [(OrderId(TraderId(str(data[2])), OrderNumber(data[3])),
Quantity(data[4], str(data[5]))) for data in db_results]
def setUp(self, annotate=True):
yield super(MatchingEngineTestSuite, self).setUp(annotate=annotate)
# Object creation
self.ask = Ask(OrderId(TraderId('2'), OrderNumber(1)),
Price(100, 'BTC'), Quantity(30, 'MC'), Timeout(30),
Timestamp.now())
self.bid = Bid(OrderId(TraderId('4'), OrderNumber(2)),
Price(100, 'BTC'), Quantity(30, 'MC'), Timeout(30),
Timestamp.now())
self.ask_order = Order(OrderId(TraderId('5'), OrderNumber(3)),
Price(100, 'BTC'), Quantity(30, 'MC'),
Timeout(30), Timestamp.now(), True)
self.bid_order = Order(OrderId(TraderId('6'), OrderNumber(4)),
Price(100, 'BTC'), Quantity(30, 'MC'),
Timeout(30), Timestamp.now(), False)
self.order_book = OrderBook()
self.matching_engine = MatchingEngine(
PriceTimeStrategy(self.order_book))
def from_database(cls, data):
trader_id, message_number, order_number, price, price_type, quantity, quantity_type, timeout, timestamp,\
is_ask, public_key, signature = data
tick_cls = Ask if is_ask else Bid
message_id = MessageId(TraderId(str(trader_id)), MessageNumber(str(message_number)))
order_id = OrderId(TraderId(str(trader_id)), OrderNumber(order_number))
return tick_cls(message_id, order_id, Price(price, str(price_type)), Quantity(quantity, str(quantity_type)),
Timeout(timeout), Timestamp(timestamp), str(public_key.decode('hex')),
str(signature.decode('hex')))
def test_send_counter_trade(self):
"""
Test sending a counter trade
"""
self.market_community.update_ip(TraderId('b'), ('127.0.0.1', 1234))
counter_trade = CounterTrade(
MessageId(TraderId('a'), MessageNumber('2')), self.order.order_id,
OrderId(TraderId('b'), OrderNumber(3)), 1235, Price(3, 'MC'),
Quantity(4, 'BTC'), Timestamp.now())
self.market_community.send_counter_trade(counter_trade)
def test_pagerank_1(self):
"""
Test a very simple Temporal Pagerank computation
"""
self.insert_transaction('a', 'b', Quantity(1, 'BTC'), Price(1, 'MC'))
rep_dict = self.compute_reputations()
self.assertTrue('a' in rep_dict)
self.assertTrue('b' in rep_dict)
self.assertGreater(rep_dict['a'], 0)
self.assertGreater(rep_dict['b'], 0)
def setUp(self):
# Object creation
self.transaction_id = TransactionId(TraderId("0"),
TransactionNumber(1))
self.transaction = Transaction(self.transaction_id, Price(100, 'BTC'),
Quantity(30, 'MC'),
OrderId(TraderId('3'), OrderNumber(2)),
OrderId(TraderId('2'), OrderNumber(1)),
Timestamp(0.0))
self.proposed_trade = Trade.propose(
MessageId(TraderId('0'), MessageNumber('1')),
OrderId(TraderId('0'), OrderNumber(2)),
OrderId(TraderId('1'), OrderNumber(3)), Price(100, 'BTC'),
Quantity(30, 'MC'), Timestamp(0.0))
self.payment = Payment(
MessageId(TraderId("0"), MessageNumber("1")),
TransactionId(TraderId('2'), TransactionNumber(2)),
Quantity(3, 'MC'), Price(2, 'BTC'), WalletAddress('a'),
WalletAddress('b'), PaymentId('aaa'), Timestamp(4.0), True)
def setUp(self):
# Object creation
self.memory_transaction_repository = MemoryTransactionRepository("0")
self.transaction_id = TransactionId(TraderId("0"),
TransactionNumber(1))
self.transaction = Transaction(self.transaction_id, Price(100, 'BTC'),
Quantity(30, 'MC'),
OrderId(TraderId("0"), OrderNumber(1)),
OrderId(TraderId("2"), OrderNumber(2)),
Timestamp(0.0))
def test_cancel_order_not_found(self):
"""
Test whether a 404 is returned when we try to cancel an order that does not exist
"""
self.session.lm.market_community.order_manager.create_ask_order(
Price(3, 'DUM1'), Quantity(4, 'DUM2'), Timeout(3600))
self.should_check_equality = False
return self.do_request('market/orders/1234/cancel',
request_type='POST',
expected_code=404)
def test_cancel_order_invalid(self):
"""
Test whether an error is returned when we try to cancel an order that has expired
"""
order = self.session.lm.market_community.order_manager.create_ask_order(
Price(3, 'DUM1'), Quantity(4, 'DUM2'), Timeout(0))
order.set_verified()
self.session.lm.market_community.order_manager.order_repository.update(order)
self.should_check_equality = False
return self.do_request('market/orders/1/cancel', request_type='POST', expected_code=400)
def setUp(self, annotate=True):
yield super(AbstractTestMarketCommunity, self).setUp(annotate=annotate)
dummy1_wallet = DummyWallet1()
dummy2_wallet = DummyWallet2()
self.market_community = MarketCommunity(self.dispersy,
self.master_member,
self.member)
self.market_community.initialize(wallets={
dummy1_wallet.get_identifier():
dummy1_wallet,
dummy2_wallet.get_identifier():
dummy2_wallet
},
use_database=False)
self.market_community.use_local_address = True
self.dispersy._lan_address = ("127.0.0.1", 1234)
self.dispersy._endpoint.open(self.dispersy)
self.dispersy.attach_community(self.market_community)
eccrypto = ECCrypto()
ec = eccrypto.generate_key(u"curve25519")
member = Member(self.dispersy, ec, 1)
trader_id = hashlib.sha1(member.public_key).digest().encode('hex')
self.ask = Ask(OrderId(TraderId(trader_id), OrderNumber(1234)),
Price(63400, 'DUM1'), Quantity(30, 'DUM2'),
Timeout(3600), Timestamp.now())
self.bid = Bid(OrderId(TraderId(trader_id), OrderNumber(1235)),
Price(343, 'DUM1'), Quantity(22, 'DUM2'), Timeout(3600),
Timestamp.now())
self.order = Order(
OrderId(TraderId(self.market_community.mid), OrderNumber(24)),
Price(20, 'DUM1'), Quantity(30, 'DUM2'), Timeout(3600.0),
Timestamp.now(), False)
self.proposed_trade = Trade.propose(
MessageId(TraderId('0'), MessageNumber('message_number')),
OrderId(TraderId('0'), OrderNumber(23)),
OrderId(TraderId(self.market_community.mid), OrderNumber(24)),
Price(20, 'DUM1'), Quantity(30, 'DUM2'), Timestamp.now())
def next_payment(self, order_is_ask, min_unit, incremental):
if not incremental:
# Don't use incremental payments, just return the full amount
ret_val = self.total_quantity if order_is_ask else self.total_price
self._logger.debug(
"Returning %s for the next payment (no incremental payments)",
ret_val)
return ret_val
last_payment = self.last_payment(not order_is_ask)
if not last_payment:
# Just return the lowest unit possible
return Quantity(min_unit, self.total_quantity.wallet_id) if order_is_ask else \
Price(min_unit, self.total_price.wallet_id)
# We determine the percentage of the last payment of the total amount
if order_is_ask:
if self.transferred_price >= self.total_price: # Complete the trade
return self.total_quantity - self.transferred_quantity
percentage = float(last_payment.transferee_price) / float(
self.total_price)
transfer_amount = Transaction.unitize(
float(percentage * float(self.total_quantity)), min_unit) * 2
if transfer_amount > float(self.total_quantity -
self.transferred_quantity):
transfer_amount = float(self.total_quantity -
self.transferred_quantity)
return Quantity(transfer_amount, self.total_quantity.wallet_id)
else:
if self.transferred_quantity >= self.total_quantity: # Complete the trade
return self.total_price - self.transferred_price
percentage = float(last_payment.transferee_quantity) / float(
self.total_quantity)
transfer_amount = Transaction.unitize(
float(percentage * float(self.total_price)), min_unit) * 2
if transfer_amount > float(self.total_price -
self.transferred_price):
transfer_amount = float(self.total_price -
self.transferred_price)
return Price(transfer_amount, self.total_price.wallet_id)
def setUp(self, annotate=True):
yield super(AbstractTestOrderBook, self).setUp(annotate=annotate)
# Object creation
self.ask = Ask(OrderId(TraderId('0'), OrderNumber(1)), Price(100, 'BTC'), Quantity(30, 'MC'),
Timeout(1462224447.117), Timestamp(1462224447.117))
self.invalid_ask = Ask(OrderId(TraderId('0'), OrderNumber(1)), Price(100, 'BTC'), Quantity(30, 'MC'),
Timeout(0), Timestamp(0.0))
self.ask2 = Ask(OrderId(TraderId('1'), OrderNumber(1)), Price(400, 'BTC'), Quantity(30, 'MC'),
Timeout(1462224447.117), Timestamp(1462224447.117))
self.bid = Bid(OrderId(TraderId('2'), OrderNumber(1)), Price(200, 'BTC'), Quantity(30, 'MC'),
Timeout(1462224447.117), Timestamp(1462224447.117))
self.invalid_bid = Bid(OrderId(TraderId('0'), OrderNumber(1)), Price(100, 'BTC'), Quantity(30, 'MC'),
Timeout(0), Timestamp(0.0))
self.bid2 = Bid(OrderId(TraderId('3'), OrderNumber(1)), Price(300, 'BTC'), Quantity(30, 'MC'),
Timeout(1462224447.117), Timestamp(1462224447.117))
self.trade = Trade.propose(MessageId(TraderId('0'), MessageNumber(1)),
OrderId(TraderId('0'), OrderNumber(1)),
OrderId(TraderId('0'), OrderNumber(1)), Price(100, 'BTC'),
Quantity(30, 'MC'), Timestamp(1462224447.117))
self.order_book = OrderBook()
def setUp(self):
# Object creation
self.proposed_trade = Trade.propose(
MessageId(TraderId('0'), MessageNumber(1)),
OrderId(TraderId('0'), OrderNumber(1)),
OrderId(TraderId('1'), OrderNumber(2)), Price(63400, 'BTC'),
Quantity(30, 'MC'), Timestamp(1462224447.117))
self.declined_trade = Trade.decline(
MessageId(TraderId('0'), MessageNumber(1)),
Timestamp(1462224447.117), self.proposed_trade,
DeclinedTradeReason.ORDER_COMPLETED)
def from_database(cls, data, reserved_ticks):
"""
Create an Order object based on information in the database.
"""
trader_id, order_number, price, price_type, quantity, quantity_type, traded_quantity, timeout, \
order_timestamp, completed_timestamp, is_ask, cancelled = data
order_id = OrderId(TraderId(str(trader_id)), OrderNumber(order_number))
order = cls(order_id, Price(price, str(price_type)), Quantity(quantity, str(quantity_type)), Timeout(timeout),
Timestamp(order_timestamp), bool(is_ask))
order._traded_quantity = Quantity(traded_quantity, str(quantity_type))
order._cancelled = bool(cancelled)
if completed_timestamp:
order._completed_timestamp = Timestamp(completed_timestamp)
for reserved_order_id, quantity in reserved_ticks:
order.reserved_ticks[reserved_order_id] = quantity
order._reserved_quantity += quantity
return order
def add_trade(self, other_order_id, quantity):
assert isinstance(other_order_id, OrderId), type(other_order_id)
self._logger.debug("Adding trade for order %s with quantity %s (other id: %s)",
str(self.order_id), quantity, str(other_order_id))
self._traded_quantity += quantity
self.release_quantity_for_tick(other_order_id, quantity)
assert self.available_quantity >= Quantity(0, quantity.wallet_id), str(self.available_quantity)
if self.is_complete():
self._completed_timestamp = Timestamp.now()
def test_search_for_quantity_in_price_level(self):
"""
Test searching within a price level
"""
self.bid_order._order_id = self.ask.order_id
self.order_book.insert_ask(self.ask)
self.order_book.insert_ask(self.ask2)
matching_ticks = self.price_time_strategy._search_for_quantity_in_price_level(
self.bid_order.order_id, None, Quantity(10, 'MC'),
self.bid_order.price, False)
self.assertFalse(matching_ticks)
def test_match_order_different_price_level(self):
"""
Test for match order given an ask order and bid in different price levels
"""
self.order_book.insert_bid(self.bid2)
matching_ticks = self.price_time_strategy.match(
self.ask_order.order_id, self.ask_order.price,
self.ask_order.available_quantity, True)
self.assertEquals(1, len(matching_ticks))
self.assertEquals(Price(200, 'BTC'), self.bid2.price)
self.assertEquals(Quantity(30, 'MC'), matching_ticks[0][2])
def test_from_network(self):
# Test for from network
data = ProposedTrade.from_network(type('Data', (object,), {"trader_id": TraderId('0'),
"message_number": MessageNumber('message_number'),
"order_number": OrderNumber(1),
"recipient_trader_id": TraderId('1'),
"recipient_order_number": OrderNumber(2),
"proposal_id": 1234,
"timestamp": Timestamp(1462224447.117),
"price": Price(63400, 'BTC'),
"quantity": Quantity(30, 'MC')}))
self.assertEquals(MessageId(TraderId('0'), MessageNumber('message_number')), data.message_id)
self.assertEquals(OrderId(TraderId('0'), OrderNumber(1)), data.order_id)
self.assertEquals(OrderId(TraderId('1'), OrderNumber(2)),
data.recipient_order_id)
self.assertEquals(1234, data.proposal_id)
self.assertEquals(Price(63400, 'BTC'), data.price)
self.assertEquals(Quantity(30, 'MC'), data.quantity)
self.assertEquals(Timestamp(1462224447.117), data.timestamp)
def test_no_match_reserved(self):
"""
Test whether there is no match when we already reserved some quantity
"""
self.order_book.insert_bid(self.bid)
self.order_book.get_tick(self.bid.order_id).reserve_for_matching(
Quantity(30, 'MC'))
self.order_book.insert_ask(self.ask)
matching_ticks = self.matching_engine.match(
self.order_book.get_ask(self.ask.order_id))
self.assertEquals([], matching_ticks)
def test_verify_offer_creation(self):
"""
Test creation of an offer in the community
"""
self.assertRaises(RuntimeError,
self.market_community.verify_offer_creation,
Price(3, 'MC'), 'ABC', Quantity(4, 'BTC'), 'ABC')
self.assertRaises(RuntimeError,
self.market_community.verify_offer_creation,
Price(3, 'MC'), 'ABC', Quantity(4, 'BTC'), 'MC')
self.assertRaises(RuntimeError,
self.market_community.verify_offer_creation,
Price(1, 'DUM1'), 'DUM1', Quantity(1, 'BTC'), 'BTC')
self.assertRaises(RuntimeError,
self.market_community.verify_offer_creation,
Price(0.1, 'DUM1'), 'DUM1', Quantity(1,
'DUM2'), 'DUM2')
self.assertRaises(RuntimeError,
self.market_community.verify_offer_creation,
Price(1, 'DUM1'), 'DUM1', Quantity(0.1,
'DUM2'), 'DUM2')
def _match_ask(self, order_id, price, quantity, is_ask):
matched_ticks = []
if price <= self.order_book.get_bid_price(price.wallet_id, quantity.wallet_id) \
and quantity > Quantity(0, quantity.wallet_id):
# Scan the price levels in the order book
matched_ticks = self._search_for_quantity_in_order_book(
order_id,
self.order_book.get_bid_price(price.wallet_id, quantity.wallet_id),
self.order_book.get_bid_price_level(price.wallet_id, quantity.wallet_id),
quantity, price, is_ask)
return matched_ticks
def test_search_for_quantity_in_order_book_partial_ask(self):
"""
Test for protected search for quantity in order book partial ask
"""
self.order_book.insert_bid(self.bid)
self.order_book.insert_bid(self.bid2)
self.order_book.insert_bid(self.bid3)
self.order_book.insert_bid(self.bid4)
matching_ticks = self.price_time_strategy._search_for_quantity_in_order_book_partial_ask(
self.ask_order.order_id, Price(100, 'BTC'), Quantity(30, 'MC'), [],
self.ask_order.price, True)
self.assertEquals(0, len(matching_ticks))
def test_properties(self):
"""
Test the wallet info payload
"""
self.assertEquals(OrderNumber(2),
self.match_payload.recipient_order_number)
self.assertEquals(Quantity(20, 'MC'),
self.match_payload.match_quantity)
self.assertEquals(TraderId('1'), self.match_payload.match_trader_id)
self.assertEquals(TraderId('2'),
self.match_payload.matchmaker_trader_id)
self.assertEquals('a', self.match_payload.match_id)
def test_search_for_quantity_in_order_book_partial_bid_high(self):
"""
Test for protected search for quantity in order book partial bid when price is too high
"""
self.order_book.insert_ask(self.ask)
self.order_book.insert_ask(self.ask2)
self.order_book.insert_ask(self.ask3)
self.order_book.insert_ask(self.ask4)
matching_ticks = self.price_time_strategy._search_for_quantity_in_order_book_partial_bid(
self.bid_order.order_id, Price(100, 'BTC'), Quantity(30, 'MC'), [],
self.bid_order.price, False)
self.assertEquals(0, len(matching_ticks))
def test_create_payment_message(self):
"""
Test the creation of a payment message
"""
self.transaction.incoming_address = WalletAddress('abc')
self.transaction.outgoing_address = WalletAddress('def')
self.transaction.partner_incoming_address = WalletAddress('ghi')
self.transaction.partner_outgoing_address = WalletAddress('jkl')
payment_msg = self.transaction_manager.create_payment_message(
MessageId(TraderId("0"), MessageNumber('3')), PaymentId('abc'),
self.transaction, (Quantity(3, 'MC'), Price(4, 'BTC')), True)
self.assertIsInstance(payment_msg, Payment)
def test_match_order_bid(self):
"""
Test for match bid order
"""
self.order_book.insert_ask(self.ask)
matching_ticks = self.price_time_strategy.match(
self.bid_order.order_id, self.bid_order.price,
self.bid_order.available_quantity, False)
self.assertEquals(1, len(matching_ticks))
self.assertEquals(self.order_book.get_tick(self.ask.order_id),
matching_ticks[0][1])
self.assertEquals(Quantity(30, 'MC'), matching_ticks[0][2])
