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])