def test_from_network(self):
# Test for from network
data = Payment.from_network(
type(
'Data', (object, ), {
"trader_id":
TraderId(b"0"),
"transaction_id":
TransactionId(TraderId(b'2'), TransactionNumber(2)),
"transferred_assets":
AssetAmount(3, 'BTC'),
"address_from":
WalletAddress('a'),
"address_to":
WalletAddress('b'),
"payment_id":
PaymentId('aaa'),
"timestamp":
Timestamp(4.0),
"success":
True
}))
self.assertEquals(TraderId(b"0"), data.trader_id)
self.assertEquals(TransactionId(TraderId(b'2'), TransactionNumber(2)),
data.transaction_id)
self.assertEquals(AssetAmount(3, 'BTC'), data.transferred_assets)
self.assertEquals(Timestamp(4.0), data.timestamp)
self.assertTrue(data.success)
def setUp(self):
# Object creation
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 from_database(cls, data, payments):
"""
Create a Transaction object based on information in the database.
"""
trader_id, transaction_number, order_trader_id, order_number, partner_trader_id, partner_order_number,\
asset1_amount, asset1_type, asset1_transferred, asset2_amount, asset2_type, asset2_transferred,\
transaction_timestamp, sent_wallet_info, received_wallet_info, incoming_address, outgoing_address,\
partner_incoming_address, partner_outgoing_address, match_id = data
transaction_id = TransactionId(TraderId(str(trader_id)), TransactionNumber(transaction_number))
transaction = cls(transaction_id,
AssetPair(AssetAmount(asset1_amount, str(asset1_type)),
AssetAmount(asset2_amount, str(asset2_type))),
OrderId(TraderId(str(order_trader_id)), OrderNumber(order_number)),
OrderId(TraderId(str(partner_trader_id)), OrderNumber(partner_order_number)),
Timestamp(float(transaction_timestamp)))
transaction._transferred_assets = AssetPair(AssetAmount(asset1_transferred, str(asset1_type)),
AssetAmount(asset2_transferred, str(asset2_type)))
transaction.sent_wallet_info = sent_wallet_info
transaction.received_wallet_info = received_wallet_info
transaction.incoming_address = WalletAddress(str(incoming_address))
transaction.outgoing_address = WalletAddress(str(outgoing_address))
transaction.partner_incoming_address = WalletAddress(str(partner_incoming_address))
transaction.partner_outgoing_address = WalletAddress(str(partner_outgoing_address))
transaction.match_id = str(match_id)
transaction._payments = payments
return transaction
def test_from_network(self):
# Test for from network
data = Payment.from_network(
type(
'Data', (object, ), {
"message_id":
MessageId(TraderId("0"), MessageNumber(1)),
"transaction_id":
TransactionId(TraderId('2'), TransactionNumber(2)),
"transferee_quantity":
Quantity(3, 'MC'),
"transferee_price":
Price(2, 'BTC'),
"address_from":
WalletAddress('a'),
"address_to":
WalletAddress('b'),
"payment_id":
PaymentId('aaa'),
"timestamp":
Timestamp(4.0),
"success":
True
}))
self.assertEquals(MessageId(TraderId("0"), MessageNumber(1)),
data.message_id)
self.assertEquals(TransactionId(TraderId('2'), TransactionNumber(2)),
data.transaction_id)
self.assertEquals(Quantity(3, 'MC'), data.transferee_quantity)
self.assertEquals(Price(2, 'BTC'), data.transferee_price)
self.assertEquals(Timestamp(4.0), data.timestamp)
self.assertTrue(data.success)
def setUp(self):
# Object creation
self.payment = Payment(TraderId("0"),
TransactionId(TraderId('2'), TransactionNumber(2)),
AssetAmount(3, 'BTC'),
WalletAddress('a'), WalletAddress('b'),
PaymentId('aaa'), Timestamp(4.0), True)
def from_database(cls, data, payments):
"""
Create a Transaction object based on information in the database.
"""
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, received_wallet_info, incoming_address, outgoing_address, partner_incoming_address,\
partner_outgoing_address, match_id = data
transaction_id = TransactionId(TraderId(str(trader_id)),
TransactionNumber(transaction_number))
transaction = cls(
transaction_id, Price(price, str(price_type)),
Quantity(quantity, str(quantity_type)),
OrderId(TraderId(str(order_trader_id)), OrderNumber(order_number)),
OrderId(TraderId(str(partner_trader_id)),
OrderNumber(partner_order_number)),
Timestamp(float(transaction_timestamp)))
transaction._transferred_price = Price(transferred_price,
str(price_type))
transaction._transferred_quantity = Quantity(transferred_quantity,
str(quantity_type))
transaction.sent_wallet_info = sent_wallet_info
transaction.received_wallet_info = received_wallet_info
transaction.incoming_address = WalletAddress(str(incoming_address))
transaction.outgoing_address = WalletAddress(str(outgoing_address))
transaction.partner_incoming_address = WalletAddress(
str(partner_incoming_address))
transaction.partner_outgoing_address = WalletAddress(
str(partner_outgoing_address))
transaction.match_id = str(match_id)
transaction._payments = payments
return transaction
def setUp(self):
# Object creation
self.payment_payload = PaymentPayload.Implementation(
MetaObject(), TraderId('0'), MessageNumber('1'), TraderId('2'),
TransactionNumber(2), Quantity(20, 'MC'), Price(10, 'BTC'),
WalletAddress('a'), WalletAddress('b'), PaymentId('3'),
Timestamp(0.0), True)
def setUp(self):
yield super(TestDatabase, self).setUp()
path = os.path.join(self.getStateDir(), 'sqlite')
if not os.path.exists(path):
os.makedirs(path)
self.database = MarketDB(self.getStateDir(), 'market')
self.order_id1 = OrderId(TraderId(b'3'), OrderNumber(4))
self.order_id2 = OrderId(TraderId(b'4'), OrderNumber(5))
self.order1 = Order(self.order_id1, AssetPair(AssetAmount(5, 'BTC'), AssetAmount(6, 'EUR')),
Timeout(3600), Timestamp.now(), True)
self.order2 = Order(self.order_id2, AssetPair(AssetAmount(5, 'BTC'), AssetAmount(6, 'EUR')),
Timeout(3600), Timestamp.now(), False)
self.order2.reserve_quantity_for_tick(OrderId(TraderId(b'3'), OrderNumber(4)), 3)
self.transaction_id1 = TransactionId(TraderId(b"0"), TransactionNumber(4))
self.transaction1 = Transaction(self.transaction_id1, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MB')),
OrderId(TraderId(b"0"), OrderNumber(1)),
OrderId(TraderId(b"1"), OrderNumber(2)), Timestamp(20.0))
self.payment1 = Payment(TraderId(b"0"), self.transaction_id1, AssetAmount(5, 'BTC'),
WalletAddress('abc'), WalletAddress('def'), PaymentId("abc"), Timestamp(20.0), False)
self.transaction1.add_payment(self.payment1)
def setUp(self, annotate=True):
yield super(TestDatabase, self).setUp(annotate=annotate)
path = os.path.join(self.getStateDir(), 'sqlite')
if not os.path.exists(path):
os.makedirs(path)
self.database = MarketDB(self.getStateDir())
self.order_id1 = OrderId(TraderId('3'), OrderNumber(4))
self.order_id2 = OrderId(TraderId('4'), OrderNumber(5))
self.order1 = Order(self.order_id1, Price(5,
'EUR'), Quantity(6, 'BTC'),
Timeout(3600), Timestamp.now(), True)
self.order2 = Order(self.order_id2, Price(5,
'EUR'), Quantity(6, 'BTC'),
Timeout(3600), Timestamp.now(), False)
self.transaction_id1 = TransactionId(TraderId("0"),
TransactionNumber(4))
self.transaction1 = Transaction(self.transaction_id1,
Price(100, 'BTC'), Quantity(30, 'MC'),
OrderId(TraderId("0"), OrderNumber(1)),
OrderId(TraderId("1"), OrderNumber(2)),
Timestamp(20.0))
self.payment1 = Payment(MessageId(TraderId("0"), MessageNumber("4")),
self.transaction_id1, Quantity(5, 'MC'),
Price(6, 'BTC'), WalletAddress('abc'),
WalletAddress('def'), PaymentId("abc"),
Timestamp(20.0), False)
self.transaction1.add_payment(self.payment1)
def from_unpack_list(cls, trader_id, timestamp, transaction_trader_id,
transaction_number, incoming_address,
outgoing_address):
return WalletInfoPayload(
TraderId(trader_id), Timestamp(timestamp),
TransactionId(TraderId(transaction_trader_id),
TransactionNumber(transaction_number)),
WalletAddress(incoming_address), WalletAddress(outgoing_address))
def test_properties(self):
"""
Test the wallet info payload
"""
self.assertEquals(WalletAddress('a'),
self.wallet_info_payload.incoming_address)
self.assertEquals(WalletAddress('b'),
self.wallet_info_payload.outgoing_address)
def from_unpack_list(cls, trader_id, message_number, timestamp, transaction_trader_id, transaction_number,
transferee_quantity, transferee_quantity_type, transferee_price, transferee_price_type,
address_from, address_to, payment_id, success):
return PaymentPayload(MessageId(TraderId(trader_id), MessageNumber(message_number)), Timestamp(timestamp),
TransactionId(TraderId(transaction_trader_id), TransactionNumber(transaction_number)),
Quantity(transferee_quantity, transferee_quantity_type),
Price(transferee_price, transferee_price_type),
WalletAddress(address_from), WalletAddress(address_to), PaymentId(payment_id),
success)
def from_unpack_list(cls, trader_id, timestamp, transaction_trader_id,
transaction_number, transferred_amount,
transferred_type, address_from, address_to,
payment_id, success):
return PaymentPayload(
TraderId(trader_id), Timestamp(timestamp),
TransactionId(TraderId(transaction_trader_id),
TransactionNumber(transaction_number)),
AssetAmount(transferred_amount, transferred_type),
WalletAddress(address_from), WalletAddress(address_to),
PaymentId(payment_id), success)
def test_to_network(self):
# Test for to network
data = self.payment.to_network()
self.assertEquals(data[0], TraderId("0"))
self.assertEquals(data[1], Timestamp(4.0))
self.assertEquals(data[2], TransactionId(TraderId("2"), TransactionNumber(2)))
self.assertEquals(data[3], AssetAmount(3, 'BTC'))
self.assertEquals(data[4], WalletAddress('a'))
self.assertEquals(data[5], WalletAddress('b'))
self.assertEquals(data[6], PaymentId('aaa'))
self.assertEquals(data[7], True)
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 from_block(cls, block_info):
"""
Create a Transaction object based on information in a tx_init/tx_done block.
"""
trader_id = block_info["tx"]["trader_id"]
transaction_number = block_info["tx"]["transaction_number"]
order_trader_id = block_info["tx"]["trader_id"]
order_number = block_info["tx"]["order_number"]
partner_trader_id = block_info["tx"]["partner_trader_id"]
partner_order_number = block_info["tx"]["partner_order_number"]
asset1_amount = block_info["tx"]["assets"]["first"]["amount"]
asset1_type = block_info["tx"]["assets"]["first"]["type"]
asset1_transferred = block_info["tx"]["transferred"]["first"]["amount"]
asset2_amount = block_info["tx"]["assets"]["second"]["amount"]
asset2_type = block_info["tx"]["assets"]["second"]["type"]
asset2_transferred = block_info["tx"]["transferred"]["second"][
"amount"]
transaction_timestamp = block_info["tx"]["timestamp"]
sent_wallet_info = False
received_wallet_info = False
incoming_address = None
outgoing_address = None
partner_incoming_address = None
partner_outgoing_address = None
match_id = ''
transaction_id = TransactionId(TraderId(bytes(trader_id)),
TransactionNumber(transaction_number))
transaction = cls(
transaction_id,
AssetPair(AssetAmount(asset1_amount, str(asset1_type)),
AssetAmount(asset2_amount, str(asset2_type))),
OrderId(TraderId(bytes(order_trader_id)),
OrderNumber(order_number)),
OrderId(TraderId(bytes(partner_trader_id)),
OrderNumber(partner_order_number)),
Timestamp(float(transaction_timestamp)))
transaction._transferred_assets = AssetPair(
AssetAmount(asset1_transferred, str(asset1_type)),
AssetAmount(asset2_transferred, str(asset2_type)))
transaction.sent_wallet_info = sent_wallet_info
transaction.received_wallet_info = received_wallet_info
transaction.incoming_address = WalletAddress(str(incoming_address))
transaction.outgoing_address = WalletAddress(str(outgoing_address))
transaction.partner_incoming_address = WalletAddress(
str(partner_incoming_address))
transaction.partner_outgoing_address = WalletAddress(
str(partner_outgoing_address))
transaction.match_id = str(match_id)
return transaction
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(TraderId(b"0"),
PaymentId('abc'), self.transaction,
AssetAmount(1, 'BTC'),
True)
self.assertIsInstance(payment_msg, Payment)
def from_database(cls, data):
"""
Create a Payment object based on information in the database.
"""
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 = data
message_id = MessageId(TraderId(str(trader_id)), MessageNumber(str(message_number)))
transaction_id = TransactionId(TraderId(str(transaction_trader_id)), TransactionNumber(transaction_number))
return cls(message_id, transaction_id, Quantity(transferee_quantity, str(quantity_type)),
Price(transferee_price, str(price_type)), WalletAddress(str(address_from)),
WalletAddress(str(address_to)), PaymentId(str(payment_id)), Timestamp(float(timestamp)),
bool(success))
def from_database(cls, data):
"""
Create a Payment object based on information in the database.
"""
trader_id, transaction_trader_id, transaction_number, payment_id, transferred_amount, transferred_id,\
address_from, address_to, timestamp, success = data
transaction_id = TransactionId(TraderId(str(transaction_trader_id)),
TransactionNumber(transaction_number))
return cls(TraderId(str(trader_id)), transaction_id,
AssetAmount(transferred_amount, str(transferred_id)),
WalletAddress(str(address_from)),
WalletAddress(str(address_to)), PaymentId(str(payment_id)),
Timestamp(float(timestamp)), bool(success))
def test_to_network(self):
# Test for to network
data = self.payment.to_network()
self.assertEquals(data[0], MessageId(TraderId("0"), MessageNumber(1)))
self.assertEquals(data[1], Timestamp(4.0))
self.assertEquals(data[2],
TransactionId(TraderId("2"), TransactionNumber(2)))
self.assertEquals(data[3], Quantity(3, 'MC'))
self.assertEquals(data[4], Price(2, 'BTC'))
self.assertEquals(data[5], WalletAddress('a'))
self.assertEquals(data[6], WalletAddress('b'))
self.assertEquals(data[7], PaymentId('aaa'))
self.assertEquals(data[8], True)
def add_transaction_and_payment(self):
"""
Add a transaction and a payment to the market
"""
proposed_trade = Trade.propose(MessageId(TraderId('0'), MessageNumber('message_number')),
OrderId(TraderId('0'), OrderNumber(1)),
OrderId(TraderId('1'), OrderNumber(2)),
Price(63400, 'BTC'), Quantity(30, 'MC'), Timestamp(1462224447.117))
transaction = self.session.lm.market_community.transaction_manager.create_from_proposed_trade(proposed_trade)
payment = Payment(MessageId(TraderId("0"), MessageNumber("1")), transaction.transaction_id,
Quantity(0, 'MC'), Price(20, 'BTC'), WalletAddress('a'), WalletAddress('b'),
PaymentId('aaa'), Timestamp(4.0), True)
transaction.add_payment(payment)
self.session.lm.market_community.transaction_manager.transaction_repository.update(transaction)
return transaction
def test_properties(self):
"""
Test the payment payload
"""
self.assertEquals(MessageNumber('1'),
self.payment_payload.message_number)
self.assertEquals(TransactionNumber(2),
self.payment_payload.transaction_number)
self.assertEquals(Price(10, 'BTC'),
self.payment_payload.transferee_price)
self.assertEquals(Quantity(20, 'MC'),
self.payment_payload.transferee_quantity)
self.assertEquals('3', str(self.payment_payload.payment_id))
self.assertEquals(Timestamp(0.0), self.payment_payload.timestamp)
self.assertEquals(WalletAddress('a'),
self.payment_payload.address_from)
self.assertEquals(WalletAddress('b'), self.payment_payload.address_to)
self.assertEquals(True, self.payment_payload.success)
def setUp(self):
# Object creation
self.transaction_id = TransactionId(TraderId("0"),
TransactionNumber(1))
self.transaction = Transaction(
self.transaction_id,
AssetPair(AssetAmount(100, 'BTC'), AssetAmount(100, 'MB')),
OrderId(TraderId('3'), OrderNumber(2)),
OrderId(TraderId('2'), OrderNumber(1)), Timestamp(0.0))
self.proposed_trade = Trade.propose(
TraderId('0'), OrderId(TraderId('0'), OrderNumber(2)),
OrderId(TraderId('1'), OrderNumber(3)),
AssetPair(AssetAmount(100, 'BTC'), AssetAmount(100, 'MB')),
Timestamp(0.0))
self.payment = Payment(
TraderId("0"), TransactionId(TraderId('2'), TransactionNumber(2)),
AssetAmount(3, 'MB'), WalletAddress('a'), WalletAddress('b'),
PaymentId('aaa'), Timestamp(4.0), True)
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 test_encode_decode_wallet_info(self):
"""
Test encoding and decoding of wallet info
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"wallet-info")
wallet_payload = WalletInfoPayload.Implementation(
meta_msg, TraderId('abc'), MessageNumber('3'), TraderId('def'),
TransactionNumber(5), WalletAddress('a'), WalletAddress('b'),
Timestamp.now())
message.payload = wallet_payload
packet, = self.conversion._encode_wallet_info(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_wallet_info(
self.get_placeholder_msg(u"wallet-info"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.trader_id, TraderId('abc'))
self.assertEqual(decoded.transaction_trader_id, TraderId('def'))
def add_transaction_and_payment(self):
"""
Add a transaction and a payment to the market
"""
proposed_trade = Trade.propose(
TraderId('0'), OrderId(TraderId('0'), OrderNumber(1)),
OrderId(TraderId('1'), OrderNumber(2)),
AssetPair(AssetAmount(30, 'BTC'), AssetAmount(60, 'MB')),
Timestamp(1462224447.117))
transaction = self.session.lm.market_community.transaction_manager.create_from_proposed_trade(
proposed_trade, 'abcd')
payment = Payment(TraderId("0"), transaction.transaction_id,
AssetAmount(20, 'BTC'), WalletAddress('a'),
WalletAddress('b'), PaymentId('aaa'), Timestamp(4.0),
True)
transaction.add_payment(payment)
self.session.lm.market_community.transaction_manager.transaction_repository.update(
transaction)
return transaction
def test_encode_decode_payment(self):
"""
Test encoding and decoding of a payment
"""
message = MockObject()
meta_msg = self.market_community.get_meta_message(u"payment")
payment_payload = PaymentPayload.Implementation(meta_msg, TraderId('abc'), MessageNumber('3'),
TraderId('def'), TransactionNumber(5), Quantity(5, 'MC'),
Price(6, 'BTC'), WalletAddress('a'),
WalletAddress('b'), PaymentId('abc'), Timestamp.now(), False)
message.payload = payment_payload
packet, = self.conversion._encode_payment(message)
self.assertTrue(packet)
_, decoded = self.conversion._decode_payment(self.get_placeholder_msg(u"payment"), 0, packet)
self.assertTrue(decoded)
self.assertEqual(decoded.trader_id, TraderId('abc'))
self.assertEqual(decoded.transaction_trader_id, TraderId('def'))
self.assertEqual(decoded.payment_id, PaymentId('abc'))
self.assertEqual(decoded.success, False)
def setUp(self):
# Object creation
self.wallet_info_payload = WalletInfoPayload.Implementation(
MetaObject(), TraderId('0'), MessageNumber('1'), TraderId('2'),
TransactionNumber(2), WalletAddress('a'), WalletAddress('b'),
Timestamp(3600.0))
def test_init(self):
# Test for init validation
with self.assertRaises(ValueError):
WalletAddress(1)
def setUp(self):
# Object creation
self.wallet_address = WalletAddress("0")
self.wallet_address2 = WalletAddress("1")
