def test_market_creation(contractsFixture, universe, cash, market):
reportingWindow = contractsFixture.applySignature(
'ReportingWindow', market.getReportingWindow())
shadyStakeToken = contractsFixture.upload(
'../source/contracts/reporting/StakeToken.sol', 'shadyStakeToken')
shadyStakeToken.setController(
contractsFixture.contracts["Controller"].address)
shadyStakeToken.initialize(market.address, [0, market.getNumTicks()])
logs = []
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
market = contractsFixture.createReasonableBinaryMarket(
universe, cash, extraInfo="so extra")
assert len(logs) == 3
assert logs[2]['_event_type'] == 'MarketCreated'
assert logs[2]['extraInfo'] == 'so extra'
assert logs[2][
'marketCreationFee'] == universe.getOrCacheMarketCreationCost()
assert logs[2]['market'] == market.address
assert logs[2]['marketCreator'] == bytesToHexString(tester.a0)
assert market.getUniverse() == universe.address
assert market.getNumberOfOutcomes() == 2
assert market.getNumTicks() == 10000
assert reportingWindow.getReputationToken() == universe.getReputationToken(
)
assert market.getFinalPayoutDistributionHash() == stringToBytes("")
assert market.getReportingState(
) == contractsFixture.contracts['Constants'].PRE_REPORTING()
assert market.isContainerForStakeToken(shadyStakeToken.address) == 0
assert market.getDesignatedReportDueTimestamp(
) == market.getEndTime() + timedelta(days=3).total_seconds()
def test_firstReportingHappyPath(makeReport, localFixture, universe, market):
reportingWindow = localFixture.applySignature('ReportingWindow', market.getReportingWindow())
reputationToken = localFixture.applySignature('ReputationToken', universe.getReputationToken())
# Proceed to the FIRST REPORTING phase
proceedToFirstReporting(localFixture, universe, market, makeReport, 1, [0,market.getNumTicks()], [market.getNumTicks(),0])
logs = []
captureFilteredLogs(localFixture.chain.head_state, localFixture.contracts['Augur'], logs)
# We make one report by Tester 2
stakeTokenYes = localFixture.getOrCreateStakeToken(market, [0,market.getNumTicks()])
stakeTokenYes.buy(1, sender=tester.k2)
# If there ws no designated report he first reporter gets the no-show REP bond auto-staked on the outcome they're purchasing
expectedStakeTokenBalance = 1
if (not makeReport):
expectedStakeTokenBalance += universe.getOrCacheDesignatedReportNoShowBond()
assert stakeTokenYes.balanceOf(tester.a2) == expectedStakeTokenBalance
# Confirm the report logging works
log = logs[2]
if not makeReport:
log = logs[3]
assert len(logs) == 4
else:
assert len(logs) == 3
assert log['_event_type'] == 'ReportSubmitted'
assert log['amountStaked'] == expectedStakeTokenBalance
assert log['reporter'] == bytesToHexString(tester.a2)
assert log['stakeToken'] == localFixture.getOrCreateStakeToken(market, [0,market.getNumTicks()]).address
assert log['market'] == market.address
assert log['payoutNumerators'] == [0,market.getNumTicks()]
assert reputationToken.balanceOf(tester.a2) == 1 * 10 ** 6 * 10 ** 18 - 1
tentativeWinner = market.getTentativeWinningPayoutDistributionHash()
if (makeReport):
# The tentative winner will be the No outcome at first since we disputed Yes and have to stake on an outcome in that case
stakeTokenNo = localFixture.getOrCreateStakeToken(market, [market.getNumTicks(),0])
assert tentativeWinner == stakeTokenNo.getPayoutDistributionHash()
# If we buy the full designated bond amount we will be back to the YES outcome winning
stakeTokenYes.buy(localFixture.contracts['Constants'].DESIGNATED_REPORTER_DISPUTE_BOND_AMOUNT(), sender=tester.k2)
tentativeWinner = market.getTentativeWinningPayoutDistributionHash()
assert tentativeWinner == stakeTokenYes.getPayoutDistributionHash()
# To progress into the FIRST DISPUTE phase we move time forward
localFixture.chain.head_state.timestamp = reportingWindow.getDisputeStartTime() + 1
assert market.getReportingState() == localFixture.contracts['Constants'].FIRST_DISPUTE()
# If time passes and no dispute bond is placed the market can be finalized
localFixture.chain.head_state.timestamp = reportingWindow.getDisputeEndTime() + 1
# The market is awaiting finalization now
assert market.getReportingState() == localFixture.contracts['Constants'].AWAITING_FINALIZATION()
# We can finalize it
assert market.tryFinalize()
assert market.getReportingState() == localFixture.contracts['Constants'].FINALIZED()
def test_publicCreateOrder_bid2(contractsFixture, cash, market, universe):
orders = contractsFixture.contracts['Orders']
createOrder = contractsFixture.contracts['CreateOrder']
logs = []
orderType = BID
amount = 1
fxpPrice = fix('0.6')
outcome = 0
tradeGroupID = 42
marketInitialCash = cash.balanceOf(market.address)
captureFilteredLogs(contractsFixture.chain.head_state, contractsFixture.contracts['Augur'], logs)
creatorInitialETH = contractsFixture.chain.head_state.get_balance(tester.a1)
orderID = createOrder.publicCreateOrder(orderType, amount, fxpPrice, market.address, outcome, longTo32Bytes(0), longTo32Bytes(0), tradeGroupID, sender=tester.k1, value = fix('10'))
assert orderID != bytearray(32), "Order ID should be non-zero"
assert orders.getAmount(orderID) == amount
assert orders.getPrice(orderID) == fxpPrice
assert orders.getOrderCreator(orderID) == bytesToHexString(tester.a1)
assert orders.getOrderMoneyEscrowed(orderID) == 0.6 * 10**18
assert orders.getOrderSharesEscrowed(orderID) == 0
assert cash.balanceOf(tester.a1) == 0
assert contractsFixture.chain.head_state.get_balance(tester.a1) == creatorInitialETH - long(0.6 * 10**18)
assert cash.balanceOf(market.address) - marketInitialCash == 0.6 * 10**18
shareToken = contractsFixture.getShareToken(market, 0)
assert len(logs) == 1
assert logs[0]['_event_type'] == 'OrderCreated'
assert logs[0]['creator'] == bytesToHexString(tester.a1)
assert logs[0]['shareToken'] == shareToken.address
assert logs[0]['tradeGroupId'] == 42
assert logs[0]['orderId'] == orderID
def test_fee_wondow_logging(contractsFixture, market, categoricalMarket,
scalarMarket, universe):
feeWindow = contractsFixture.applySignature(
'FeeWindow', universe.getOrCreateCurrentFeeWindow())
contractsFixture.contracts["Time"].setTimestamp(feeWindow.getStartTime() +
1)
assert feeWindow.buy(100)
logs = []
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
assert feeWindow.transfer(tester.a1, 8)
assert len(logs) == 1
assert logs[0]['_event_type'] == 'TokensTransferred'
assert logs[0]['from'] == bytesToHexString(tester.a0)
assert logs[0]['to'] == bytesToHexString(tester.a1)
assert logs[0]['token'] == feeWindow.address
assert logs[0]['universe'] == universe.address
assert logs[0]['value'] == 8
assert feeWindow.approve(tester.a2, 12)
assert feeWindow.transferFrom(tester.a0, tester.a1, 12, sender=tester.k2)
assert len(logs) == 2
assert logs[1]['_event_type'] == 'TokensTransferred'
assert logs[1]['from'] == bytesToHexString(tester.a0)
assert logs[1]['to'] == bytesToHexString(tester.a1)
assert logs[1]['token'] == feeWindow.address
assert logs[1]['universe'] == universe.address
assert logs[1]['value'] == 12
def test_reputation_token_logging(contractsFixture, universe):
reputationToken = contractsFixture.applySignature("ReputationToken", universe.getReputationToken())
logs = []
captureFilteredLogs(contractsFixture.chain.head_state, contractsFixture.contracts['Augur'], logs)
assert reputationToken.transfer(tester.a1, 8)
assert len(logs) == 1
assert logs[0]['_event_type'] == 'TokensTransferred'
assert logs[0]['from'] == bytesToHexString(tester.a0)
assert logs[0]['to'] == bytesToHexString(tester.a1)
assert logs[0]['token'] == reputationToken.address
assert logs[0]['universe'] == universe.address
assert logs[0]['tokenType'] == 0
assert logs[0]['value'] == 8
assert reputationToken.approve(tester.a2, 12)
assert reputationToken.transferFrom(tester.a0, tester.a1, 12, sender=tester.k2)
assert len(logs) == 2
assert logs[1]['_event_type'] == 'TokensTransferred'
assert logs[1]['from'] == bytesToHexString(tester.a0)
assert logs[1]['to'] == bytesToHexString(tester.a1)
assert logs[1]['token'] == reputationToken.address
assert logs[1]['universe'] == universe.address
assert logs[0]['tokenType'] == 0
assert logs[1]['value'] == 12
def test_publicFillOrder_bid(contractsFixture, cash, market, universe):
createOrder = contractsFixture.contracts['CreateOrder']
fillOrder = contractsFixture.contracts['FillOrder']
orders = contractsFixture.contracts['Orders']
tradeGroupID = "42"
logs = []
initialMakerETH = contractsFixture.chain.head_state.get_balance(tester.a1)
initialFillerETH = contractsFixture.chain.head_state.get_balance(tester.a2)
creatorCost = fix('2', '6000')
fillerCost = fix('2', '4000')
# create order
orderID = createOrder.publicCreateOrder(BID,
fix(2),
6000,
market.address,
YES,
longTo32Bytes(0),
longTo32Bytes(0),
tradeGroupID,
sender=tester.k1,
value=creatorCost)
# fill best order
captureFilteredLogs(contractsFixture.chain.head_state, orders, logs)
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
fillOrderID = fillOrder.publicFillOrder(orderID,
fix(2),
tradeGroupID,
sender=tester.k2,
value=fillerCost)
assert len(logs) == 5
assert logs[4]["_event_type"] == "OrderFilled"
assert logs[4]["filler"] == bytesToHexString(tester.a2)
assert logs[4]["numCreatorShares"] == 0
assert logs[4]["numCreatorTokens"] == creatorCost
assert logs[4]["numFillerShares"] == 0
assert logs[4]["numFillerTokens"] == fillerCost
assert logs[4]["marketCreatorFees"] == 0
assert logs[4]["reporterFees"] == 0
assert logs[4]["shareToken"] == market.getShareToken(YES)
assert logs[4]["tradeGroupId"] == stringToBytes("42")
assert contractsFixture.chain.head_state.get_balance(
tester.a1) == initialMakerETH - creatorCost
assert contractsFixture.chain.head_state.get_balance(
tester.a2) == initialFillerETH - fillerCost
assert orders.getAmount(orderID) == 0
assert orders.getPrice(orderID) == 0
assert orders.getOrderCreator(orderID) == longToHexString(0)
assert orders.getOrderMoneyEscrowed(orderID) == 0
assert orders.getOrderSharesEscrowed(orderID) == 0
assert orders.getBetterOrderId(orderID) == longTo32Bytes(0)
assert orders.getWorseOrderId(orderID) == longTo32Bytes(0)
assert fillOrderID == 0
def test_ask_withPartialShares(contractsFixture, universe, cash, market):
orders = contractsFixture.contracts['Orders']
createOrder = contractsFixture.contracts['CreateOrder']
fillOrder = contractsFixture.contracts['FillOrder']
completeSets = contractsFixture.contracts['CompleteSets']
yesShareToken = contractsFixture.applySignature('ShareToken',
market.getShareToken(YES))
noShareToken = contractsFixture.applySignature('ShareToken',
market.getShareToken(NO))
logs = []
# buy fix(2) complete sets
assert completeSets.publicBuyCompleteSets(market.address,
fix(2),
sender=tester.k1,
value=fix(
2, market.getNumTicks()))
assert cash.balanceOf(tester.a1) == fix('0')
assert yesShareToken.balanceOf(tester.a1) == fix(2)
assert noShareToken.balanceOf(tester.a1) == fix(2)
logs = []
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
# create ASK order for fix(3) shares with a mix of shares and cash
assert yesShareToken.approve(createOrder.address,
fix('2'),
sender=tester.k1)
orderID = createOrder.publicCreateOrder(ASK,
fix(3),
4000,
market.address,
YES,
longTo32Bytes(0),
longTo32Bytes(0),
"42",
sender=tester.k1,
value=fix('6000'))
assert cash.balanceOf(tester.a1) == fix('0')
assert yesShareToken.balanceOf(tester.a1) == 0
assert noShareToken.balanceOf(tester.a1) == fix(2)
# Confirm create order logging works correctly
assert len(logs) == 2
assert logs[1]['_event_type'] == 'OrderCreated'
assert logs[1]['creator'] == bytesToHexString(tester.a1)
assert logs[1]['shareToken'] == yesShareToken.address
assert logs[1]['tradeGroupId'] == stringToBytes("42")
assert logs[1]['orderId'] == orderID
# validate the order contains expected results
assert orderID != bytearray(32), "Order ID should be non-zero"
assert orders.getAmount(orderID) == fix(3)
assert orders.getPrice(orderID) == 4000
assert orders.getOrderCreator(orderID) == bytesToHexString(tester.a1)
assert orders.getOrderMoneyEscrowed(orderID) == fix('6000')
assert orders.getOrderSharesEscrowed(orderID) == fix(2)
def test_create_bid_with_shares_fill_with_shares(contractsFixture, cash, market, universe):
completeSets = contractsFixture.contracts['CompleteSets']
createOrder = contractsFixture.contracts['CreateOrder']
fillOrder = contractsFixture.contracts['FillOrder']
yesShareToken = contractsFixture.applySignature('ShareToken', market.getShareToken(YES))
noShareToken = contractsFixture.applySignature('ShareToken', market.getShareToken(NO))
totalProceeds = fix('12', market.getNumTicks())
marketCreatorFee = totalProceeds / market.getMarketCreatorSettlementFeeDivisor()
reporterFee = totalProceeds / universe.getOrCacheReportingFeeDivisor()
completeSetFees = marketCreatorFee + reporterFee
# 1. buy complete sets with both accounts
assert completeSets.publicBuyCompleteSets(market.address, fix(12), sender = tester.k1, value=fix('12', market.getNumTicks()))
assert completeSets.publicBuyCompleteSets(market.address, fix(12), sender = tester.k2, value=fix('12', market.getNumTicks()))
assert cash.balanceOf(tester.a1) == fix('0')
assert cash.balanceOf(tester.a2) == fix('0')
assert yesShareToken.balanceOf(tester.a2) == fix(12)
assert yesShareToken.balanceOf(tester.a1) == fix(12)
assert noShareToken.balanceOf(tester.a1) == fix(12)
assert noShareToken.balanceOf(tester.a2) == fix(12)
# 2. create BID order for YES with NO shares escrowed
assert noShareToken.approve(createOrder.address, fix(12), sender = tester.k1)
orderID = createOrder.publicCreateOrder(BID, fix(12), 6000, market.address, YES, longTo32Bytes(0), longTo32Bytes(0), "42", sender = tester.k1)
assert orderID
assert cash.balanceOf(tester.a1) == fix('0')
assert yesShareToken.balanceOf(tester.a1) == fix(12)
assert noShareToken.balanceOf(tester.a1) == 0
# 3. fill BID order for YES with shares of YES
initialMakerETH = contractsFixture.chain.head_state.get_balance(tester.a1)
initialFillerETH = contractsFixture.chain.head_state.get_balance(tester.a2)
assert yesShareToken.approve(fillOrder.address, fix(12), sender = tester.k2)
logs = []
captureFilteredLogs(contractsFixture.chain.head_state, contractsFixture.contracts['Augur'], logs)
leftoverInOrder = fillOrder.publicFillOrder(orderID, fix(12), sender = tester.k2)
orderFilledLog = logs[5]
assert orderFilledLog['_event_type'] == 'OrderFilled'
assert orderFilledLog['marketCreatorFees'] == marketCreatorFee
assert orderFilledLog['reporterFees'] == reporterFee
creatorFee = completeSetFees * 0.4
fillerFee = completeSetFees * 0.6
assert leftoverInOrder == 0
creatorPayment = fix('12', '4000') - long(creatorFee)
fillerPayment = fix('12', '6000') - long(fillerFee)
assert cash.balanceOf(tester.a1) == 0
assert cash.balanceOf(tester.a2) == 0
assert contractsFixture.chain.head_state.get_balance(tester.a1) == initialMakerETH + long(creatorPayment)
assert contractsFixture.chain.head_state.get_balance(tester.a2) == initialFillerETH + long(fillerPayment)
assert yesShareToken.balanceOf(tester.a1) == fix(12)
assert yesShareToken.balanceOf(tester.a2) == 0
assert noShareToken.balanceOf(tester.a1) == 0
assert noShareToken.balanceOf(tester.a2) == fix(12)
def test_basic_token_emit(localFixture, chain, mockToken):
logs = []
assert mockToken.mint(tester.a1, 101)
captureFilteredLogs(chain.head_state, mockToken, logs)
assert mockToken.callInternalTransfer(tester.a1, tester.a2, 101)
assert mockToken.balanceOf(tester.a2) == 101
assert len(logs) == 1
assert logs[0]['_event_type'] == 'Transfer'
assert logs[0]['value'] == 101L
def test_one_ask_on_books_buy_partial_order(contractsFixture, cash, market,
universe):
createOrder = contractsFixture.contracts['CreateOrder']
trade = contractsFixture.contracts['Trade']
fillOrder = contractsFixture.contracts['FillOrder']
orders = contractsFixture.contracts['Orders']
tradeGroupID = "42"
logs = []
# create order
orderID = createOrder.publicCreateOrder(ASK,
fix(12),
6000,
market.address,
YES,
longTo32Bytes(0),
longTo32Bytes(0),
tradeGroupID,
sender=tester.k1,
value=fix('12', '4000'))
# fill best order
captureFilteredLogs(contractsFixture.chain.head_state, orders, logs)
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
fillOrderID = trade.publicBuy(market.address,
YES,
fix(7),
6000,
tradeGroupID,
sender=tester.k2,
value=fix('7', '6000'))
assert len(logs) == 5
log1 = logs[4]
assert log1["_event_type"] == "OrderFilled"
assert log1["filler"] == bytesToHexString(tester.a2)
assert log1["numCreatorShares"] == 0
assert log1["numCreatorTokens"] == fix('7', '4000')
assert log1["numFillerShares"] == 0
assert log1["numFillerTokens"] == fix('7', '6000')
assert log1["marketCreatorFees"] == 0
assert log1["reporterFees"] == 0
assert log1["shareToken"] == market.getShareToken(YES)
assert log1["tradeGroupId"] == stringToBytes("42")
assert orders.getAmount(orderID) == fix(5)
assert orders.getPrice(orderID) == 6000
assert orders.getOrderCreator(orderID) == bytesToHexString(tester.a1)
assert orders.getOrderMoneyEscrowed(orderID) == fix('5', '4000')
assert orders.getOrderSharesEscrowed(orderID) == 0
assert orders.getBetterOrderId(orderID) == longTo32Bytes(0)
assert orders.getWorseOrderId(orderID) == longTo32Bytes(0)
assert fillOrderID == longTo32Bytes(1)
def test_stake_token_logging(contractsFixture, market, categoricalMarket,
scalarMarket, universe):
reportingWindow = contractsFixture.applySignature(
'ReportingWindow', market.getReportingWindow())
participationToken = contractsFixture.applySignature(
"ParticipationToken", reportingWindow.getParticipationToken())
contractsFixture.chain.head_state.timestamp = market.getEndTime() + 1
assert contractsFixture.designatedReport(market,
[0, market.getNumTicks()],
tester.k0)
assert contractsFixture.designatedReport(
categoricalMarket, [0, 0, categoricalMarket.getNumTicks()], tester.k0)
assert contractsFixture.designatedReport(scalarMarket,
[0, scalarMarket.getNumTicks()],
tester.k0)
contractsFixture.chain.head_state.timestamp = reportingWindow.getStartTime(
) + 1
assert market.tryFinalize()
assert categoricalMarket.tryFinalize()
assert scalarMarket.tryFinalize()
assert participationToken.buy(100)
logs = []
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
assert participationToken.transfer(tester.a1, 8)
assert len(logs) == 1
assert logs[0]['_event_type'] == 'TokensTransferred'
assert logs[0]['from'] == bytesToHexString(tester.a0)
assert logs[0]['to'] == bytesToHexString(tester.a1)
assert logs[0]['token'] == participationToken.address
assert logs[0]['universe'] == universe.address
assert logs[0]['value'] == 8
assert participationToken.approve(tester.a2, 12)
assert participationToken.transferFrom(tester.a0,
tester.a1,
12,
sender=tester.k2)
assert len(logs) == 2
assert logs[1]['_event_type'] == 'TokensTransferred'
assert logs[1]['from'] == bytesToHexString(tester.a0)
assert logs[1]['to'] == bytesToHexString(tester.a1)
assert logs[1]['token'] == participationToken.address
assert logs[1]['universe'] == universe.address
assert logs[1]['value'] == 12
def proceedToLastReporting(testFixture, universe, market, makeReport,
designatedDisputer, firstDisputer, reportOutcomes,
designatedDisputeOutcomes, firstReporter,
firstReportOutcomes, firstReportDisputeOutcomes):
cash = testFixture.contracts['Cash']
reputationToken = testFixture.applySignature('ReputationToken',
universe.getReputationToken())
reportingWindow = testFixture.applySignature('ReportingWindow',
market.getReportingWindow())
if (market.getReportingState() !=
testFixture.contracts['Constants'].FIRST_REPORTING()):
proceedToFirstReporting(testFixture, universe, market, makeReport,
designatedDisputer, reportOutcomes,
designatedDisputeOutcomes)
stakeToken = testFixture.getOrCreateStakeToken(market, firstReportOutcomes)
# We make one report by the firstReporter
assert stakeToken.buy(1, sender=testFixture.testerKey[firstReporter])
tentativeWinner = market.getTentativeWinningPayoutDistributionHash()
assert tentativeWinner == stakeToken.getPayoutDistributionHash()
testFixture.chain.head_state.timestamp = reportingWindow.getDisputeStartTime(
) + 1
assert market.getReportingState(
) == testFixture.contracts['Constants'].FIRST_DISPUTE()
logs = []
captureFilteredLogs(testFixture.chain.head_state,
testFixture.contracts['Augur'], logs)
disputeFirstReportOutcomeStake = testFixture.contracts[
'Constants'].DESIGNATED_REPORTER_DISPUTE_BOND_AMOUNT()
assert market.disputeFirstReporters(
firstReportDisputeOutcomes,
disputeFirstReportOutcomeStake,
False,
sender=testFixture.testerKey[firstDisputer])
# Confirm the first dispute logging works
assert len(logs) == 4
assert logs[3]['_event_type'] == 'ReportsDisputed'
assert logs[3]['reportingPhase'] == testFixture.contracts[
'Constants'].FIRST_DISPUTE()
assert logs[3]['disputer'] == bytesToHexString(
testFixture.testerAddress[firstDisputer])
assert logs[3]['disputeBondAmount'] == testFixture.contracts[
'Constants'].FIRST_REPORTERS_DISPUTE_BOND_AMOUNT()
assert logs[3]['market'] == market.address
# We're in the LAST REPORTING phase now
assert market.getReportingState(
) == testFixture.contracts['Constants'].LAST_REPORTING()
def test_one_bid_on_books_buy_full_order(contractsFixture, cash, market,
universe):
createOrder = contractsFixture.contracts['CreateOrder']
trade = contractsFixture.contracts['Trade']
fillOrder = contractsFixture.contracts['FillOrder']
orders = contractsFixture.contracts['Orders']
tradeGroupID = 42L
logs = []
# create order
orderID = createOrder.publicCreateOrder(BID,
2,
fix('0.6'),
market.address,
YES,
longTo32Bytes(0),
longTo32Bytes(0),
tradeGroupID,
sender=tester.k1,
value=fix('2', '0.6'))
# fill best order
captureFilteredLogs(contractsFixture.chain.head_state, orders, logs)
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
fillOrderID = trade.publicSell(market.address,
YES,
2,
fix('0.6'),
tradeGroupID,
sender=tester.k2,
value=fix('2', '0.4'))
assert len(logs) == 5
log1 = logs[4]
assert log1["_event_type"] == "OrderFilled"
assert log1["filler"] == bytesToHexString(tester.a2)
assert log1["numCreatorShares"] == 0
assert log1["numCreatorTokens"] == fix('2', '0.6')
assert log1["numFillerShares"] == 0
assert log1["numFillerTokens"] == fix('2', '0.4')
assert log1["settlementFees"] == 0
assert log1["shareToken"] == market.getShareToken(YES)
assert log1["tradeGroupId"] == 42
assert orders.getAmount(orderID) == 0
assert orders.getPrice(orderID) == 0
assert orders.getOrderCreator(orderID) == longToHexString(0)
assert orders.getOrderMoneyEscrowed(orderID) == 0
assert orders.getOrderSharesEscrowed(orderID) == 0
assert orders.getBetterOrderId(orderID) == longTo32Bytes(0)
assert orders.getWorseOrderId(orderID) == longTo32Bytes(0)
assert fillOrderID == longTo32Bytes(1)
def test_cancelBid(contractsFixture, cash, market, universe):
createOrder = contractsFixture.contracts['CreateOrder']
cancelOrder = contractsFixture.contracts['CancelOrder']
orders = contractsFixture.contracts['Orders']
orderType = BID
fxpAmount = 1
fxpPrice = fix('0.6')
outcomeID = YES
tradeGroupID = 42
yesShareToken = contractsFixture.applySignature('ShareToken', market.getShareToken(YES))
noShareToken = contractsFixture.applySignature('ShareToken', market.getShareToken(NO))
creatorInitialETH = contractsFixture.chain.head_state.get_balance(tester.a1)
creatorInitialShares = yesShareToken.balanceOf(tester.a1)
marketInitialCash = cash.balanceOf(market.address)
marketInitialYesShares = yesShareToken.totalSupply()
marketInitialNoShares = noShareToken.totalSupply()
orderID = createOrder.publicCreateOrder(orderType, fxpAmount, fxpPrice, market.address, outcomeID, longTo32Bytes(0), longTo32Bytes(0), tradeGroupID, sender=tester.k1, value = fix('10000'))
assert orderID, "Order ID should be non-zero"
assert orders.getOrderCreator(orderID), "Order should have an owner"
assert contractsFixture.chain.head_state.get_balance(tester.a1) == creatorInitialETH - fix('0.6'), "ETH should be deducted from the creator balance"
logs = []
captureFilteredLogs(contractsFixture.chain.head_state, contractsFixture.contracts['Augur'], logs)
assert(cancelOrder.cancelOrder(orderID, orderType, market.address, outcomeID, sender=tester.k1) == 1), "cancelOrder should succeed"
# Confirm cancel order logging works correctly
assert len(logs) == 1
assert logs[0]['_event_type'] == 'OrderCanceled'
assert logs[0]['orderId'] == orderID
assert logs[0]['shareToken'] == yesShareToken.address
assert logs[0]['sender'] == bytesToHexString(tester.a1)
assert logs[0]['orderType'] == orderType
assert logs[0]['sharesRefund'] == 0
assert logs[0]['tokenRefund'] == fix('0.6')
assert orders.getAmount(orderID) == 0
assert orders.getPrice(orderID) == 0
assert orders.getOrderCreator(orderID) == longToHexString(0)
assert orders.getOrderMoneyEscrowed(orderID) == 0
assert orders.getOrderSharesEscrowed(orderID) == 0
assert orders.getBetterOrderId(orderID) == longTo32Bytes(0)
assert orders.getWorseOrderId(orderID) == longTo32Bytes(0)
assert(creatorInitialETH == contractsFixture.chain.head_state.get_balance(tester.a1)), "Maker's ETH should be the same as before the order was placed"
assert(marketInitialCash == cash.balanceOf(market.address)), "Market's cash balance should be the same as before the order was placed"
assert(creatorInitialShares == yesShareToken.balanceOf(tester.a1)), "Maker's shares should be unchanged"
assert(marketInitialYesShares == yesShareToken.totalSupply()), "Market's yes shares should be unchanged"
assert marketInitialNoShares == noShareToken.totalSupply(), "Market's no shares should be unchanged"
def test_redeem_shares_in_binary_market(kitchenSinkFixture, universe, cash, market):
claimTradingProceeds = kitchenSinkFixture.contracts['ClaimTradingProceeds']
yesShareToken = kitchenSinkFixture.applySignature('ShareToken', market.getShareToken(YES))
noShareToken = kitchenSinkFixture.applySignature('ShareToken', market.getShareToken(NO))
expectedValue = 1 * market.getNumTicks()
expectedReporterFees = expectedValue / universe.getOrCacheReportingFeeDivisor()
expectedMarketCreatorFees = expectedValue / market.getMarketCreatorSettlementFeeDivisor()
expectedSettlementFees = expectedReporterFees + expectedMarketCreatorFees
expectedPayout = long(expectedValue - expectedSettlementFees)
assert universe.getOpenInterestInAttoEth() == 0
# get YES shares with a1
acquireLongShares(kitchenSinkFixture, cash, market, YES, 1, claimTradingProceeds.address, sender = tester.k1)
assert universe.getOpenInterestInAttoEth() == 1 * market.getNumTicks()
# get NO shares with a2
acquireShortShareSet(kitchenSinkFixture, cash, market, YES, 1, claimTradingProceeds.address, sender = tester.k2)
assert universe.getOpenInterestInAttoEth() == 2 * market.getNumTicks()
finalizeMarket(kitchenSinkFixture, market, [0,10**4])
logs = []
captureFilteredLogs(kitchenSinkFixture.chain.head_state, kitchenSinkFixture.contracts['Augur'], logs)
with TokenDelta(cash, expectedMarketCreatorFees, market.getMarketCreatorMailbox(), "Market creator fees not paid"):
with TokenDelta(cash, expectedReporterFees, universe.getOrCreateNextFeeWindow(), "Reporter fees not paid"):
# redeem shares with a1
initialLongHolderETH = kitchenSinkFixture.chain.head_state.get_balance(tester.a1)
claimTradingProceeds.claimTradingProceeds(market.address, tester.a1)
# redeem shares with a2
initialShortHolderETH = kitchenSinkFixture.chain.head_state.get_balance(tester.a2)
claimTradingProceeds.claimTradingProceeds(market.address, tester.a2)
# Confirm claim proceeds logging works correctly
assert len(logs) == 6
assert logs[3]['_event_type'] == 'TradingProceedsClaimed'
assert logs[3]['market'] == market.address
assert logs[3]['shareToken'] == yesShareToken.address
assert logs[3]['numPayoutTokens'] == expectedPayout
assert logs[3]['numShares'] == 1
assert logs[3]['sender'] == bytesToHexString(tester.a1)
assert logs[3]['finalTokenBalance'] == initialLongHolderETH + expectedPayout
# assert a1 ends up with cash (minus fees) and a2 does not
assert kitchenSinkFixture.chain.head_state.get_balance(tester.a1) == initialLongHolderETH + expectedPayout
assert kitchenSinkFixture.chain.head_state.get_balance(tester.a2) == initialShortHolderETH
assert yesShareToken.balanceOf(tester.a1) == 0
assert yesShareToken.balanceOf(tester.a2) == 0
assert noShareToken.balanceOf(tester.a1) == 0
assert noShareToken.balanceOf(tester.a2) == 0
assert universe.getOpenInterestInAttoEth() == 1 * market.getNumTicks() # The corresponding share for tester2's complete set has not been redeemed
def test_transfer(contractsFixture, market):
shareToken = contractsFixture.applySignature('ShareToken',
market.getShareToken())
shareToken.createShares(tester.a0, 7, sender=tester.k0)
initialTotalSupply = shareToken.totalSupply()
initialBalance0 = shareToken.balanceOf(tester.a0)
initialBalance1 = shareToken.balanceOf(tester.a1)
logs = []
with raises(TransactionFailed):
shareToken.transfer(tester.a0, 11, sender=tester.k0)
with raises(TransactionFailed):
shareToken.transfer(tester.a0, 5, sender=tester.k1)
captureFilteredLogs(contractsFixture.chain.head_state, shareToken, logs)
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts["Augur"], logs)
retval = shareToken.transfer(tester.a1, 5, sender=tester.k0)
afterTransferBalance0 = shareToken.balanceOf(tester.a0)
afterTransferBalance1 = shareToken.balanceOf(tester.a1)
assert (retval == 1), "transfer should succeed"
assert logs == [{
"_event_type": "Transfer",
"from": bytesToHexString(tester.a0),
"to": bytesToHexString(tester.a1),
"value": 5,
}, {
"_event_type": "TokensTransferred",
"token": shareToken.address,
"from": bytesToHexString(tester.a0),
"to": bytesToHexString(tester.a1),
"universe": market.getUniverse(),
"tokenType": 1,
"market": market.address,
"value": 5
}]
assert (
initialBalance0 - 5 == afterTransferBalance0
), "Decrease in address 1's balance should equal amount transferred"
assert (
initialBalance1 + 5 == afterTransferBalance1
), "Increase in address 2's balance should equal amount transferred"
assert (shareToken.totalSupply() == initialTotalSupply
), "Total supply should be unchanged"
assert (retval == 1), "transfer with 0 value should succeed"
def proceedToFirstReporting(testFixture, universe, market, makeReport,
disputer, reportOutcomes,
designatedDisputeOutcomes):
if (market.getReportingState() !=
testFixture.contracts['Constants'].DESIGNATED_REPORTING()):
proceedToDesignatedReporting(testFixture, universe, market,
reportOutcomes)
# To proceed to first reporting we will either dispute a designated report or not make a designated report within the alotted time window for doing so
if (makeReport):
assert testFixture.designatedReport(market, reportOutcomes, tester.k0)
assert market.getReportingState(
) == testFixture.contracts['Constants'].DESIGNATED_DISPUTE()
logs = []
captureFilteredLogs(testFixture.chain.head_state,
testFixture.contracts['Augur'], logs)
assert market.disputeDesignatedReport(
designatedDisputeOutcomes,
1,
False,
sender=testFixture.testerKey[disputer])
# Confirm the designated dispute logging works
assert len(logs) == 4
assert logs[3]['_event_type'] == 'ReportsDisputed'
assert logs[3]['reportingPhase'] == testFixture.contracts[
'Constants'].DESIGNATED_DISPUTE()
assert logs[3]['disputer'] == bytesToHexString(
testFixture.testerAddress[disputer])
assert logs[3]['disputeBondAmount'] == testFixture.contracts[
'Constants'].DESIGNATED_REPORTER_DISPUTE_BOND_AMOUNT()
assert logs[3]['market'] == market.address
else:
testFixture.chain.head_state.timestamp = market.getEndTime(
) + testFixture.contracts[
'Constants'].DESIGNATED_REPORTING_DURATION_SECONDS() + 1
# We're in the FIRST REPORTING phase now
assert market.getReportingState(
) == testFixture.contracts['Constants'].FIRST_REPORTING()
def test_market_creation(contractsFixture, universe, cash, market):
numTicks = market.getNumTicks()
logs = []
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
market = contractsFixture.createReasonableBinaryMarket(
universe, cash, extraInfo="so extra")
assert len(logs) == 3
assert logs[2]['_event_type'] == 'MarketCreated'
assert logs[2]['extraInfo'] == 'so extra'
assert logs[2][
'marketCreationFee'] == universe.getOrCacheMarketCreationCost()
assert logs[2]['market'] == market.address
assert logs[2]['marketCreator'] == bytesToHexString(tester.a0)
assert market.getUniverse() == universe.address
assert market.getNumberOfOutcomes() == 2
assert numTicks == 10000
assert market.getReputationToken() == universe.getReputationToken()
assert market.getWinningPayoutDistributionHash() == stringToBytes("")
def test_stake_token_logging(contractsFixture, market, universe):
stakeToken = contractsFixture.getOrCreateStakeToken(
market, [market.getNumTicks(), 0])
reportingWindow = contractsFixture.applySignature(
'ReportingWindow', universe.getOrCreateNextReportingWindow())
# Fast forward to one second after the next reporting window
contractsFixture.chain.head_state.timestamp = reportingWindow.getStartTime(
) + 1
stakeToken.buy(100)
logs = []
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
assert stakeToken.transfer(tester.a1, 8)
assert len(logs) == 1
assert logs[0]['_event_type'] == 'TokensTransferred'
assert logs[0]['from'] == bytesToHexString(tester.a0)
assert logs[0]['to'] == bytesToHexString(tester.a1)
assert logs[0]['token'] == stakeToken.address
assert logs[0]['universe'] == universe.address
assert logs[0]['value'] == 8
assert stakeToken.approve(tester.a2, 12)
assert stakeToken.transferFrom(tester.a0, tester.a1, 12, sender=tester.k2)
assert len(logs) == 2
assert logs[1]['_event_type'] == 'TokensTransferred'
assert logs[1]['from'] == bytesToHexString(tester.a0)
assert logs[1]['to'] == bytesToHexString(tester.a1)
assert logs[1]['token'] == stakeToken.address
assert logs[1]['universe'] == universe.address
assert logs[1]['value'] == 12
def test_approve(contractsFixture, market):
shareToken = contractsFixture.applySignature('ShareToken', market.getShareToken())
shareToken.createShares(tester.a0, 7, sender=tester.k0)
logs = []
assert(shareToken.allowance(tester.a0, tester.a1) == 0), "initial allowance is 0"
captureFilteredLogs(contractsFixture.chain.head_state, shareToken, logs)
captureFilteredLogs(contractsFixture.chain.head_state, contractsFixture.contracts["Augur"], logs)
retval = shareToken.approve(tester.a1, 10, sender=tester.k0)
assert(retval == 1), "approve a2 to spend 10 cash from a1"
assert(shareToken.allowance(tester.a0, tester.a1) == 10), "allowance is 10 after approval"
retval = shareToken.transferFrom(tester.a0, tester.a1, 7, sender=tester.k1)
assert(retval == 1), "transferFrom should succeed"
assert logs == [
{
"_event_type": "Approval",
"owner": bytesToHexString(tester.a0),
"spender": bytesToHexString(tester.a1),
"value": 10
},
{
"_event_type": "Transfer",
"from": bytesToHexString(tester.a0),
"to": bytesToHexString(tester.a1),
"value": 7
},
{
"_event_type": "TokensTransferred",
"token": shareToken.address,
"from": bytesToHexString(tester.a0),
"to": bytesToHexString(tester.a1),
"universe": market.getUniverse(),
"tokenType": 1,
"market": market.address,
"value": 7
}
]
def test_designatedReportingHappyPath(localFixture, universe, market):
# Proceed to the DESIGNATED REPORTING phase
proceedToDesignatedReporting(localFixture, universe, market, [0,market.getNumTicks()])
reportingWindow = localFixture.applySignature("ReportingWindow", market.getReportingWindow())
originalNumDesignatedReportNoShows = reportingWindow.getNumDesignatedReportNoShows()
# To progress into the DESIGNATED DISPUTE phase we do a designated report
logs = []
captureFilteredLogs(localFixture.chain.head_state, localFixture.contracts['Augur'], logs)
assert localFixture.designatedReport(market, [0,market.getNumTicks()], tester.k0)
# Confirm the designated report logging works
assert len(logs) == 4
assert logs[3]['_event_type'] == 'DesignatedReportSubmitted'
assert logs[3]['amountStaked'] == localFixture.contracts["Constants"].DEFAULT_DESIGNATED_REPORT_STAKE()
assert logs[3]['reporter'] == bytesToHexString(tester.a0)
assert logs[3]['stakeToken'] == localFixture.getOrCreateStakeToken(market, [0,market.getNumTicks()]).address
assert logs[3]['market'] == market.address
assert logs[3]['payoutNumerators'] == [0,market.getNumTicks()]
# making a designated report also decremented the no show accounting on the reporting window
assert reportingWindow.getNumDesignatedReportNoShows() == originalNumDesignatedReportNoShows - 1
# We're now in the DESIGNATED DISPUTE PHASE
assert market.getReportingState() == localFixture.contracts['Constants'].DESIGNATED_DISPUTE()
# If time passes and no dispute bond is placed the market can be finalized
localFixture.chain.head_state.timestamp = market.getEndTime() + localFixture.contracts['Constants'].DESIGNATED_REPORTING_DURATION_SECONDS() + localFixture.contracts['Constants'].DESIGNATED_REPORTING_DISPUTE_DURATION_SECONDS() + 1
# The market is awaiting finalization now
assert market.getReportingState() == localFixture.contracts['Constants'].AWAITING_FINALIZATION()
# We can finalize it
assert market.tryFinalize()
assert market.getReportingState() == localFixture.contracts['Constants'].FINALIZED()
def test_reportingFullHappyPath(getStakeBonus, localFixture, universe, cash, market):
reputationToken = localFixture.applySignature('ReputationToken', universe.getReputationToken())
stakeTokenNo = localFixture.getOrCreateStakeToken(market, [market.getNumTicks(),0])
stakeTokenYes = localFixture.getOrCreateStakeToken(market, [0,market.getNumTicks()])
reportingWindow = localFixture.applySignature('ReportingWindow', universe.getOrCreateNextReportingWindow())
expectedMarketCreatorFeePayout = universe.getOrCacheValidityBond()
reporterGasCosts = universe.getOrCacheTargetReporterGasCosts()
# We can't yet report on the market as it's in the pre reporting phase
assert market.getReportingState() == localFixture.contracts['Constants'].PRE_REPORTING()
with raises(TransactionFailed, message="Reporting cannot be done in the PRE REPORTING state"):
stakeTokenNo.buy(100, sender=tester.k0)
# Fast forward to one second after the next reporting window
localFixture.chain.head_state.timestamp = reportingWindow.getStartTime() + 1
# This will cause us to be in the first reporting phase
assert market.getReportingState() == localFixture.contracts['Constants'].FIRST_REPORTING()
noShowBondCosts = 3 * localFixture.contracts['Constants'].DEFAULT_DESIGNATED_REPORT_NO_SHOW_BOND()
# Both reporters report on the outcome. Tester 1 reports first, winning the no-show REP bond and and causing the YES outcome to be the tentative winner
initialFirstReporterETH = localFixture.chain.head_state.get_balance(tester.a1)
stakeTokenYes.buy(0, sender=tester.k1)
assert stakeTokenYes.balanceOf(tester.a1) == 2 * 10 ** 18
assert reputationToken.balanceOf(tester.a1) == 1 * 10**6 * 10 **18
stakeTokenNo.buy(100, sender=tester.k0)
assert stakeTokenNo.balanceOf(tester.a0) == 100
assert reputationToken.balanceOf(tester.a0) == 8 * 10**6 * 10 **18 - 100 - noShowBondCosts
tentativeWinner = market.getTentativeWinningPayoutDistributionHash()
assert tentativeWinner == stakeTokenYes.getPayoutDistributionHash()
# The first reporter also recieves reporter gas fees
assert localFixture.chain.head_state.get_balance(tester.a1) == initialFirstReporterETH + reporterGasCosts
# Move time forward into the FIRST DISPUTE phase
localFixture.chain.head_state.timestamp = reportingWindow.getDisputeStartTime() + 1
assert market.getReportingState() == localFixture.contracts['Constants'].FIRST_DISPUTE()
# Contest the results with Tester 0
market.disputeFirstReporters([], 0, False, sender=tester.k0)
assert not reportingWindow.isContainerForMarket(market.address)
assert universe.isContainerForMarket(market.address)
reportingWindow = localFixture.applySignature('ReportingWindow', market.getReportingWindow())
assert reportingWindow.isContainerForMarket(market.address)
# We're now in the LAST REPORTING phase
assert market.getReportingState() == localFixture.contracts['Constants'].LAST_REPORTING()
# Tester 0 has a REP balance less the first bond amount
assert reputationToken.balanceOf(tester.a0) == 8 * 10**6 * 10 **18 - 100 - 11 * 10**21 - noShowBondCosts
# Tester 2 reports for the NO outcome
localFixture.chain.head_state.timestamp = reportingWindow.getStartTime() + 1
stakeTokenNo.buy(2, sender=tester.k2)
assert stakeTokenNo.balanceOf(tester.a2) == 2
assert reputationToken.balanceOf(tester.a2) == 10**6 * 10 **18 - 2
tentativeWinner = market.getTentativeWinningPayoutDistributionHash()
assert tentativeWinner == stakeTokenNo.getPayoutDistributionHash()
# Move forward in time to put us in the LAST DISPUTE PHASE
localFixture.chain.head_state.timestamp = reportingWindow.getDisputeStartTime() + 1
assert market.getReportingState() == localFixture.contracts['Constants'].LAST_DISPUTE()
# Tester 1 contests the outcome of the ALL report which will cause a fork
market.disputeLastReporters(sender=tester.k1)
assert universe.getForkingMarket() == market.address
assert not reportingWindow.isContainerForMarket(market.address)
assert universe.isContainerForMarket(market.address)
reportingWindow = localFixture.applySignature('ReportingWindow', market.getReportingWindow())
assert reportingWindow.isContainerForMarket(market.address)
assert market.getReportingState() == localFixture.contracts['Constants'].FORKING()
# The universe forks and there is now a universe where NO and YES are the respective outcomes of each
noUniverse = localFixture.getOrCreateChildUniverse(universe, market, [market.getNumTicks(),0])
noUniverseReputationToken = localFixture.applySignature('ReputationToken', noUniverse.getReputationToken())
assert noUniverse.address != universe.address
yesUniverse = localFixture.getOrCreateChildUniverse(universe, market, [0,market.getNumTicks()])
yesUniverseReputationToken = localFixture.applySignature('ReputationToken', yesUniverse.getReputationToken())
assert yesUniverse.address != universe.address
assert yesUniverse.address != noUniverse.address
# Attempting to finalize the fork now will not succeed as no REP has been migrated
assert market.tryFinalize() == 0
logs = []
captureFilteredLogs(localFixture.chain.head_state, localFixture.contracts['Augur'], logs)
# Tester 1 moves their ~1 Million REP to the YES universe and gets a fixed percentage bonus for doing so within the FORKING period
expectedAmount = reputationToken.balanceOf(tester.a1)
bonus = expectedAmount / localFixture.contracts["Constants"].FORK_MIGRATION_PERCENTAGE_BONUS_DIVISOR()
reputationToken.migrateOut(yesUniverseReputationToken.address, tester.a1, reputationToken.balanceOf(tester.a1), sender = tester.k1)
assert not reputationToken.balanceOf(tester.a1)
assert yesUniverseReputationToken.balanceOf(tester.a1) == expectedAmount + bonus
# Confirm the token logs were generated correctly
assert len(logs) == 3
burnLog = logs[0]
mintLog = logs[1]
bonusMintLog = logs[2]
assert burnLog['_event_type'] == 'TokensBurned'
assert burnLog['amount'] == expectedAmount
assert burnLog['token'] == reputationToken.address
assert burnLog['universe'] == universe.address
assert mintLog['_event_type'] == 'TokensMinted'
assert mintLog['amount'] == expectedAmount
assert mintLog['token'] == yesUniverseReputationToken.address
assert mintLog['universe'] == yesUniverse.address
assert bonusMintLog['_event_type'] == 'TokensMinted'
assert bonusMintLog['amount'] == bonus
assert bonusMintLog['token'] == yesUniverseReputationToken.address
assert bonusMintLog['universe'] == yesUniverse.address
# Attempting to finalize the fork now will not succeed as a majority or REP has not yet migrated and fork end time has not been reached
assert market.tryFinalize() == 0
# Testers 0 and 2 move their combined ~9 million REP to the NO universe and receive a bonus since they are within the FORKING period
expectedAmount = reputationToken.balanceOf(tester.a0)
bonus = expectedAmount / localFixture.contracts["Constants"].FORK_MIGRATION_PERCENTAGE_BONUS_DIVISOR()
reputationToken.migrateOut(noUniverseReputationToken.address, tester.a0, reputationToken.balanceOf(tester.a0), sender = tester.k0)
assert not reputationToken.balanceOf(tester.a0)
tester0REPBalance = noUniverseReputationToken.balanceOf(tester.a0)
assert tester0REPBalance == expectedAmount + bonus
expectedAmount = reputationToken.balanceOf(tester.a2)
bonus = expectedAmount / localFixture.contracts["Constants"].FORK_MIGRATION_PERCENTAGE_BONUS_DIVISOR()
reputationToken.migrateOut(noUniverseReputationToken.address, tester.a2, reputationToken.balanceOf(tester.a2), sender = tester.k2)
assert not reputationToken.balanceOf(tester.a2)
assert noUniverseReputationToken.balanceOf(tester.a2) == expectedAmount + bonus
logs = []
captureFilteredLogs(localFixture.chain.head_state, localFixture.contracts['Augur'], logs)
# We can finalize the market now since a mjaority of REP has moved. Alternatively we could "localFixture.chain.head_state.timestamp = universe.getForkEndTime() + 1" to move
initialMarketCreatorETHBalance = localFixture.chain.head_state.get_balance(market.getMarketCreatorMailbox())
assert market.tryFinalize()
# Confirm market finalization logging works
assert len(logs) == 1
assert logs[0]['_event_type'] == 'MarketFinalized'
assert logs[0]['market'] == market.address
# The market is now finalized and the NO outcome is the winner
assert market.getReportingState() == localFixture.contracts['Constants'].FINALIZED()
assert market.getFinalWinningStakeToken() == stakeTokenNo.address
# Since the designated report was not invalid the market creator gets back the validity bond
increaseInMarketCreatorBalance = localFixture.chain.head_state.get_balance(market.getMarketCreatorMailbox()) - initialMarketCreatorETHBalance
assert increaseInMarketCreatorBalance == expectedMarketCreatorFeePayout
# We can redeem forked REP on any universe we didn't dispute
stakeTokenBalance = stakeTokenNo.balanceOf(tester.a0)
# If we wait until after the fork window we won't get the bonus when migrating stake tokens
bonus = stakeTokenBalance / localFixture.contracts["Constants"].FORK_MIGRATION_PERCENTAGE_BONUS_DIVISOR()
expectedrepBalanceInNewUniverse = noUniverseReputationToken.balanceOf(tester.a0) + stakeTokenBalance
if (not getStakeBonus):
localFixture.chain.head_state.timestamp = universe.getForkEndTime() + 1
else:
expectedrepBalanceInNewUniverse += bonus
assert stakeTokenNo.redeemForkedTokens(sender = tester.k0)
assert noUniverseReputationToken.balanceOf(tester.a0) == expectedrepBalanceInNewUniverse
# We can also see that a tester who now migrates their REP will also not get the bonus
expectedAmount = reputationToken.balanceOf(tester.a3)
reputationToken.migrateOut(noUniverseReputationToken.address, tester.a3, reputationToken.balanceOf(tester.a3), sender = tester.k3)
assert not reputationToken.balanceOf(tester.a3)
assert noUniverseReputationToken.balanceOf(tester.a3) == expectedAmount
def test_initial_report_and_participation_fee_collection(
localFixture, universe, market, categoricalMarket, scalarMarket, cash,
reputationToken):
feeWindow = localFixture.applySignature('FeeWindow', market.getFeeWindow())
constants = localFixture.contracts["Constants"]
# We cannot purchase participation tokens yet since the window isn't active
with raises(TransactionFailed):
feeWindow.buy(1)
# generate some fees
generateFees(localFixture, universe, market)
# We'll make the window active then purchase some participation tokens
localFixture.contracts["Time"].setTimestamp(feeWindow.getStartTime() + 1)
feeWindowAmount = 100
with TokenDelta(reputationToken, -feeWindowAmount, tester.a0,
"Buying participation tokens didn't deduct REP correctly"):
with TokenDelta(
feeWindow, feeWindowAmount, tester.a0,
"Buying participation tokens didn't increase participation token balance correctly"
):
assert feeWindow.buy(feeWindowAmount)
# As other testers we'll buy some more
assert feeWindow.buy(feeWindowAmount, sender=tester.k1)
assert feeWindow.buy(feeWindowAmount, sender=tester.k2)
assert feeWindow.buy(feeWindowAmount, sender=tester.k3)
# We can't redeem the participation tokens yet since the window isn't over
with raises(TransactionFailed):
feeWindow.redeem(False)
# Now end the window and finalize
localFixture.contracts["Time"].setTimestamp(feeWindow.getEndTime() + 1)
assert market.finalize()
assert categoricalMarket.finalize()
assert scalarMarket.finalize()
marketInitialReport = localFixture.applySignature(
'InitialReporter', market.getInitialReporter())
categoricalInitialReport = localFixture.applySignature(
'InitialReporter', categoricalMarket.getInitialReporter())
scalarInitialReport = localFixture.applySignature(
'InitialReporter', scalarMarket.getInitialReporter())
reporterFees = 1000 * market.getNumTicks(
) / universe.getOrCacheReportingFeeDivisor()
totalStake = feeWindow.getTotalFeeStake()
assert cash.balanceOf(feeWindow.address) == reporterFees
expectedParticipationFees = reporterFees * feeWindowAmount / totalStake
# Cashing out Participation tokens will awards fees proportional to the total winning stake in the window
with TokenDelta(reputationToken, feeWindowAmount, tester.a0,
"Redeeming participation tokens didn't refund REP"):
with TokenDelta(
feeWindow, -feeWindowAmount, tester.a0,
"Redeeming participation tokens didn't decrease participation token balance correctly"
):
with EtherDelta(
expectedParticipationFees, tester.a0, localFixture.chain,
"Redeeming participation tokens didn't increase ETH correctly"
):
assert feeWindow.redeem(tester.a0)
with TokenDelta(reputationToken, feeWindowAmount, tester.a1,
"Redeeming participation tokens didn't refund REP"):
with TokenDelta(
feeWindow, -feeWindowAmount, tester.a1,
"Redeeming participation tokens didn't decrease participation token balance correctly"
):
with EtherDelta(
expectedParticipationFees, tester.a1, localFixture.chain,
"Redeeming participation tokens didn't increase ETH correctly"
):
assert feeWindow.redeem(tester.a1)
with TokenDelta(reputationToken, feeWindowAmount, tester.a2,
"Redeeming participation tokens didn't refund REP"):
with TokenDelta(
feeWindow, -feeWindowAmount, tester.a2,
"Redeeming participation tokens didn't decrease participation token balance correctly"
):
with EtherDelta(
expectedParticipationFees, tester.a2, localFixture.chain,
"Redeeming participation tokens didn't increase ETH correctly"
):
assert feeWindow.redeem(tester.a2)
logs = []
captureFilteredLogs(localFixture.chain.head_state,
localFixture.contracts['Augur'], logs)
marketStake = marketInitialReport.getStake()
expectedFees = reporterFees * marketStake / totalStake
winningsRedeemedLog = {
"reporter": bytesToHexString(tester.a0),
"reportingParticipant": marketInitialReport.address,
"amountRedeemed": marketStake,
"reportingFeesReceived": expectedFees,
"payoutNumerators": [market.getNumTicks(), 0],
"universe": universe.address,
"market": market.address
}
with AssertLog(localFixture, "WinningsRedeemed", winningsRedeemedLog):
with TokenDelta(reputationToken, marketStake, tester.a0,
"Redeeming didn't refund REP"):
with EtherDelta(expectedFees, tester.a0, localFixture.chain,
"Redeeming didn't increase ETH correctly"):
assert marketInitialReport.redeem(tester.a0)
categoricalMarketStake = categoricalInitialReport.getStake()
expectedFees = reporterFees * categoricalMarketStake / totalStake
with TokenDelta(reputationToken, categoricalMarketStake, tester.a0,
"Redeeming didn't refund REP"):
with EtherDelta(expectedFees, tester.a0, localFixture.chain,
"Redeeming didn't increase ETH correctly"):
assert categoricalInitialReport.redeem(tester.a0)
def test_token_fee_collection(localFixture, universe, market,
categoricalMarket, scalarMarket, cash,
reputationToken, reportingWindow):
# We'll progress past the designated dispute phase and finalize all the markets
localFixture.chain.head_state.timestamp = market.getEndTime(
) + localFixture.contracts[
"Constants"].DESIGNATED_REPORTING_DURATION_SECONDS() + 1
assert market.tryFinalize()
assert categoricalMarket.tryFinalize()
assert scalarMarket.tryFinalize()
# We can't redeem the stake used to do the designated report for fees yet since the window is not yet over
marketDesignatedStake = localFixture.getOrCreateStakeToken(
market, [0, market.getNumTicks()])
categoricalMarketDesignatedStake = localFixture.getOrCreateStakeToken(
categoricalMarket, [0, 0, categoricalMarket.getNumTicks()])
scalarMarketDesignatedStake = localFixture.getOrCreateStakeToken(
scalarMarket, [0, scalarMarket.getNumTicks()])
with raises(TransactionFailed):
marketDesignatedStake.redeemWinningTokens(False)
# If we forgo fees we can redeem however. We'll do this for the scalar market. Note that the market total stake isn't decreased. Market total stake only decreases once it is finalized at which point it can no longer migrate so the value doesn't matter
scalarStake = scalarMarketDesignatedStake.balanceOf(tester.a0)
with TokenDelta(reputationToken, scalarStake, tester.a0,
"Forgoing fees resulting in an incorrect REP refund"):
with EtherDelta(0, tester.a0, localFixture.chain,
"Forgoing fees gave fees incorrectly"):
with StakeDelta(
0, -scalarStake, -scalarStake, scalarMarket,
reportingWindow,
"Forgoing fees incorrectly updated stake accounting"):
assert scalarMarketDesignatedStake.redeemWinningTokens(True)
# We cannot purchase participation tokens yet since the window isn't active
participationToken = localFixture.applySignature(
"ParticipationToken", reportingWindow.getParticipationToken())
with raises(TransactionFailed):
participationToken.buy(1)
# We'll progress to the start of the window and purchase some participation tokens
localFixture.chain.head_state.timestamp = reportingWindow.getStartTime(
) + 1
participationTokenAmount = 100
with TokenDelta(reputationToken, -participationTokenAmount, tester.a0,
"Buying participation tokens didn't deduct REP correctly"):
with TokenDelta(
participationToken, participationTokenAmount, tester.a0,
"Buying participation tokens didn't increase participation token balance correctly"
):
with StakeDelta(
0, participationTokenAmount, participationTokenAmount,
market, reportingWindow,
"Buying participation tokens din't adjust stake accounting correctly"
):
assert participationToken.buy(participationTokenAmount)
# As other testers we'll buy some more
with StakeDelta(
0, participationTokenAmount * 3, participationTokenAmount * 3,
market, reportingWindow,
"Buying participation tokens din't adjust stake accounting correctly"
):
with TokenDelta(
participationToken, participationTokenAmount, tester.a1,
"Buying participation tokens didn't increase participation token balance correctly"
):
assert participationToken.buy(participationTokenAmount,
sender=tester.k1)
with TokenDelta(
participationToken, participationTokenAmount, tester.a2,
"Buying participation tokens didn't increase participation token balance correctly"
):
assert participationToken.buy(participationTokenAmount,
sender=tester.k2)
with TokenDelta(
participationToken, participationTokenAmount, tester.a3,
"Buying participation tokens didn't increase participation token balance correctly"
):
assert participationToken.buy(participationTokenAmount,
sender=tester.k3)
# We can't redeem the participation tokens for fees yet since the window isn't over
with raises(TransactionFailed):
participationToken.redeem(False)
# We can redeem them to just get back REP. We'll have tester 3 do this
participationValue = participationToken.balanceOf(tester.a3)
with TokenDelta(reputationToken, participationValue, tester.a3,
"Forgoing fees resulting in an incorrect REP refund"):
with TokenDelta(
participationToken, -participationTokenAmount, tester.a3,
"Redeeming participation tokens didn't decrease participation token balance correctly"
):
with EtherDelta(0, tester.a0, localFixture.chain,
"Forgoing fees gave fees incorrectly"):
with StakeDelta(
0, -participationValue, -participationValue, market,
reportingWindow,
"Forgoing fees incorrectly updated stake accounting"):
assert participationToken.redeem(True, sender=tester.k3)
# Fast forward time until the window is over and we can redeem our winning stake and participation tokens and receive fees
localFixture.chain.head_state.timestamp = reportingWindow.getEndTime() + 1
reporterFees = 1000 * market.getNumTicks(
) / universe.getOrCacheReportingFeeDivisor()
totalWinningStake = reportingWindow.getTotalWinningStake()
assert cash.balanceOf(reportingWindow.address) == reporterFees
expectedParticipationFees = reporterFees * participationTokenAmount / totalWinningStake
# Cashing out Participation tokens or Stake tokens will awards fees proportional to the total winning stake in the window
with TokenDelta(
participationToken, -participationTokenAmount, tester.a0,
"Redeeming participation tokens didn't decrease participation token balance correctly"
):
with EtherDelta(
expectedParticipationFees, tester.a0, localFixture.chain,
"Redeeming participation tokens didn't increase ETH correctly"
):
assert participationToken.redeem(False)
with TokenDelta(
participationToken, -participationTokenAmount, tester.a1,
"Redeeming participation tokens didn't decrease participation token balance correctly"
):
with EtherDelta(
expectedParticipationFees, tester.a1, localFixture.chain,
"Redeeming participation tokens didn't increase ETH correctly"
):
assert participationToken.redeem(False, sender=tester.k1)
with TokenDelta(
participationToken, -participationTokenAmount, tester.a2,
"Redeeming participation tokens didn't decrease participation token balance correctly"
):
with EtherDelta(
expectedParticipationFees, tester.a2, localFixture.chain,
"Redeeming participation tokens didn't increase ETH correctly"
):
assert participationToken.redeem(False, sender=tester.k2)
logs = []
captureFilteredLogs(localFixture.chain.head_state,
localFixture.contracts['Augur'], logs)
marketStake = marketDesignatedStake.balanceOf(tester.a0)
expectedFees = reporterFees * marketStake / totalWinningStake + 1 # Rounding error
with EtherDelta(expectedFees, tester.a0, localFixture.chain,
"Redeeming Stake tokens didn't increase ETH correctly"):
with TokenDelta(
marketDesignatedStake, -marketStake, tester.a0,
"Redeeming Stake tokens didn't decrease Stake token balance correctly"
):
assert marketDesignatedStake.redeemWinningTokens(False)
# Confirm redeeming stake tokens logs appropriately
assert len(logs) == 3
assert logs[2]['_event_type'] == 'WinningTokensRedeemed'
assert logs[2]['reporter'] == bytesToHexString(tester.a0)
assert logs[2]['reportingFeesReceived'] == expectedFees
assert logs[2]['stakeToken'] == marketDesignatedStake.address
assert logs[2]['market'] == market.address
assert logs[2]['amountRedeemed'] == marketStake
assert logs[2]['payoutNumerators'] == [0, market.getNumTicks()]
categoricalMarketStake = categoricalMarketDesignatedStake.balanceOf(
tester.a0)
expectedFees = reporterFees * categoricalMarketStake / totalWinningStake + 1 # Rounding error
with EtherDelta(expectedFees, tester.a0, localFixture.chain,
"Redeeming Stake tokens didn't increase ETH correctly"):
with TokenDelta(
categoricalMarketDesignatedStake, -categoricalMarketStake,
tester.a0,
"Redeeming Stake tokens didn't decrease Stake token balance correctly"
):
assert categoricalMarketDesignatedStake.redeemWinningTokens(False)
def test_fill_order_with_shares_escrowed_sell_with_shares(
contractsFixture, cash, market, universe):
createOrder = contractsFixture.contracts['CreateOrder']
fillOrder = contractsFixture.contracts['FillOrder']
orders = contractsFixture.contracts['Orders']
completeSets = contractsFixture.contracts['CompleteSets']
yesShareToken = contractsFixture.applySignature('ShareToken',
market.getShareToken(YES))
noShareToken = contractsFixture.applySignature('ShareToken',
market.getShareToken(NO))
# buy complete sets for both users
assert completeSets.publicBuyCompleteSets(market.address,
fix(1),
sender=tester.k1,
value=fix('1', '10000'))
assert yesShareToken.balanceOf(tester.a1) == fix(1)
assert completeSets.publicBuyCompleteSets(market.address,
fix(1),
sender=tester.k2,
value=fix('1', '10000'))
assert noShareToken.balanceOf(tester.a2) == fix(1)
# create order with shares
logs = []
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
orderID = createOrder.publicCreateOrder(ASK,
fix(1),
6000,
market.address,
YES,
longTo32Bytes(0),
longTo32Bytes(0),
"42",
sender=tester.k1)
assert orderID
# fill order with shares
assert fillOrder.publicFillOrder(orderID, fix(1), "43",
sender=tester.k2) == 0
assert len(logs) == 8
log1 = logs[7]
assert log1["_event_type"] == "OrderFilled"
assert log1["filler"] == bytesToHexString(tester.a2)
assert log1["numCreatorShares"] == fix(1)
assert log1["numCreatorTokens"] == 0
assert log1["numFillerShares"] == fix(1)
assert log1["numFillerTokens"] == 0
assert log1["marketCreatorFees"] == fix(
1, 10000) / market.getMarketCreatorSettlementFeeDivisor()
assert log1["reporterFees"] == fix(
1, 10000) / universe.getOrCacheReportingFeeDivisor()
assert log1["shareToken"] == market.getShareToken(YES)
assert log1["tradeGroupId"] == stringToBytes("43")
assert orders.getAmount(orderID) == 0
assert orders.getPrice(orderID) == 0
assert orders.getOrderCreator(orderID) == longToHexString(0)
assert orders.getOrderMoneyEscrowed(orderID) == 0
assert orders.getOrderSharesEscrowed(orderID) == 0
assert orders.getBetterOrderId(orderID) == longTo32Bytes(0)
assert orders.getWorseOrderId(orderID) == longTo32Bytes(0)
def test_two_asks_on_books_buy_one_full_then_create(contractsFixture, cash,
market, universe):
createOrder = contractsFixture.contracts['CreateOrder']
trade = contractsFixture.contracts['Trade']
fillOrder = contractsFixture.contracts['FillOrder']
orders = contractsFixture.contracts['Orders']
tradeGroupID = "42"
logs = []
# create order 1
orderID1 = createOrder.publicCreateOrder(ASK,
fix(12),
6000,
market.address,
YES,
longTo32Bytes(0),
longTo32Bytes(0),
tradeGroupID,
sender=tester.k1,
value=fix('12', '4000'))
# create order 2
orderID2 = createOrder.publicCreateOrder(ASK,
fix(7),
7000,
market.address,
YES,
longTo32Bytes(0),
longTo32Bytes(0),
tradeGroupID,
sender=tester.k3,
value=fix('7', '4000'))
# fill/create
captureFilteredLogs(contractsFixture.chain.head_state, orders, logs)
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
fillOrderID = trade.publicBuy(market.address,
YES,
fix(15),
6000,
tradeGroupID,
sender=tester.k2,
value=fix('15', '6000'))
assert len(logs) == 6
log1 = logs[4]
log2 = logs[5]
assert log1["_event_type"] == "OrderFilled"
assert log1["filler"] == bytesToHexString(tester.a2)
assert log1["numCreatorShares"] == 0
assert log1["numCreatorTokens"] == fix('12', '4000')
assert log1["numFillerShares"] == 0
assert log1["numFillerTokens"] == fix('12', '6000')
assert log1["marketCreatorFees"] == 0
assert log1["reporterFees"] == 0
assert log1["shareToken"] == market.getShareToken(YES)
assert log1["tradeGroupId"] == stringToBytes("42")
assert log2["_event_type"] == "OrderCreated"
assert log2['creator'] == bytesToHexString(tester.a2)
assert log2["orderId"] == fillOrderID
assert log2["shareToken"] == market.getShareToken(YES)
assert log2["tradeGroupId"] == stringToBytes("42")
assert orders.getAmount(orderID1) == 0
assert orders.getPrice(orderID1) == 0
assert orders.getOrderCreator(orderID1) == longToHexString(0)
assert orders.getOrderMoneyEscrowed(orderID1) == 0
assert orders.getOrderSharesEscrowed(orderID1) == 0
assert orders.getBetterOrderId(orderID1) == longTo32Bytes(0)
assert orders.getWorseOrderId(orderID1) == longTo32Bytes(0)
assert orders.getAmount(orderID2) == fix(7)
assert orders.getPrice(orderID2) == 7000
assert orders.getOrderCreator(orderID2) == bytesToHexString(tester.a3)
assert orders.getOrderMoneyEscrowed(orderID2) == fix('7', '3000')
assert orders.getOrderSharesEscrowed(orderID2) == 0
assert orders.getBetterOrderId(orderID2) == longTo32Bytes(0)
assert orders.getWorseOrderId(orderID2) == longTo32Bytes(0)
assert orders.getAmount(fillOrderID) == fix(3)
assert orders.getPrice(fillOrderID) == 6000
assert orders.getOrderCreator(fillOrderID) == bytesToHexString(tester.a2)
assert orders.getOrderMoneyEscrowed(fillOrderID) == fix('3', '6000')
assert orders.getOrderSharesEscrowed(fillOrderID) == 0
assert orders.getBetterOrderId(fillOrderID) == longTo32Bytes(0)
assert orders.getWorseOrderId(fillOrderID) == longTo32Bytes(0)
def test_fill_order_with_shares_escrowed_sell_with_shares_categorical(
contractsFixture, cash, categoricalMarket, universe):
market = categoricalMarket
createOrder = contractsFixture.contracts['CreateOrder']
fillOrder = contractsFixture.contracts['FillOrder']
orders = contractsFixture.contracts['Orders']
completeSets = contractsFixture.contracts['CompleteSets']
firstShareToken = contractsFixture.applySignature('ShareToken',
market.getShareToken(0))
secondShareToken = contractsFixture.applySignature('ShareToken',
market.getShareToken(1))
thirdShareToken = contractsFixture.applySignature('ShareToken',
market.getShareToken(2))
# buy complete sets for both users
numTicks = market.getNumTicks()
assert completeSets.publicBuyCompleteSets(market.address,
fix(1),
sender=tester.k1,
value=fix('1', numTicks))
assert completeSets.publicBuyCompleteSets(market.address,
fix(1),
sender=tester.k2,
value=fix('1', numTicks))
assert firstShareToken.balanceOf(tester.a1) == firstShareToken.balanceOf(
tester.a2) == fix(1)
assert secondShareToken.balanceOf(tester.a1) == secondShareToken.balanceOf(
tester.a2) == fix(1)
assert thirdShareToken.balanceOf(tester.a1) == thirdShareToken.balanceOf(
tester.a2) == fix(1)
# create order with shares
logs = []
price = 6000
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
orderID = createOrder.publicCreateOrder(ASK,
fix(1),
price,
market.address,
0,
longTo32Bytes(0),
longTo32Bytes(0),
"42",
sender=tester.k1)
assert orderID
# fill order with shares
assert fillOrder.publicFillOrder(orderID, fix(1), "43",
sender=tester.k2) == 0
# The second users corresponding shares were used to fulfil this order
assert firstShareToken.balanceOf(tester.a2) == fix(1)
assert secondShareToken.balanceOf(tester.a2) == 0
assert thirdShareToken.balanceOf(tester.a2) == 0
assert len(logs) == 10
log1 = logs[9]
assert log1["_event_type"] == "OrderFilled"
assert log1["filler"] == bytesToHexString(tester.a2)
assert log1["numCreatorShares"] == fix(1)
assert log1["numCreatorTokens"] == 0
assert log1["numFillerShares"] == fix(1)
assert log1["numFillerTokens"] == 0
assert log1["marketCreatorFees"] == fix(
1, numTicks) / market.getMarketCreatorSettlementFeeDivisor()
assert log1["reporterFees"] == fix(
1, numTicks) / universe.getOrCacheReportingFeeDivisor()
assert log1["shareToken"] == market.getShareToken(0)
assert log1["tradeGroupId"] == stringToBytes("43")
assert orders.getAmount(orderID) == 0
assert orders.getPrice(orderID) == 0
assert orders.getOrderCreator(orderID) == longToHexString(0)
assert orders.getOrderMoneyEscrowed(orderID) == 0
assert orders.getOrderSharesEscrowed(orderID) == 0
assert orders.getBetterOrderId(orderID) == longTo32Bytes(0)
assert orders.getWorseOrderId(orderID) == longTo32Bytes(0)
def proceedToForking(testFixture, universe, market, makeReport,
designatedDisputer, firstDisputer, reporter,
reportOutcomes, designatedDisputeOutcomes, firstReporter,
firstReportOutcomes, firstReportDisputeOutcomes,
lastReportOutcomes):
reputationToken = testFixture.applySignature('ReputationToken',
universe.getReputationToken())
# Proceed to the LAST REPORTING phase
if (market.getReportingState() !=
testFixture.contracts['Constants'].LAST_REPORTING()):
proceedToLastReporting(testFixture, universe, market, makeReport,
designatedDisputer, firstDisputer,
reportOutcomes, designatedDisputeOutcomes,
firstReporter, firstReportOutcomes,
firstReportDisputeOutcomes)
reportingWindow = testFixture.applySignature('ReportingWindow',
market.getReportingWindow())
stakeTokenNo = testFixture.getOrCreateStakeToken(market,
lastReportOutcomes)
stakeTokenYes = testFixture.getOrCreateStakeToken(
market, firstReportDisputeOutcomes)
# If we buy the delta between outcome stakes that will be sufficient to make the outcome win
noStake = market.getPayoutDistributionHashStake(
stakeTokenNo.getPayoutDistributionHash())
yesStake = market.getPayoutDistributionHashStake(
stakeTokenYes.getPayoutDistributionHash())
stakeDelta = yesStake - noStake
stakeTokenNo.buy(stakeDelta + 1, sender=testFixture.testerKey[reporter])
tentativeWinner = market.getTentativeWinningPayoutDistributionHash()
assert tentativeWinner == stakeTokenNo.getPayoutDistributionHash()
# To progress into the LAST DISPUTE phase we move time forward
testFixture.chain.head_state.timestamp = reportingWindow.getDisputeStartTime(
) + 1
assert market.getReportingState(
) == testFixture.contracts['Constants'].LAST_DISPUTE()
logs = []
captureFilteredLogs(testFixture.chain.head_state,
testFixture.contracts['Augur'], logs)
# Making a dispute at this phase will progress the market into FORKING
assert market.disputeLastReporters(sender=tester.k0)
assert market.getReportingState(
) == testFixture.contracts['Constants'].FORKING()
# Confirm the last dispute logging and universe fork logging works
assert len(logs) == 3
assert logs[1]['_event_type'] == 'UniverseForked'
assert logs[1]['universe'] == universe.address
assert logs[2]['_event_type'] == 'ReportsDisputed'
assert logs[2]['reportingPhase'] == testFixture.contracts[
'Constants'].LAST_DISPUTE()
assert logs[2]['disputer'] == bytesToHexString(tester.a0)
assert logs[2]['disputeBondAmount'] == testFixture.contracts[
'Constants'].LAST_REPORTERS_DISPUTE_BOND_AMOUNT()
assert logs[2]['market'] == market.address
def test_fill_buy_order_with_buy_categorical(contractsFixture, cash,
categoricalMarket, universe):
market = categoricalMarket
createOrder = contractsFixture.contracts['CreateOrder']
fillOrder = contractsFixture.contracts['FillOrder']
orders = contractsFixture.contracts['Orders']
firstShareToken = contractsFixture.applySignature('ShareToken',
market.getShareToken(0))
secondShareToken = contractsFixture.applySignature('ShareToken',
market.getShareToken(1))
thirdShareToken = contractsFixture.applySignature('ShareToken',
market.getShareToken(2))
# create order with cash
logs = []
price = 6000
numTicks = market.getNumTicks()
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
orderID = createOrder.publicCreateOrder(BID,
fix(1),
price,
market.address,
0,
longTo32Bytes(0),
longTo32Bytes(0),
"42",
value=fix(1, price),
sender=tester.k1)
assert orderID
# fill order with cash
assert fillOrder.publicFillOrder(orderID,
fix(1),
"43",
sender=tester.k2,
value=fix(1, numTicks - price)) == 0
# A complete set was purchased with the provided cash and the shares were provided to each user
assert firstShareToken.balanceOf(tester.a1) == fix(1)
assert secondShareToken.balanceOf(tester.a1) == 0
assert thirdShareToken.balanceOf(tester.a1) == 0
assert firstShareToken.balanceOf(tester.a2) == 0
assert secondShareToken.balanceOf(tester.a2) == fix(1)
assert thirdShareToken.balanceOf(tester.a2) == fix(1)
assert len(logs) == 8
log1 = logs[7]
assert log1["_event_type"] == "OrderFilled"
assert log1["filler"] == bytesToHexString(tester.a2)
assert log1["numCreatorShares"] == 0
assert log1["numCreatorTokens"] == fix(1, price)
assert log1["numFillerShares"] == 0
assert log1["numFillerTokens"] == fix(1, numTicks - price)
assert log1["marketCreatorFees"] == 0
assert log1["reporterFees"] == 0
assert log1["shareToken"] == market.getShareToken(0)
assert log1["tradeGroupId"] == stringToBytes("43")
assert orders.getAmount(orderID) == 0
assert orders.getPrice(orderID) == 0
assert orders.getOrderCreator(orderID) == longToHexString(0)
assert orders.getOrderMoneyEscrowed(orderID) == 0
assert orders.getOrderSharesEscrowed(orderID) == 0
assert orders.getBetterOrderId(orderID) == longTo32Bytes(0)
assert orders.getWorseOrderId(orderID) == longTo32Bytes(0)
def test_publicFillOrder_bid_scalar(contractsFixture, cash, scalarMarket,
universe):
createOrder = contractsFixture.contracts['CreateOrder']
fillOrder = contractsFixture.contracts['FillOrder']
orders = contractsFixture.contracts['Orders']
# We're testing the scalar market because it has a different numTicks than 10**18 as the other do. In particular it's numTicks is 40*18**18
market = scalarMarket
tradeGroupID = 42
logs = []
initialMakerETH = contractsFixture.chain.head_state.get_balance(tester.a1)
initialFillerETH = contractsFixture.chain.head_state.get_balance(tester.a2)
creatorCost = fix('2', '0.6')
fillerCost = fix('2', '39.4')
# create order
orderID = createOrder.publicCreateOrder(BID,
2,
fix('0.6'),
market.address,
YES,
longTo32Bytes(0),
longTo32Bytes(0),
tradeGroupID,
sender=tester.k1,
value=creatorCost)
# fill best order
captureFilteredLogs(contractsFixture.chain.head_state, orders, logs)
captureFilteredLogs(contractsFixture.chain.head_state,
contractsFixture.contracts['Augur'], logs)
fillOrderID = fillOrder.publicFillOrder(orderID,
2,
tradeGroupID,
sender=tester.k2,
value=fillerCost)
assert len(logs) == 5
assert logs[4]["_event_type"] == "OrderFilled"
assert logs[4]["filler"] == bytesToHexString(tester.a2)
assert logs[4]["numCreatorShares"] == 0
assert logs[4]["numCreatorTokens"] == creatorCost
assert logs[4]["numFillerShares"] == 0
assert logs[4]["numFillerTokens"] == fillerCost
assert logs[4]["settlementFees"] == 0
assert logs[4]["shareToken"] == market.getShareToken(YES)
assert logs[4]["tradeGroupId"] == 42
assert contractsFixture.chain.head_state.get_balance(
tester.a1) == initialMakerETH - creatorCost
assert contractsFixture.chain.head_state.get_balance(
tester.a2) == initialFillerETH - fillerCost
assert orders.getAmount(orderID) == 0
assert orders.getPrice(orderID) == 0
assert orders.getOrderCreator(orderID) == longToHexString(0)
assert orders.getOrderMoneyEscrowed(orderID) == 0
assert orders.getOrderSharesEscrowed(orderID) == 0
assert orders.getBetterOrderId(orderID) == longTo32Bytes(0)
assert orders.getWorseOrderId(orderID) == longTo32Bytes(0)
assert fillOrderID == 0
