def test_shares_by_owner(self):
market = MarketFactory()
response = self.client.get(reverse('api:shares-by-owner',
kwargs={
'market_address':
market.address,
'owner_address': market.creator
}),
content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(response.content).get('results')), 0)
outcome_token = OutcomeTokenFactory(event=market.event)
outcome_token2 = OutcomeTokenFactory(event=market.event)
OutcomeTokenBalanceFactory(owner=market.creator,
outcome_token=outcome_token)
response = self.client.get(reverse('api:shares-by-owner',
kwargs={
'market_address':
market.address,
'owner_address': market.creator
}),
content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(response.content).get('results')), 1)
def test_event_instance_revocation_receiver(self):
outcome_token_factory = OutcomeTokenFactory()
revocation_event = {
'name':
'Revocation',
'address':
outcome_token_factory.address,
'params': [{
'name': 'owner',
'value': outcome_token_factory.address[0:-7] + 'GIACOMO'
}, {
'name': 'amount',
'value': 1000,
}]
}
issuance_event = revocation_event.copy()
issuance_event.update({'name': 'Issuance'})
# do issuance
OutcomeTokenInstanceReceiver().save(issuance_event)
# do revocation
OutcomeTokenInstanceReceiver().save(revocation_event)
outcome_token = OutcomeToken.objects.get(
address=outcome_token_factory.address)
self.assertIsNotNone(outcome_token.pk)
self.assertEquals(outcome_token_factory.total_supply,
outcome_token.total_supply)
def test_outcome_token_transfer_rollback(self):
outcome_token_factory = OutcomeTokenFactory()
owner_one = outcome_token_factory.address[0:-5] + 'other'
owner_two = outcome_token_factory.address[0:-2] + 'to'
block = {
'number': 1,
'timestamp': self.to_timestamp(datetime.now())
}
issuance_event = {
'name': 'Issuance',
'address': outcome_token_factory.address,
'params': [
{
'name': 'owner',
'value': owner_one
},
{
'name': 'amount',
'value': 1000
}
]
}
transfer_event = {
'name': 'Transfer',
'address': outcome_token_factory.address,
'params': [
{
'name': 'from',
'value': owner_one
},
{
'name': 'to',
'value': owner_two
},
{
'name': 'value',
'value': 10
}
]
}
OutcomeTokenInstanceReceiver().save(issuance_event)
OutcomeTokenInstanceReceiver().save(transfer_event)
outcome_token_balance_before_rollback = OutcomeTokenBalance.objects.get(owner=owner_two)
self.assertEquals(outcome_token_balance_before_rollback.balance, 10)
# Rollback
OutcomeTokenInstanceReceiver().rollback(transfer_event, block)
with self.assertRaises(OutcomeTokenBalance.DoesNotExist):
OutcomeTokenBalance.objects.get(owner=owner_two)
# Test with funds on owner2
OutcomeTokenInstanceReceiver().save(issuance_event)
isuance_event_owner_two = issuance_event.copy()
isuance_event_owner_two.get('params')[0]['value'] = owner_two
OutcomeTokenInstanceReceiver().save(isuance_event_owner_two)
OutcomeTokenInstanceReceiver().save(transfer_event)
OutcomeTokenInstanceReceiver().rollback(transfer_event, block)
owner_two_token_balance = OutcomeTokenBalance.objects.get(owner=owner_two)
self.assertEquals(owner_two_token_balance.balance, 1000)
def test_market_participant_history(self):
outcome_token = OutcomeTokenFactory()
event = outcome_token.event
oracle = event.oracle
market = MarketFactory(event=event)
creation_date_time = datetime.now()
sender_address = '{:040d}'.format(100)
response = self.client.get(
reverse('api:trades-by-owner', kwargs={'market_address': market.address, 'owner_address': sender_address}),
content_type='application/json'
)
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(response.content).get('results')), 0)
# Buy Order
BuyOrderFactory(market=market, sender=sender_address)
BuyOrderFactory(market=market, sender=sender_address)
response = self.client.get(
reverse('api:trades-by-owner', kwargs={'market_address': market.address, 'owner_address': sender_address}),
content_type='application/json'
)
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(response.content).get('results')), 2)
def test_market_history(self):
# create markets
outcome_token = OutcomeTokenFactory()
event = outcome_token.event
oracle = event.oracle
market = MarketFactory(event=event)
creation_date_time = datetime.now()
# Create Order
order = ShortSellOrder()
order.creation_date_time = creation_date_time
order.creation_block = 0
order.market = market
order.sender = '0x1'
order.outcome_token = outcome_token
order.outcome_token_count = 1
order.cost = 1
order.net_outcome_tokens_sold = market.net_outcome_tokens_sold
order.save()
url = reverse('api:history-by-market') + '?market=' + market.address
history_data = self.client.get(url, content_type='application/json')
self.assertEquals(history_data.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(history_data.content).get('results')),
1)
from_date = (creation_date_time -
timedelta(days=1)).strftime('%Y-%m-%d %H:%M:%S')
to_date = (creation_date_time +
timedelta(days=1)).strftime('%Y-%m-%d %H:%M:%S')
url = reverse(
'api:history-by-market'
) + '?market=' + market.address + '&from=' + from_date + '&to=' + to_date
history_data = self.client.get(url, content_type='application/json')
self.assertEquals(history_data.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(history_data.content).get('results')),
1)
# test querying date with no orders
from_date = (creation_date_time -
timedelta(days=5)).strftime('%Y-%m-%d %H:%M:%S')
to_date = (creation_date_time -
timedelta(days=4)).strftime('%Y-%m-%d %H:%M:%S')
url = reverse(
'api:history-by-market'
) + '?market=' + market.address + '&from=' + from_date + '&to=' + to_date
history_data = self.client.get(url, content_type='application/json')
self.assertEquals(history_data.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(history_data.content).get('results')),
0)
# test querying date passing only the from param
from_date = (creation_date_time -
timedelta(days=5)).strftime('%Y-%m-%d %H:%M:%S')
url = reverse('api:history-by-market'
) + '?market=' + market.address + '&from=' + from_date
history_data = self.client.get(url, content_type='application/json')
self.assertEquals(history_data.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(history_data.content).get('results')),
1)
def test_shares_by_account(self):
account1 = '{:040d}'.format(13)
account2 = '{:040d}'.format(14)
url = reverse('api:shares-by-account', kwargs={'account_address': account1})
empty_shares_response = self.client.get(url, content_type='application/json')
self.assertEquals(len(json.loads(empty_shares_response.content).get('results')), 0)
oracle = CentralizedOracleFactory()
event = CategoricalEventFactory(oracle=oracle)
market = MarketFactory(event=event, creator=account1)
outcome_token = OutcomeTokenFactory(event=market.event)
OutcomeTokenBalanceFactory(owner=market.creator, outcome_token=outcome_token)
BuyOrderFactory(outcome_token=outcome_token, sender=account1, market=market)
url = reverse('api:shares-by-account', kwargs={'account_address': account1})
shares_response = self.client.get(url, content_type='application/json')
decoded_response = json.loads(shares_response.content)
self.assertEquals(len(decoded_response.get('results')), 1)
self.assertEquals(
decoded_response.get('results')[0].get('eventDescription').get('title'),
oracle.event_description.title
)
self.assertEquals(
decoded_response.get('results')[0].get('marginalPrice'),
0.5
)
url = reverse('api:shares-by-account', kwargs={'account_address': account2})
no_shares_response = self.client.get(url, content_type='application/json')
self.assertEquals(len(json.loads(no_shares_response.content).get('results')), 0)
def test_issuance_outcome_token(self):
outcome_token = OutcomeTokenFactory()
event = EventFactory()
issuance_event = {
'name':
'Issuance',
'address':
outcome_token.address,
'params': [{
'name': 'owner',
'value': event.address
}, {
'name': 'amount',
'value': 20,
}]
}
s = OutcomeTokenIssuanceSerializer(data=issuance_event)
self.assertTrue(s.is_valid(), s.errors)
instance = s.save()
balance = OutcomeTokenBalance.objects.get(owner=event.address)
self.assertEqual(balance.balance, 20)
self.assertIsNotNone(instance)
self.assertEqual(
OutcomeToken.objects.get(
address=outcome_token.address).total_supply,
outcome_token.total_supply + 20)
def test_event_instance_issuance_receiver(self):
outcome_token = OutcomeTokenFactory()
event = {
'name':
'Issuance',
'address':
outcome_token.address,
'params': [{
'name': 'owner',
'value': outcome_token.event.creator
}, {
'name': 'amount',
'value': 1000,
}]
}
OutcomeTokenInstanceReceiver().save(event)
outcome_token_saved = OutcomeToken.objects.get(
address=outcome_token.address)
self.assertIsNotNone(outcome_token_saved.pk)
self.assertEquals(outcome_token.total_supply + 1000,
outcome_token_saved.total_supply)
outcome_token_balance = OutcomeTokenBalance.objects.get(
owner=outcome_token.event.creator)
self.assertIsNotNone(outcome_token_balance.pk)
self.assertEqual(outcome_token_balance.balance, 1000)
def test_market_trades(self):
url = reverse('api:trades-by-market', kwargs={'market_address': '{:040d}'.format(1000)})
trades_response = self.client.get(url, content_type='application/json')
self.assertEquals(trades_response.status_code, status.HTTP_404_NOT_FOUND)
# create markets
outcome_token = OutcomeTokenFactory()
event = outcome_token.event
oracle = event.oracle
market = MarketFactory(event=event)
creation_date_time = datetime.now()
# Create Order
order = ShortSellOrder()
order.creation_date_time = creation_date_time
order.creation_block = 0
order.market = market
order.sender = '0x1'
order.outcome_token = outcome_token
order.outcome_token_count = 1
order.cost = 1
order.net_outcome_tokens_sold = market.net_outcome_tokens_sold
order.marginal_prices = ["0.5000", "0.5000"]
order.save()
url = reverse('api:trades-by-market', kwargs={'market_address': market.address})
trades_response = self.client.get(url, content_type='application/json')
trades_data = json.loads(trades_response.content)
self.assertEquals(trades_response.status_code, status.HTTP_200_OK)
self.assertEquals(len(trades_data.get('results')), 1)
self.assertEquals(trades_data.get('results')[0].get('marginalPrices')[0], order.marginal_prices[0])
from_date = (creation_date_time - timedelta(days=1)).strftime('%Y-%m-%d %H:%M:%S')
to_date = (creation_date_time + timedelta(days=1)).strftime('%Y-%m-%d %H:%M:%S')
url = reverse('api:trades-by-market',
kwargs={'market_address': market.address})
url += '?creation_date_time_0=' + from_date + '&creation_date_time_1='+to_date
trades_response = self.client.get(url, content_type='application/json')
self.assertEquals(trades_response.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(trades_response.content).get('results')), 1)
# test querying date with no orders
from_date = (creation_date_time - timedelta(days=5)).strftime('%Y-%m-%d %H:%M:%S')
to_date = (creation_date_time - timedelta(days=4)).strftime('%Y-%m-%d %H:%M:%S')
url = reverse('api:trades-by-market',
kwargs={'market_address': market.address})
url += '?creation_date_time_0=' + from_date + '&creation_date_time_1=' + to_date
trades_response = self.client.get(url, content_type='application/json')
self.assertEquals(trades_response.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(trades_response.content).get('results')), 0)
# test querying date passing only the from param
from_date = (creation_date_time - timedelta(days=5)).strftime('%Y-%m-%d %H:%M:%S')
url = reverse('api:trades-by-market',
kwargs={'market_address': market.address})
url += '?creation_date_time_0=' + from_date
trades_response = self.client.get(url, content_type='application/json')
self.assertEquals(trades_response.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(trades_response.content).get('results')), 1)
def test_outcome_token_purchase_marginal_price(self):
categorical_event = CategoricalEventFactory()
OutcomeTokenFactory(event=categorical_event, index=0)
OutcomeTokenFactory(event=categorical_event, index=1)
market = MarketFactory(event=categorical_event,
funding=1e18,
net_outcome_tokens_sold=[0, 0])
sender_address = '{:040d}'.format(100)
outcome_token_purchase_event = {
'name':
'OutcomeTokenPurchase',
'address':
market.address,
'params': [
{
'name': 'outcomeTokenCost',
'value': 1000000000000000000
},
{
'name': 'marketFees',
'value': 0
},
{
'name': 'buyer',
'value': sender_address
},
{
'name': 'outcomeTokenIndex',
'value': 0
},
{
'name': 'outcomeTokenCount',
'value': 1584900000000000000
},
]
}
block = {'number': 1, 'timestamp': self.to_timestamp(datetime.now())}
self.assertEquals(BuyOrder.objects.all().count(), 0)
MarketInstanceReceiver().save(outcome_token_purchase_event, block)
buy_orders = BuyOrder.objects.all()
self.assertEquals(buy_orders.count(), 1)
self.assertListEqual(
buy_orders[0].marginal_prices,
[Decimal(0.7500), Decimal(0.2500)]) # outcomeTokenCost+fee
def test_market_outcome_token_purchase_rollback(self):
oracle_factory = CentralizedOracleFactory()
event_factory = CategoricalEventFactory(oracle=oracle_factory)
outcome_token = OutcomeTokenFactory(event=event_factory, index=0)
market_without_rollback = MarketFactory(event=event_factory)
buyer_address = '{:040d}'.format(100)
self.assertIsNotNone(market_without_rollback.pk)
block = {
'number': oracle_factory.creation_block,
'timestamp': self.to_timestamp(oracle_factory.creation_date_time)
}
outcome_token_purchase_event = {
'name':
'OutcomeTokenPurchase',
'address':
market_without_rollback.address,
'params': [
{
'name': 'outcomeTokenCost',
'value': 100
},
{
'name': 'marketFees',
'value': 10
},
{
'name': 'buyer',
'value': buyer_address
},
{
'name': 'outcomeTokenIndex',
'value': 0
},
{
'name': 'outcomeTokenCount',
'value': 10
},
]
}
# Send outcome token purchase event
MarketInstanceReceiver().save(outcome_token_purchase_event, block)
orders_before_rollback = BuyOrder.objects.filter(
creation_block=block.get('number'),
sender=buyer_address,
market=market_without_rollback)
self.assertEquals(len(orders_before_rollback), 1)
# Outcome token purchase rollback
MarketInstanceReceiver().rollback(outcome_token_purchase_event, block)
market_with_rollback = Market.objects.get(event=event_factory.address)
orders_after_rollback = BuyOrder.objects.filter(
creation_block=block.get('number'),
sender=buyer_address,
market=market_with_rollback)
self.assertEquals(len(orders_after_rollback), 0)
def test_create_outcome_token_instance(self):
outcome_token = OutcomeTokenFactory()
event = ScalarEventFactory()
outcome_token_event = {
'address':
event.address,
'params': [{
'name': 'outcomeToken',
'value': outcome_token.address,
}, {
'name': 'index',
'value': outcome_token.index
}]
}
outcome_token.delete()
s = OutcomeTokenInstanceSerializer(data=outcome_token_event)
self.assertTrue(s.is_valid(), s.errors)
instance = s.save()
self.assertIsNotNone(instance)
def test_market_marginal_prices(self):
oracle = CentralizedOracleFactory()
categorical_event = CategoricalEventFactory(oracle=oracle)
outcome_token = OutcomeTokenFactory(event=categorical_event)
market = MarketFactory(event=categorical_event)
sender_address = '{:040d}'.format(100)
# Buy Order
order_one = BuyOrderFactory(market=market, sender=sender_address)
order_two = BuyOrderFactory(market=market, sender=sender_address)
market_response = self.client.get(reverse('api:markets-by-name', kwargs={'market_address': market.address}), content_type='application/json')
market_data = json.loads(market_response.content)
self.assertEquals(market_data.get('marginalPrices'), order_two.marginal_prices)
def test_calc_lmsr_marginal_price(self):
outcomeTokenIndex = 0
outcomeTokenCount = 1e18
# create markets
outcome_token = OutcomeTokenFactory()
event = outcome_token.event
market = MarketFactory(event=event)
net_outcome_tokens_sold = [0, 1] # market.net_outcome_tokens_sold
result = calc_lmsr_marginal_price(1, net_outcome_tokens_sold,
market.funding)
self.assertIsNotNone(result)
self.assertTrue(result > 0)
def test_collected_fees(self):
categorical_event = CategoricalEventFactory()
outcome_token = OutcomeTokenFactory(event=categorical_event, index=0)
market = MarketFactory(event=categorical_event)
sender_address = '{:040d}'.format(100)
fees = 10
outcome_token_purchase_event = {
'name':
'OutcomeTokenPurchase',
'address':
market.address,
'params': [
{
'name': 'outcomeTokenCost',
'value': 100
},
{
'name': 'marketFees',
'value': fees
},
{
'name': 'buyer',
'value': sender_address
},
{
'name': 'outcomeTokenIndex',
'value': 0
},
{
'name': 'outcomeTokenCount',
'value': 10
},
]
}
block = {'number': 1, 'timestamp': self.to_timestamp(datetime.now())}
# Save event
MarketInstanceReceiver().save(outcome_token_purchase_event, block)
# Check that collected fees was incremented
market_check = Market.objects.get(address=market.address)
self.assertEquals(market_check.collected_fees,
market.collected_fees + fees)
block.update({'number': 2})
MarketInstanceReceiver().save(outcome_token_purchase_event, block)
market_check = Market.objects.get(address=market.address)
self.assertEquals(market_check.collected_fees,
market.collected_fees + fees + fees)
def test_market_outcome_token_sale_rollback(self):
categorical_event = CategoricalEventFactory()
outcome_token = OutcomeTokenFactory(event=categorical_event, index=0)
market = MarketFactory(event=categorical_event)
seller_address = '{:040d}'.format(100)
block = {'number': 1, 'timestamp': self.to_timestamp(datetime.now())}
outcome_token_sell_event = {
'name':
'OutcomeTokenSale',
'address':
market.address,
'params': [
{
'name': 'outcomeTokenProfit',
'value': 100
},
{
'name': 'marketFees',
'value': 10
},
{
'name': 'seller',
'value': seller_address
},
{
'name': 'outcomeTokenIndex',
'value': 0
},
{
'name': 'outcomeTokenCount',
'value': 10
},
]
}
MarketInstanceReceiver().save(outcome_token_sell_event, block)
orders_before_rollback = SellOrder.objects.filter(
creation_block=block.get('number'), sender=seller_address)
self.assertEquals(len(orders_before_rollback), 1)
# Outcome token sell rollback
MarketInstanceReceiver().rollback(outcome_token_sell_event, block)
orders_before_rollback = SellOrder.objects.filter(
creation_block=block.get('number'), sender=seller_address)
self.assertEquals(len(orders_before_rollback), 0)
def test_outcome_token_purchase(self):
categorical_event = CategoricalEventFactory()
outcome_token = OutcomeTokenFactory(event=categorical_event, index=0)
market = MarketFactory(event=categorical_event)
sender_address = '{:040d}'.format(100)
outcome_token_purchase_event = {
'name':
'OutcomeTokenPurchase',
'address':
market.address,
'params': [
{
'name': 'outcomeTokenCost',
'value': 100
},
{
'name': 'marketFees',
'value': 10
},
{
'name': 'buyer',
'value': sender_address
},
{
'name': 'outcomeTokenIndex',
'value': 0
},
{
'name': 'outcomeTokenCount',
'value': 10
},
]
}
block = {'number': 1, 'timestamp': self.to_timestamp(datetime.now())}
self.assertEquals(BuyOrder.objects.all().count(), 0)
MarketInstanceReceiver().save(outcome_token_purchase_event, block)
buy_orders = BuyOrder.objects.all()
self.assertEquals(buy_orders.count(), 1)
self.assertEquals(buy_orders[0].cost, 110) # outcomeTokenCost+fee
def test_outcome_token_sell(self):
categorical_event = CategoricalEventFactory()
outcome_token = OutcomeTokenFactory(event=categorical_event, index=0)
market = MarketFactory(event=categorical_event)
sender_address = '{:040d}'.format(100)
outcome_token_sell_event = {
'name':
'OutcomeTokenSale',
'address':
market.address,
'params': [
{
'name': 'outcomeTokenProfit',
'value': 100
},
{
'name': 'marketFees',
'value': 10
},
{
'name': 'seller',
'value': sender_address
},
{
'name': 'outcomeTokenIndex',
'value': 0
},
{
'name': 'outcomeTokenCount',
'value': 10
},
]
}
block = {'number': 1, 'timestamp': self.to_timestamp(datetime.now())}
self.assertEquals(SellOrder.objects.all().count(), 0)
MarketInstanceReceiver().save(outcome_token_sell_event, block)
sell_orders = SellOrder.objects.all()
self.assertEquals(sell_orders.count(), 1)
self.assertEquals(sell_orders[0].profit, 90) # outcomeTokenProfit-fee
def test_market_participant_history(self):
outcome_token = OutcomeTokenFactory()
event = outcome_token.event
oracle = event.oracle
market = MarketFactory(event=event)
creation_date_time = datetime.now()
sender_address = '{:040d}'.format(100)
response = self.client.get(reverse('api:trades-by-owner',
kwargs={
'market_address':
market.address,
'owner_address': sender_address
}),
content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(response.content).get('results')), 0)
# Create Order
order = ShortSellOrder()
order.creation_date_time = creation_date_time
order.creation_block = 0
order.market = market
order.sender = sender_address
order.outcome_token = outcome_token
order.outcome_token_count = 1
order.cost = 1
order.net_outcome_tokens_sold = market.net_outcome_tokens_sold
order.save()
response = self.client.get(reverse('api:trades-by-owner',
kwargs={
'market_address':
market.address,
'owner_address': sender_address
}),
content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(len(json.loads(response.content).get('results')), 1)
def test_event_instance_issuance_receiver(self):
outcome_token_factory = OutcomeTokenFactory()
event = {
'name':
'Issuance',
'address':
outcome_token_factory.address,
'params': [{
'name': 'owner',
'value': outcome_token_factory.address[0:-7] + 'GIACOMO'
}, {
'name': 'amount',
'value': 1000,
}]
}
OutcomeTokenInstanceReceiver().save(event)
outcome_token = OutcomeToken.objects.get(
address=outcome_token_factory.address)
self.assertIsNotNone(outcome_token.pk)
self.assertEquals(outcome_token_factory.total_supply + 1000,
outcome_token.total_supply)
def test_event_instance_receiver(self):
outcome_token = OutcomeTokenFactory()
oracle = OracleFactory()
event = ScalarEventFactory()
event_address = event.address
block = {
'number': event.creation_block,
'timestamp': mktime(event.creation_date_time.timetuple())
}
scalar_event = {
'name':
'ScalarEventCreation',
'address':
event.factory,
'params': [{
'name': 'creator',
'value': event.creator
}, {
'name': 'collateralToken',
'value': event.collateral_token
}, {
'name': 'oracle',
'value': oracle.address
}, {
'name': 'outcomeCount',
'value': 2
}, {
'name': 'upperBound',
'value': event.upper_bound
}, {
'name': 'lowerBound',
'value': event.lower_bound
}, {
'name': 'scalarEvent',
'value': event_address
}]
}
event.delete()
EventFactoryReceiver().save(scalar_event, block)
event = ScalarEvent.objects.get(address=event_address)
block = {
'number': event.creation_block,
'timestamp': mktime(event.creation_date_time.timetuple())
}
outcome_token_address = outcome_token.address
outcome_event = {
'name':
'OutcomeTokenCreation',
'address':
event_address,
'params': [{
'name': 'outcomeToken',
'value': outcome_token_address,
}, {
'name': 'index',
'value': outcome_token.index
}]
}
outcome_token.delete()
EventInstanceReceiver().save(outcome_event, block)
self.assertIsNotNone(
OutcomeToken.objects.get(address=outcome_token_address))
def test_create_outcome_token_instance(self):
outcome_token_factory = OutcomeTokenFactory()
oracle_factory = OracleFactory()
event_factory = EventFactory()
event = None
block = {
'number': oracle_factory.creation_block,
'timestamp': mktime(oracle_factory.creation_date_time.timetuple())
}
scalar_event = {
'address':
oracle_factory.factory[1:-12] + 'TESTINSTANCE',
'params': [{
'name': 'creator',
'value': oracle_factory.creator
}, {
'name': 'collateralToken',
'value': event_factory.collateral_token
}, {
'name': 'oracle',
'value': oracle_factory.address
}, {
'name': 'outcomeCount',
'value': 1
}, {
'name': 'upperBound',
'value': 1
}, {
'name': 'lowerBound',
'value': 0
}, {
'name': 'scalarEvent',
'value': event_factory.address[1:-12] + 'TESTINSTANCE'
}]
}
s = ScalarEventSerializer(data=scalar_event, block=block)
s.is_valid()
event = s.save()
block = {
'number': oracle_factory.creation_block,
'timestamp': mktime(oracle_factory.creation_date_time.timetuple())
}
oracle_event = {
'address':
oracle_factory.factory[0:-7] + 'GIACOMO',
'params': [{
'name': 'creator',
'value': event.creator
}, {
'name': 'address',
'value': event.address
}, {
'name': 'outcomeToken',
'value': oracle_factory.address[1:-8] + 'INSTANCE',
}, {
'name': 'index',
'value': outcome_token_factory.index
}]
}
s = OutcomeTokenInstanceSerializer(data=oracle_event)
self.assertTrue(s.is_valid(), s.errors)
instance = s.save()
self.assertIsNotNone(instance)
def test_event_instance_receiver(self):
outcome_token_factory = OutcomeTokenFactory()
oracle_factory = OracleFactory()
event_factory = EventFactory()
event_address = event_factory.address[0:-7] + 'GIACOMO'
block = {
'number': oracle_factory.creation_block,
'timestamp': mktime(oracle_factory.creation_date_time.timetuple())
}
scalar_event = {
'name':
'ScalarEventCreation',
'address':
oracle_factory.factory[1:-12] + 'TESTINSTANCE',
'params': [{
'name': 'creator',
'value': oracle_factory.creator
}, {
'name': 'collateralToken',
'value': event_factory.collateral_token
}, {
'name': 'oracle',
'value': oracle_factory.address
}, {
'name': 'outcomeCount',
'value': 1
}, {
'name': 'upperBound',
'value': 1
}, {
'name': 'lowerBound',
'value': 0
}, {
'name': 'scalarEvent',
'value': event_address
}]
}
EventFactoryReceiver().save(scalar_event, block)
event = ScalarEvent.objects.get(address=event_address)
block = {
'number': oracle_factory.creation_block,
'timestamp': mktime(oracle_factory.creation_date_time.timetuple())
}
outcome_token_address = oracle_factory.address[1:-8] + 'INSTANCE'
outcome_event = {
'name':
'OutcomeTokenCreation',
'address':
oracle_factory.factory[0:-7] + 'GIACOMO',
'params': [{
'name': 'creator',
'value': event.creator
}, {
'name': 'address',
'value': event.address
}, {
'name': 'outcomeToken',
'value': outcome_token_address,
}, {
'name': 'index',
'value': outcome_token_factory.index
}]
}
EventInstanceReceiver().save(outcome_event, block)
self.assertIsNotNone(
OutcomeToken.objects.get(address=outcome_token_address))
