def test_decodeUnsignedTx(self): tx = collections.OrderedDict([ ('nonce', 3), ('gasprice', 0x06fc23ac00), ('startgas', 0x0494e5), ('to', rec_bin('0xb13f6f423781bd1934fc8599782f5e161ce7c816')), ('value', 0x2386f26fc10000), ('data', rec_bin( '0xf435f5a7000000000000000000000000c198eccab3fe1f35e9160b48eb18af7934a13262' )), ]) rlp_tx = rlp.encode(list(tx.values())) print(rec_hex(utils.sha3(rlp_tx))) (nonce, gasprice, startgas, to, value, data, is_contract_creation) = \ self.verifier_contract.exposedDecodeUnsignedTx( rlp_tx ) self.assertEqual(nonce, tx['nonce']) self.assertEqual(gasprice, tx['gasprice']) self.assertEqual(startgas, tx['startgas']) self.assertEqualAddr(to, tx['to']) self.assertEqual(value, tx['value']) self.assertEqual(data, tx['data']) self.assertFalse(is_contract_creation)
def test_decodeSignedTx(self): tx = collections.OrderedDict([ ('nonce', 3), ('gasprice', 0x06fc23ac00), ('startgas', 0x0494e5), ('to', rec_bin('0xb13f6f423781bd1934fc8599782f5e161ce7c816')), ('value', 0x2386f26fc10000), ('data', rec_bin( '0xf435f5a7000000000000000000000000c198eccab3fe1f35e9160b48eb18af7934a13262' )), ('v', 28), ('r', 115792089237316195423570985008687907852837564279074904382605163141518161494337 - 1), ('s', 17), ]) rlp_tx = rlp.encode(list(tx.values())) print(rec_hex(utils.sha3(rlp_tx))) (nonce, gasprice, startgas, to, value, data, v, r, s, is_contract_creation) = \ self.verifier_contract.exposedDecodeSignedTx( rlp_tx ) self.assertEqual(nonce, tx['nonce']) self.assertEqual(gasprice, tx['gasprice']) self.assertEqual(startgas, tx['startgas']) self.assertEqualAddr(to, tx['to']) self.assertEqual(value, tx['value']) self.assertEqual(data, tx['data']) self.assertEqual(v, tx['v']) self.assertEqual(r, tx['r']) self.assertEqual(s, tx['s']) self.assertFalse(is_contract_creation)
def test_dishonest_party(self): ADDR_A = rec_hex(t.a1) PKEY_A = t.k1 ADDR_B = rec_hex(t.a2) PKEY_B = t.k2 DAPP_ADDRESS = "0xDEADbEeF000000000000000000000000DeaDbeEf" fake_tx_commit_object = transactions.Transaction( 0, OURGASPRICE, OURGASLIMIT, ADDR_B, (UNLOCK_AMOUNT + extraTransactionFees), b'').sign(PKEY_A) self.chain.direct_tx(fake_tx_commit_object) self.chain.mine(1) witness = "0x03" fakecommitBlockNumber, fakecommitBlockIndex = self.chain.chain.get_tx_position( fake_tx_commit_object) print("tx block number {} and tx block index {}".format( fakecommitBlockNumber, fakecommitBlockIndex)) def _listener(log): print('LOG:', ) print('LOG:', log) print(rec_hex(log['data'])) self.chain.head_state.log_listeners.append(_listener) self.verifier_contract.reveal(fakecommitBlockNumber, fakecommitBlockIndex, DAPP_ADDRESS, UNLOCK_AMOUNT, b'', rec_bin(witness), OURGASPRICE, OURGASLIMIT, sender=PKEY_A, to=self.verifier_contract.address, value=1009, gasprice=OURGASPRICE, startgas=OURGASLIMIT) self.chain.mine(1) #revealBlockNumber, revealBlockIndex = self.chain.chain.get_tx_position() #print("reveal block number {} and reveal block index {}".format(revealBlockNumber, revealBlockIndex)) def aux(x): return x.to_bytes(32, byteorder='big') computedfakecommit = (rec_bin(ADDR_A) + self.verifier_contract.address + aux(UNLOCK_AMOUNT) + b'' + rec_bin(witness) + aux(OURGASPRICE) + aux(OURGASLIMIT)) sessionID = sha3_256(computedfakecommit) print(rec_hex(sessionID)) revealTestSession = self.verifier_contract.getSession( rec_bin( "000000000000000000000000000000000000000000000000128dfa6a90b28000" )) print(revealTestSession)
def assert_failed_call(modified_decoded_proof_blob, block_hash=block_hash): with self.assertRaises(t.TransactionFailed): _ = self.verifier_contract.txProof( block_hash, rlp.encode(rec_bin(modified_decoded_proof_blob)), startgas=10**6)
def test_InvalidEthTokenSwapNoCommit(self): ## ## STARTING STATE ## self.chain.mine(1) self.assertEqual( TOTAL_TOKEN_SUPPLY - TOKEN_AMOUNT_STARTING - BOB_STARTING_TOKEN_AMOUNT, self.token_contract.balanceOf(CONTRACT_OWNER_ADDRESS)) self.assertEqual( TOKEN_AMOUNT_STARTING, self.token_contract.balanceOf(self.exchange_contract.address)) self.assertEqual( ACCOUNT_STARTING_BALANCE - ETH_AMOUNT_STARTING, self.chain.head_state.get_balance(rec_hex(CONTRACT_OWNER_ADDRESS))) self.assertEqual( ETH_AMOUNT_STARTING, self.chain.head_state.get_balance( rec_hex(self.exchange_contract.address))) self.assertEqual(BOB_STARTING_TOKEN_AMOUNT, self.token_contract.balanceOf(BOB_ADDRESS)) self.assertEqual(0, self.token_contract.balanceOf(ALICE_ADDRESS)) self.assertEqual(ETH_AMOUNT_STARTING, self.exchange_contract.ethPool()) self.assertEqual(TOKEN_AMOUNT_STARTING, self.exchange_contract.tokenPool()) self.assertEqual(ETH_AMOUNT_STARTING * TOKEN_AMOUNT_STARTING, self.exchange_contract.invariant()) currentInvariant = ETH_AMOUNT_STARTING * TOKEN_AMOUNT_STARTING self.assertEqual(COMMIT_PERIOD_LENGTH, self.exchange_contract.commitPeriodLength()) randomSubId = rec_bin( "0x4242424242424242424242424242424242424242424242424242424242424242" ) self.assertRaises(t.TransactionFailed, self.exchange_contract.ethToTokenSwap, randomSubId, value=ALICE_TRADE_AMOUNT, sender=RANDO_ADDRESS_PRIVATE_KEY)
def test_ExchangeWorkflowBuyTokensWithEth(self): ## ## STARTING STATE ## self.chain.mine(1) self.assertEqual(TOTAL_TOKEN_SUPPLY - TOKEN_AMOUNT_STARTING - BOB_STARTING_TOKEN_AMOUNT, self.token_contract.balanceOf(CONTRACT_OWNER_ADDRESS)) self.assertEqual(TOKEN_AMOUNT_STARTING, self.token_contract.balanceOf(self.exchange_contract.address)) self.assertEqual(ACCOUNT_STARTING_BALANCE - ETH_AMOUNT_STARTING, self.chain.head_state.get_balance(rec_hex(CONTRACT_OWNER_ADDRESS))) self.assertEqual(ACCOUNT_STARTING_BALANCE, self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS))) self.assertEqual(ETH_AMOUNT_STARTING, self.chain.head_state.get_balance(rec_hex(self.exchange_contract.address))) self.assertEqual(BOB_STARTING_TOKEN_AMOUNT, self.token_contract.balanceOf(BOB_ADDRESS)) self.assertEqual(0, self.token_contract.balanceOf(ALICE_ADDRESS)) self.assertEqual(ETH_AMOUNT_STARTING, self.exchange_contract.ethPool()) self.assertEqual(TOKEN_AMOUNT_STARTING, self.exchange_contract.tokenPool()) self.assertEqual(ETH_AMOUNT_STARTING * TOKEN_AMOUNT_STARTING, self.exchange_contract.invariant()) currentInvariant = ETH_AMOUNT_STARTING * TOKEN_AMOUNT_STARTING self.assertEqual(COMMIT_PERIOD_LENGTH, self.exchange_contract.commitPeriodLength()) ## ## ALICE BUYS TOKENS WITH ETH ## commitAddressAlice, commitAlice, witnessAlice, unlock_tx_hexAlice = generate_submarine_commit.generateCommitAddress( normalize_address(rec_hex(ALICE_ADDRESS)), normalize_address(rec_hex(self.exchange_contract.address)), ALICE_TRADE_AMOUNT, b'', OURGASPRICE, OURGASLIMIT) unlock_tx_infoAlice = rlp.decode(rec_bin(unlock_tx_hexAlice)) unlock_tx_objectAlice = transactions.Transaction( int.from_bytes(unlock_tx_infoAlice[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoAlice[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoAlice[2], byteorder="big"), # startgas unlock_tx_infoAlice[3], # to addr int.from_bytes(unlock_tx_infoAlice[4], byteorder="big"), # value unlock_tx_infoAlice[5], # data int.from_bytes(unlock_tx_infoAlice[6], byteorder="big"), # v int.from_bytes(unlock_tx_infoAlice[7], byteorder="big"), # r int.from_bytes(unlock_tx_infoAlice[8], byteorder="big") # s ) commit_tx_objectAlice = transactions.Transaction( 0, OURGASPRICE, BASIC_SEND_GAS_LIMIT, rec_bin(commitAddressAlice), (ALICE_TRADE_AMOUNT + extraTransactionFees), b'').sign(ALICE_PRIVATE_KEY) self.chain.direct_tx(commit_tx_objectAlice) commit_gasAlice = int(self.chain.head_state.gas_used) self.chain.mine(1) commit_block_numberAlice, commit_block_indexAlice = self.chain.chain.get_tx_position( commit_tx_objectAlice) self.assertEqual(ALICE_TRADE_AMOUNT + extraTransactionFees, self.chain.head_state.get_balance(commitAddressAlice)) self.assertEqual( ACCOUNT_STARTING_BALANCE - (ALICE_TRADE_AMOUNT + extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS))) session_dataAlice = self.exchange_contract.getSubmarineState(rec_bin(commitAlice)) self.assertListEqual(session_dataAlice, [SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL]) finished_boolAlice = self.exchange_contract.revealedAndUnlocked(rec_bin(commitAlice)) self.assertFalse( finished_boolAlice, "The contract should not be finished before it's even begun.") ## ## GENERATE AND BROADCAST REVEAL BID TXS ## self.chain.mine(COMMIT_PERIOD_LENGTH) proveth_commit_blockAlice = proveth_compatible_commit_block( self.chain.chain.get_block_by_number(commit_block_numberAlice), commit_tx_objectAlice, ) commit_proof_blobAlice = proveth.generate_proof_blob( proveth_commit_blockAlice, commit_block_indexAlice) _unlockExtraData = b'' # In this example we dont have any extra embedded data as part of the unlock TX unlock_tx_unsigned_objectAlice = transactions.UnsignedTransaction( int.from_bytes(unlock_tx_infoAlice[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoAlice[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoAlice[2], byteorder="big"), # startgas unlock_tx_infoAlice[3], # to addr int.from_bytes(unlock_tx_infoAlice[4], byteorder="big"), # value unlock_tx_infoAlice[5], # data ) unlock_tx_unsigned_rlpAlice = rlp.encode(unlock_tx_unsigned_objectAlice, transactions.UnsignedTransaction) self.chain.mine(5) self.exchange_contract.reveal( commit_block_numberAlice, # uint32 _commitBlockNumber, _unlockExtraData, # bytes _commitData, rec_bin(witnessAlice), # bytes32 _witness, unlock_tx_unsigned_rlpAlice, # bytes _rlpUnlockTxUnsigned, commit_proof_blobAlice, # bytes _proofBlob sender=ALICE_PRIVATE_KEY, gasprice=OURGASPRICE) reveal_gasAlice = int(self.chain.head_state.gas_used) ## ## BROADCAST UNLOCK ## self.chain.mine(1) self.chain.direct_tx(unlock_tx_objectAlice) self.chain.mine(1) ## ## Call the actual ethToTokenSwap function ## self.exchange_contract.ethToTokenSwap(rec_bin(commitAlice), sender=ALICE_PRIVATE_KEY, gasprice=OURGASPRICE) swapcall_gasAlice = int(self.chain.head_state.gas_used) self.chain.mine(1) # unlock_block_numberAlice, unlock_block_indexAlice = self.chain.chain.get_tx_position( # unlock_tx_objectAlice) # unlock_block_objectAlice = self.chain.chain.get_block_by_number(unlock_block_numberAlice) # print(unlock_block_objectAlice.as_dict()) # print(unlock_block_objectAlice.as_dict()['transactions'][0].as_dict()) # print(unlock_block_objectAlice.as_dict()['header'].as_dict()) ## ## CHECK STATE AFTER TOKEN PURCHASE ## self.assertEqual(ETH_AMOUNT_STARTING+ALICE_TRADE_AMOUNT, self.exchange_contract.ethPool()) self.assertEqual(ETH_AMOUNT_STARTING+ALICE_TRADE_AMOUNT, self.chain.head_state.get_balance(rec_hex(self.exchange_contract.address))) self.assertEqual(ACCOUNT_STARTING_BALANCE - ALICE_TRADE_AMOUNT - (OURGASPRICE*(commit_gasAlice + reveal_gasAlice + swapcall_gasAlice)) - extraTransactionFees, self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS))) tokens_out = int(TOKEN_AMOUNT_STARTING - (currentInvariant //(ETH_AMOUNT_STARTING + ALICE_TRADE_AMOUNT))) # // floor division self.assertEqual(tokens_out, self.token_contract.balanceOf(ALICE_ADDRESS)) self.assertEqual(TOKEN_AMOUNT_STARTING - tokens_out, self.token_contract.balanceOf(self.exchange_contract.address)) self.assertEqual(TOKEN_AMOUNT_STARTING - tokens_out, self.exchange_contract.tokenPool())
def test_auctionWorkflow(self): ## ## STARTING STATE ## starting_block_height = self.chain.head_state.block_number starting_owner_eth_holdings = self.chain.head_state.get_balance(rec_hex(CONTRACT_OWNER_ADDRESS)) self.chain.mine(1) self.assertTrue(self.erc721_contract.isMinter(CONTRACT_OWNER_ADDRESS)) self.chain.mine(1) self.assertEqual(1, self.erc721_contract.balanceOf(rec_hex(CONTRACT_OWNER_ADDRESS), sender=CONTRACT_OWNER_PRIVATE_KEY)) self.assertEqual(rec_hex(CONTRACT_OWNER_ADDRESS), self.erc721_contract.ownerOf(TOKEN_ID, sender=CONTRACT_OWNER_PRIVATE_KEY)) self.assertEqual(ACCOUNT_STARTING_BALANCE, self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS))) self.assertEqual(ACCOUNT_STARTING_BALANCE, self.chain.head_state.get_balance(rec_hex(BOB_ADDRESS))) self.assertEqual(ACCOUNT_STARTING_BALANCE, self.chain.head_state.get_balance(rec_hex(CHARLIE_ADDRESS))) self.assertTrue(self.auction_contract.address) self.assertEqual(27, self.auction_contract.vee()) ## ## START THE AUCTION ## (By sending the token to the auction contract, triggering onERC721Received) startAuctionBlock = self.chain.head_state.block_number + 1 endCommitPeriodBlock = self.chain.head_state.block_number + COMMIT_PERIOD_LENGTH onERC721RecievedDataField = encode_single_packed('(uint32,uint32)', [startAuctionBlock, endCommitPeriodBlock]) self.erc721_contract.safeTransferFrom(CONTRACT_OWNER_ADDRESS, self.auction_contract.address, TOKEN_ID, onERC721RecievedDataField, sender=CONTRACT_OWNER_PRIVATE_KEY) self.assertEqual(rec_hex(self.auction_contract.address), self.erc721_contract.ownerOf(TOKEN_ID)) self.assertEqual(rec_hex(CONTRACT_OWNER_ADDRESS), self.auction_contract.seller()) self.assertEqual(startAuctionBlock, self.auction_contract.startBlock()) self.assertEqual(endCommitPeriodBlock, self.auction_contract.endCommitBlock()) self.assertEqual(endCommitPeriodBlock+REVEAL_PERIOD_LENGTH, self.auction_contract.endRevealBlock()) self.assertEqual(TOKEN_ID, self.auction_contract.erc721TokenId()) self.assertEqual(rec_hex(self.erc721_contract.address), self.auction_contract.erc721()) # # GENERATE UNLOCK TXs # commitAddressAlice, commitAlice, witnessAlice, unlock_tx_hexAlice = generate_submarine_commit.generateCommitAddress( normalize_address(rec_hex(ALICE_ADDRESS)), normalize_address(rec_hex(self.auction_contract.address)), BID_AMOUNT_Alice, b'', OURGASPRICE, OURGASLIMIT) unlock_tx_infoAlice = rlp.decode(rec_bin(unlock_tx_hexAlice)) unlock_tx_objectAlice = transactions.Transaction( int.from_bytes(unlock_tx_infoAlice[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoAlice[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoAlice[2], byteorder="big"), # startgas unlock_tx_infoAlice[3], # to addr int.from_bytes(unlock_tx_infoAlice[4], byteorder="big"), # value unlock_tx_infoAlice[5], # data int.from_bytes(unlock_tx_infoAlice[6], byteorder="big"), # v int.from_bytes(unlock_tx_infoAlice[7], byteorder="big"), # r int.from_bytes(unlock_tx_infoAlice[8], byteorder="big") # s ) commitAddressBob, commitBob, witnessBob, unlock_tx_hexBob = generate_submarine_commit.generateCommitAddress( normalize_address(rec_hex(BOB_ADDRESS)), normalize_address(rec_hex(self.auction_contract.address)), BID_AMOUNT_Bob, b'', OURGASPRICE, OURGASLIMIT) unlock_tx_infoBob = rlp.decode(rec_bin(unlock_tx_hexBob)) unlock_tx_objectBob = transactions.Transaction( int.from_bytes(unlock_tx_infoBob[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoBob[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoBob[2], byteorder="big"), # startgas unlock_tx_infoBob[3], # to addr int.from_bytes(unlock_tx_infoBob[4], byteorder="big"), # value unlock_tx_infoBob[5], # data int.from_bytes(unlock_tx_infoBob[6], byteorder="big"), # v int.from_bytes(unlock_tx_infoBob[7], byteorder="big"), # r int.from_bytes(unlock_tx_infoBob[8], byteorder="big") # s ) commitAddressCharlie, commitCharlie, witnessCharlie, unlock_tx_hexCharlie = generate_submarine_commit.generateCommitAddress( normalize_address(rec_hex(CHARLIE_ADDRESS)), normalize_address(rec_hex(self.auction_contract.address)), BID_AMOUNT_Charlie, b'', OURGASPRICE, OURGASLIMIT) unlock_tx_infoCharlie = rlp.decode(rec_bin(unlock_tx_hexCharlie)) unlock_tx_objectCharlie = transactions.Transaction( int.from_bytes(unlock_tx_infoCharlie[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoCharlie[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoCharlie[2], byteorder="big"), # startgas unlock_tx_infoCharlie[3], # to addr int.from_bytes(unlock_tx_infoCharlie[4], byteorder="big"), # value unlock_tx_infoCharlie[5], # data int.from_bytes(unlock_tx_infoCharlie[6], byteorder="big"), # v int.from_bytes(unlock_tx_infoCharlie[7], byteorder="big"), # r int.from_bytes(unlock_tx_infoCharlie[8], byteorder="big") # s ) # # GENERATE + BROADCAST COMMIT TXs # commit_tx_objectAlice = transactions.Transaction( 0, OURGASPRICE, BASIC_SEND_GAS_LIMIT, rec_bin(commitAddressAlice), (BID_AMOUNT_Alice + extraTransactionFees), b'').sign(ALICE_PRIVATE_KEY) commit_gasAlice = int(self.chain.head_state.gas_used) self.chain.mine(1) self.chain.direct_tx(commit_tx_objectAlice) self.chain.mine(1) commit_tx_objectBob = transactions.Transaction( 0, OURGASPRICE, BASIC_SEND_GAS_LIMIT, rec_bin(commitAddressBob), (BID_AMOUNT_Bob + extraTransactionFees), b'').sign(BOB_PRIVATE_KEY) commit_gasBob = int(self.chain.head_state.gas_used) self.chain.direct_tx(commit_tx_objectBob) self.chain.mine(1) commit_tx_objectCharlie = transactions.Transaction( 0, OURGASPRICE, BASIC_SEND_GAS_LIMIT, rec_bin(commitAddressCharlie), (BID_AMOUNT_Charlie + extraTransactionFees), b'').sign(CHARLIE_PRIVATE_KEY) commit_gasCharlie = int(self.chain.head_state.gas_used) self.chain.direct_tx(commit_tx_objectCharlie) self.chain.mine(1) ## ## CHECK STATE AFTER COMMIT TX ## commit_block_numberAlice, commit_block_indexAlice = self.chain.chain.get_tx_position( commit_tx_objectAlice) self.assertEqual(BID_AMOUNT_Alice + extraTransactionFees, self.chain.head_state.get_balance(commitAddressAlice)) self.assertEqual( ACCOUNT_STARTING_BALANCE - (BID_AMOUNT_Alice + extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS))) session_dataAlice = self.auction_contract.getSubmarineState(rec_bin(commitAlice)) self.assertListEqual(session_dataAlice, [SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL]) revealedAndUnlocked_boolAlice = self.auction_contract.revealedAndUnlocked(rec_bin(commitAlice)) self.assertFalse( revealedAndUnlocked_boolAlice, "The contract should not be revealedAndUnlocked before it's even begun.") commit_block_numberBob, commit_block_indexBob = self.chain.chain.get_tx_position( commit_tx_objectBob) self.assertEqual(BID_AMOUNT_Bob + extraTransactionFees, self.chain.head_state.get_balance(commitAddressBob)) self.assertEqual( ACCOUNT_STARTING_BALANCE - (BID_AMOUNT_Bob + extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(BOB_ADDRESS))) session_dataBob = self.auction_contract.getSubmarineState(rec_bin(commitBob)) self.assertListEqual(session_dataBob, [SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL]) revealedAndUnlocked_boolBob = self.auction_contract.revealedAndUnlocked(rec_bin(commitBob)) self.assertFalse( revealedAndUnlocked_boolBob, "The contract should not be revealedAndUnlocked before it's even begun.") commit_block_numberCharlie, commit_block_indexCharlie = self.chain.chain.get_tx_position( commit_tx_objectCharlie) self.assertEqual(BID_AMOUNT_Charlie + extraTransactionFees, self.chain.head_state.get_balance(commitAddressCharlie)) self.assertEqual( ACCOUNT_STARTING_BALANCE - (BID_AMOUNT_Charlie + extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(CHARLIE_ADDRESS))) session_dataCharlie = self.auction_contract.getSubmarineState(rec_bin(commitCharlie)) self.assertListEqual(session_dataCharlie, [SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL]) revealedAndUnlocked_boolCharlie = self.auction_contract.revealedAndUnlocked(rec_bin(commitCharlie)) self.assertFalse( revealedAndUnlocked_boolCharlie, "The contract should not be revealedAndUnlocked before it's even begun.") ## ## GENERATE AND BROADCAST REVEAL BID TXS ## self.chain.mine(COMMIT_PERIOD_LENGTH + 1) commit_block_objectAlice = self.chain.chain.get_block_by_number(commit_block_numberAlice) proveth_expected_block_format_dictAlice = dict() proveth_expected_block_format_dictAlice['parentHash'] = commit_block_objectAlice['prevhash'] proveth_expected_block_format_dictAlice['sha3Uncles'] = commit_block_objectAlice['uncles_hash'] proveth_expected_block_format_dictAlice['miner'] = commit_block_objectAlice['coinbase'] proveth_expected_block_format_dictAlice['stateRoot'] = commit_block_objectAlice['state_root'] proveth_expected_block_format_dictAlice['transactionsRoot'] = commit_block_objectAlice['tx_list_root'] proveth_expected_block_format_dictAlice['receiptsRoot'] = commit_block_objectAlice['receipts_root'] proveth_expected_block_format_dictAlice['logsBloom'] = commit_block_objectAlice['bloom'] proveth_expected_block_format_dictAlice['difficulty'] = commit_block_objectAlice['difficulty'] proveth_expected_block_format_dictAlice['number'] = commit_block_objectAlice['number'] proveth_expected_block_format_dictAlice['gasLimit'] = commit_block_objectAlice['gas_limit'] proveth_expected_block_format_dictAlice['gasUsed'] = commit_block_objectAlice['gas_used'] proveth_expected_block_format_dictAlice['timestamp'] = commit_block_objectAlice['timestamp'] proveth_expected_block_format_dictAlice['extraData'] = commit_block_objectAlice['extra_data'] proveth_expected_block_format_dictAlice['mixHash'] = commit_block_objectAlice['mixhash'] proveth_expected_block_format_dictAlice['nonce'] = commit_block_objectAlice['nonce'] proveth_expected_block_format_dictAlice['hash'] = commit_block_objectAlice.hash proveth_expected_block_format_dictAlice['uncles'] = [] proveth_expected_block_format_dictAlice['transactions'] = ({ "blockHash": commit_block_objectAlice.hash, "blockNumber": str(hex((commit_block_objectAlice['number']))), "from": checksum_encode(ALICE_ADDRESS), "gas": str(hex(commit_tx_objectAlice['startgas'])), "gasPrice": str(hex(commit_tx_objectAlice['gasprice'])), "hash": rec_hex(commit_tx_objectAlice['hash']), "input": rec_hex(commit_tx_objectAlice['data']), "nonce": str(hex(commit_tx_objectAlice['nonce'])), "to": checksum_encode(commit_tx_objectAlice['to']), "transactionIndex": str(hex(0)), "value": str(hex(commit_tx_objectAlice['value'])), "v": str(hex(commit_tx_objectAlice['v'])), "r": str(hex(commit_tx_objectAlice['r'])), "s": str(hex(commit_tx_objectAlice['s'])) }, ) commit_proof_blobAlice = proveth.generate_proof_blob( proveth_expected_block_format_dictAlice, commit_block_indexAlice) _unlockExtraData = b'' # In this example we dont have any extra embedded data as part of the unlock TX unlock_tx_unsigned_objectAlice = transactions.UnsignedTransaction( int.from_bytes(unlock_tx_infoAlice[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoAlice[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoAlice[2], byteorder="big"), # startgas unlock_tx_infoAlice[3], # to addr int.from_bytes(unlock_tx_infoAlice[4], byteorder="big"), # value unlock_tx_infoAlice[5], # data ) unlock_tx_unsigned_rlpAlice = rlp.encode(unlock_tx_unsigned_objectAlice, transactions.UnsignedTransaction) self.auction_contract.reveal( commit_block_numberAlice, # uint32 _commitBlockNumber, _unlockExtraData, # bytes _commitData, rec_bin(witnessAlice), # bytes32 _witness, unlock_tx_unsigned_rlpAlice, # bytes _rlpUnlockTxUnsigned, commit_proof_blobAlice, # bytes _proofBlob sender=ALICE_PRIVATE_KEY) reveal_gasAlice = int(self.chain.head_state.gas_used) self.chain.mine(1) commit_block_objectBob = self.chain.chain.get_block_by_number(commit_block_numberBob) proveth_expected_block_format_dictBob = dict() proveth_expected_block_format_dictBob['parentHash'] = commit_block_objectBob['prevhash'] proveth_expected_block_format_dictBob['sha3Uncles'] = commit_block_objectBob['uncles_hash'] proveth_expected_block_format_dictBob['miner'] = commit_block_objectBob['coinbase'] proveth_expected_block_format_dictBob['stateRoot'] = commit_block_objectBob['state_root'] proveth_expected_block_format_dictBob['transactionsRoot'] = commit_block_objectBob['tx_list_root'] proveth_expected_block_format_dictBob['receiptsRoot'] = commit_block_objectBob['receipts_root'] proveth_expected_block_format_dictBob['logsBloom'] = commit_block_objectBob['bloom'] proveth_expected_block_format_dictBob['difficulty'] = commit_block_objectBob['difficulty'] proveth_expected_block_format_dictBob['number'] = commit_block_objectBob['number'] proveth_expected_block_format_dictBob['gasLimit'] = commit_block_objectBob['gas_limit'] proveth_expected_block_format_dictBob['gasUsed'] = commit_block_objectBob['gas_used'] proveth_expected_block_format_dictBob['timestamp'] = commit_block_objectBob['timestamp'] proveth_expected_block_format_dictBob['extraData'] = commit_block_objectBob['extra_data'] proveth_expected_block_format_dictBob['mixHash'] = commit_block_objectBob['mixhash'] proveth_expected_block_format_dictBob['nonce'] = commit_block_objectBob['nonce'] proveth_expected_block_format_dictBob['hash'] = commit_block_objectBob.hash proveth_expected_block_format_dictBob['uncles'] = [] proveth_expected_block_format_dictBob['transactions'] = ({ "blockHash": commit_block_objectBob.hash, "blockNumber": str(hex((commit_block_objectBob['number']))), "from": checksum_encode(BOB_ADDRESS), "gas": str(hex(commit_tx_objectBob['startgas'])), "gasPrice": str(hex(commit_tx_objectBob['gasprice'])), "hash": rec_hex(commit_tx_objectBob['hash']), "input": rec_hex(commit_tx_objectBob['data']), "nonce": str(hex(commit_tx_objectBob['nonce'])), "to": checksum_encode(commit_tx_objectBob['to']), "transactionIndex": str(hex(0)), "value": str(hex(commit_tx_objectBob['value'])), "v": str(hex(commit_tx_objectBob['v'])), "r": str(hex(commit_tx_objectBob['r'])), "s": str(hex(commit_tx_objectBob['s'])) }, ) commit_proof_blobBob = proveth.generate_proof_blob( proveth_expected_block_format_dictBob, commit_block_indexBob) _unlockExtraData = b'' # In this example we dont have any extra embedded data as part of the unlock TX unlock_tx_unsigned_objectBob = transactions.UnsignedTransaction( int.from_bytes(unlock_tx_infoBob[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoBob[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoBob[2], byteorder="big"), # startgas unlock_tx_infoBob[3], # to addr int.from_bytes(unlock_tx_infoBob[4], byteorder="big"), # value unlock_tx_infoBob[5], # data ) unlock_tx_unsigned_rlpBob = rlp.encode(unlock_tx_unsigned_objectBob, transactions.UnsignedTransaction) self.auction_contract.reveal( commit_block_numberBob, # uint32 _commitBlockNumber, _unlockExtraData, # bytes _commitData, rec_bin(witnessBob), # bytes32 _witness, unlock_tx_unsigned_rlpBob, # bytes _rlpUnlockTxUnsigned, commit_proof_blobBob, # bytes _proofBlob sender=BOB_PRIVATE_KEY) reveal_gasBob = int(self.chain.head_state.gas_used) self.chain.mine(1) commit_block_objectCharlie = self.chain.chain.get_block_by_number(commit_block_numberCharlie) proveth_expected_block_format_dictCharlie = dict() proveth_expected_block_format_dictCharlie['parentHash'] = commit_block_objectCharlie['prevhash'] proveth_expected_block_format_dictCharlie['sha3Uncles'] = commit_block_objectCharlie['uncles_hash'] proveth_expected_block_format_dictCharlie['miner'] = commit_block_objectCharlie['coinbase'] proveth_expected_block_format_dictCharlie['stateRoot'] = commit_block_objectCharlie['state_root'] proveth_expected_block_format_dictCharlie['transactionsRoot'] = commit_block_objectCharlie['tx_list_root'] proveth_expected_block_format_dictCharlie['receiptsRoot'] = commit_block_objectCharlie['receipts_root'] proveth_expected_block_format_dictCharlie['logsBloom'] = commit_block_objectCharlie['bloom'] proveth_expected_block_format_dictCharlie['difficulty'] = commit_block_objectCharlie['difficulty'] proveth_expected_block_format_dictCharlie['number'] = commit_block_objectCharlie['number'] proveth_expected_block_format_dictCharlie['gasLimit'] = commit_block_objectCharlie['gas_limit'] proveth_expected_block_format_dictCharlie['gasUsed'] = commit_block_objectCharlie['gas_used'] proveth_expected_block_format_dictCharlie['timestamp'] = commit_block_objectCharlie['timestamp'] proveth_expected_block_format_dictCharlie['extraData'] = commit_block_objectCharlie['extra_data'] proveth_expected_block_format_dictCharlie['mixHash'] = commit_block_objectCharlie['mixhash'] proveth_expected_block_format_dictCharlie['nonce'] = commit_block_objectCharlie['nonce'] proveth_expected_block_format_dictCharlie['hash'] = commit_block_objectCharlie.hash proveth_expected_block_format_dictCharlie['uncles'] = [] proveth_expected_block_format_dictCharlie['transactions'] = ({ "blockHash": commit_block_objectCharlie.hash, "blockNumber": str(hex((commit_block_objectCharlie['number']))), "from": checksum_encode(CHARLIE_ADDRESS), "gas": str(hex(commit_tx_objectCharlie['startgas'])), "gasPrice": str(hex(commit_tx_objectCharlie['gasprice'])), "hash": rec_hex(commit_tx_objectCharlie['hash']), "input": rec_hex(commit_tx_objectCharlie['data']), "nonce": str(hex(commit_tx_objectCharlie['nonce'])), "to": checksum_encode(commit_tx_objectCharlie['to']), "transactionIndex": str(hex(0)), "value": str(hex(commit_tx_objectCharlie['value'])), "v": str(hex(commit_tx_objectCharlie['v'])), "r": str(hex(commit_tx_objectCharlie['r'])), "s": str(hex(commit_tx_objectCharlie['s'])) }, ) commit_proof_blobCharlie = proveth.generate_proof_blob( proveth_expected_block_format_dictCharlie, commit_block_indexCharlie) _unlockExtraData = b'' # In this example we dont have any extra embedded data as part of the unlock TX unlock_tx_unsigned_objectCharlie = transactions.UnsignedTransaction( int.from_bytes(unlock_tx_infoCharlie[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoCharlie[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoCharlie[2], byteorder="big"), # startgas unlock_tx_infoCharlie[3], # to addr int.from_bytes(unlock_tx_infoCharlie[4], byteorder="big"), # value unlock_tx_infoCharlie[5], # data ) unlock_tx_unsigned_rlpCharlie = rlp.encode(unlock_tx_unsigned_objectCharlie, transactions.UnsignedTransaction) self.auction_contract.reveal( commit_block_numberCharlie, # uint32 _commitBlockNumber, _unlockExtraData, # bytes _commitData, rec_bin(witnessCharlie), # bytes32 _witness, unlock_tx_unsigned_rlpCharlie, # bytes _rlpUnlockTxUnsigned, commit_proof_blobCharlie, # bytes _proofBlob sender=CHARLIE_PRIVATE_KEY) reveal_gasCharlie = int(self.chain.head_state.gas_used) self.chain.mine(1) ## ## CHECK THE STATE AFTER REVEAL ## bidRecordAlice = self.auction_contract.bidders(rec_bin(commitAlice)) self.assertEqual(rec_hex(ALICE_ADDRESS), bidRecordAlice) session_dataAlice = self.auction_contract.getSubmarineState(rec_bin(commitAlice)) self.assertListEqual(session_dataAlice, [BID_AMOUNT_Alice, SOLIDITY_NULL_INITIALVAL, commit_block_numberAlice, commit_block_indexAlice]) revealedAndUnlocked_boolAlice = self.auction_contract.revealedAndUnlocked(rec_bin(commitAlice)) self.assertFalse(revealedAndUnlocked_boolAlice) bidRecordBob = self.auction_contract.bidders(rec_bin(commitBob)) self.assertEqual(rec_hex(BOB_ADDRESS), bidRecordBob) session_dataBob = self.auction_contract.getSubmarineState(rec_bin(commitBob)) self.assertListEqual(session_dataBob, [BID_AMOUNT_Bob, SOLIDITY_NULL_INITIALVAL, commit_block_numberBob, commit_block_indexBob]) revealedAndUnlocked_boolBob = self.auction_contract.revealedAndUnlocked(rec_bin(commitBob)) self.assertFalse(revealedAndUnlocked_boolBob) bidRecordCharlie = self.auction_contract.bidders(rec_bin(commitCharlie)) self.assertEqual(rec_hex(CHARLIE_ADDRESS), bidRecordCharlie) session_dataCharlie = self.auction_contract.getSubmarineState(rec_bin(commitCharlie)) self.assertListEqual(session_dataCharlie, [BID_AMOUNT_Charlie, SOLIDITY_NULL_INITIALVAL, commit_block_numberCharlie, commit_block_indexCharlie]) revealedAndUnlocked_boolCharlie = self.auction_contract.revealedAndUnlocked(rec_bin(commitCharlie)) self.assertFalse(revealedAndUnlocked_boolCharlie) ## ## BROADCAST UNLOCK ## self.chain.mine(1) self.chain.direct_tx(unlock_tx_objectAlice) unlock_gasAlice = int(self.chain.head_state.gas_used) self.chain.mine(1) self.chain.mine(1) self.chain.direct_tx(unlock_tx_objectBob) unlock_gasBob = int(self.chain.head_state.gas_used) self.chain.mine(1) self.chain.mine(1) self.chain.direct_tx(unlock_tx_objectCharlie) unlock_gasCharlie = int(self.chain.head_state.gas_used) self.chain.mine(1) ## ## CHECK STATE AFTER UNLOCK ## # # stuff to help with debugging # # unlock_block_numberAlice, unlock_block_indexAlice = self.chain.chain.get_tx_position( # # unlock_tx_objectAlice) # # unlock_block_objectAlice = self.chain.chain.get_block_by_number(unlock_block_numberAlice) # # print(unlock_block_objectAlice.as_dict()) self.assertEqual( self.chain.head_state.get_balance(commitAddressAlice), (extraTransactionFees - unlock_gasAlice*OURGASPRICE), "Commit address should send along the money and have almost 0 money left." ) self.assertEqual( self.chain.head_state.get_balance(commitAddressBob), (extraTransactionFees - unlock_gasBob*OURGASPRICE), "Commit address should send along the money and have almost 0 money left." ) self.assertEqual( self.chain.head_state.get_balance(commitAddressCharlie), (extraTransactionFees - unlock_gasCharlie*OURGASPRICE), "Commit address should send along the money and have almost 0 money left." ) self.assertEqual( self.chain.head_state.get_balance(self.auction_contract.address), (BID_AMOUNT_Alice + BID_AMOUNT_Bob + BID_AMOUNT_Charlie), "Contract address should have the sum of the bids balance." ) session_dataAlice = self.auction_contract.getSubmarineState(rec_bin(commitAlice)) self.assertListEqual(session_dataAlice, [BID_AMOUNT_Alice, BID_AMOUNT_Alice, commit_block_numberAlice, commit_block_indexAlice]) revealedAndUnlocked_boolAlice = self.auction_contract.revealedAndUnlocked(rec_bin(commitAlice)) self.assertTrue(revealedAndUnlocked_boolAlice) session_dataBob = self.auction_contract.getSubmarineState(rec_bin(commitBob)) self.assertListEqual(session_dataBob, [BID_AMOUNT_Bob, BID_AMOUNT_Bob, commit_block_numberBob, commit_block_indexBob]) revealedAndUnlocked_boolBob = self.auction_contract.revealedAndUnlocked(rec_bin(commitBob)) self.assertTrue(revealedAndUnlocked_boolBob) session_dataCharlie = self.auction_contract.getSubmarineState(rec_bin(commitCharlie)) self.assertListEqual(session_dataCharlie, [BID_AMOUNT_Charlie, BID_AMOUNT_Charlie, commit_block_numberCharlie, commit_block_indexCharlie]) revealedAndUnlocked_boolCharlie = self.auction_contract.revealedAndUnlocked(rec_bin(commitCharlie)) self.assertTrue(revealedAndUnlocked_boolCharlie) ## ## END AUCTION ## self.chain.mine(REVEAL_PERIOD_LENGTH) self.auction_contract.finalize(rec_bin(commitAlice), sender=ALICE_PRIVATE_KEY) self.auction_contract.finalize(rec_bin(commitBob), sender=BOB_PRIVATE_KEY) self.auction_contract.finalize(rec_bin(commitCharlie), sender=CHARLIE_PRIVATE_KEY) # ## # ## CHECK STATE NOW THAT AUCTION IS OVER self.assertEqual(commitCharlie, self.auction_contract.winningSubmarineId().hex()) self.assertEqual( ACCOUNT_STARTING_BALANCE - (extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS))) self.assertEqual( ACCOUNT_STARTING_BALANCE - (extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(BOB_ADDRESS))) self.assertEqual( ACCOUNT_STARTING_BALANCE - (BID_AMOUNT_Charlie + extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(CHARLIE_ADDRESS))) self.assertEqual(starting_owner_eth_holdings + BID_AMOUNT_Charlie, self.chain.head_state.get_balance(rec_hex(CONTRACT_OWNER_ADDRESS)))
def test_spam_unlock_large_spam(self): ## ## STARTING STATE ## ALICE_ADDRESS = t.a1 ALICE_PRIVATE_KEY = t.k1 SPAM_PRIVATE_KEY_MALLORY = t.k7 self.chain.mine(1) ## ## GENERATE UNLOCK TX ## addressB, commit, witness, unlock_tx_hex = generate_submarine_commit.generateCommitAddress( normalize_address(rec_hex(ALICE_ADDRESS)), normalize_address(rec_hex(self.verifier_contract.address)), UNLOCK_AMOUNT, b'', OURGASPRICE, OURGASLIMIT) unlock_tx_info = rlp.decode(rec_bin(unlock_tx_hex)) unlock_tx_object = transactions.Transaction( int.from_bytes(unlock_tx_info[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_info[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_info[2], byteorder="big"), # startgas unlock_tx_info[3], # to addr int.from_bytes(unlock_tx_info[4], byteorder="big"), # value unlock_tx_info[5], # data int.from_bytes(unlock_tx_info[6], byteorder="big"), # v int.from_bytes(unlock_tx_info[7], byteorder="big"), # r int.from_bytes(unlock_tx_info[8], byteorder="big") # s ) unlock_tx_unsigned_object = transactions.UnsignedTransaction( int.from_bytes(unlock_tx_info[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_info[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_info[2], byteorder="big"), # startgas unlock_tx_info[3], # to addr int.from_bytes(unlock_tx_info[4], byteorder="big"), # value unlock_tx_info[5], # data ) unlock_tx_unsigned_rlp = rlp.encode(unlock_tx_unsigned_object, transactions.UnsignedTransaction) ## ## SPAM THE UNLOCK FUNCTION ## SPAM_AMOUNT = UNLOCK_AMOUNT + 3235 spam_tx_object = transactions.Transaction( 0, OURGASPRICE, OURGASLIMIT, normalize_address(rec_hex(self.verifier_contract.address)), SPAM_AMOUNT, unlock_tx_object[5]).sign(SPAM_PRIVATE_KEY_MALLORY) self.chain.direct_tx(spam_tx_object) session_data = self.verifier_contract.getSubmarineState(rec_bin(commit)) self.assertListEqual(session_data, [SOLIDITY_NULL_INITIALVAL, SPAM_AMOUNT, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL]) self.chain.mine(1) ## ## GENERATE COMMIT ## commit_tx_object = transactions.Transaction( 0, OURGASPRICE, BASIC_SEND_GAS_LIMIT, rec_bin(addressB), (UNLOCK_AMOUNT + extraTransactionFees), b'').sign(ALICE_PRIVATE_KEY) self.chain.direct_tx(commit_tx_object) self.chain.mine(4) session_data = self.verifier_contract.getSubmarineState(rec_bin(commit)) self.assertListEqual(session_data, [SOLIDITY_NULL_INITIALVAL, SPAM_AMOUNT, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL]) finished_bool = self.verifier_contract.revealedAndUnlocked(rec_bin(commit)) self.assertFalse( finished_bool, "The contract should not be finished until after the reveal.") commit_block_number, commit_block_index = self.chain.chain.get_tx_position(commit_tx_object) ## ## BROADCAST UNLOCK (this should cause an exception since someone else donated money to your cause) ## with self.assertRaises(t.TransactionFailed): self.chain.direct_tx(unlock_tx_object) ## ## CHECK STATE AFTER UNLOCK ## session_data = self.verifier_contract.getSubmarineState(rec_bin(commit)) self.assertListEqual( session_data, [SOLIDITY_NULL_INITIALVAL, SPAM_AMOUNT, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL], "State does not match expected value after unlock.") finished_bool = self.verifier_contract.revealedAndUnlocked(rec_bin(commit)) self.assertFalse(finished_bool) ## ## GENERATE AND BROADCAST REVEAL TX ## assert (isinstance(witness, str)) commit_block_object = self.chain.chain.get_block_by_number( commit_block_number) log.info("Block information: {}".format( str(commit_block_object.as_dict()))) log.info("Block header: {}".format( str(commit_block_object.as_dict()['header'].as_dict()))) log.info("Block transactions: {}".format( str(commit_block_object.as_dict()['transactions'][0].as_dict()))) proveth_commit_block = proveth_compatible_commit_block(commit_block_object, commit_tx_object) commit_proof_blob = proveth.generate_proof_blob( proveth_commit_block, commit_block_index) log.info("Proof Blob generate by proveth.py: {}".format( rec_hex(commit_proof_blob))) # Solidity Event log listener def _event_listener(llog): log.info('Solidity Event listener log fire: {}'.format(str(llog))) log.info('Solidity Event listener log fire hex: {}'.format( str(rec_hex(llog['data'])))) self.chain.head_state.log_listeners.append(_event_listener) _unlockExtraData = b'' # In this example we dont have any extra embedded data as part of the unlock TX self.chain.mine(20) self.verifier_contract.reveal( #print( commit_block_number, # uint32 _commitBlockNumber, _unlockExtraData, # bytes _commitData, rec_bin(witness), # bytes32 _witness, unlock_tx_unsigned_rlp, # bytes _rlpUnlockTxUnsigned, commit_proof_blob, # bytes _proofBlob sender=ALICE_PRIVATE_KEY) log.info("Reveal TX Gas Used HeadState {}".format( self.chain.head_state.gas_used)) reveal_gas = int(self.chain.head_state.gas_used) self.chain.mine(1) ## ## CHECK STATE AFTER REVEAL TX ## session_data = self.verifier_contract.getSubmarineState(rec_bin(commit)) self.assertListEqual( session_data, [UNLOCK_AMOUNT, SPAM_AMOUNT, commit_block_number, commit_block_index], "After the Reveal, the state should report both revealed and unlocked." ) finished_bool = self.verifier_contract.revealedAndUnlocked(rec_bin(commit)) self.assertTrue( finished_bool, "The contract was unlocked first and then revealed, it should be finished" )
def test_workflow(self): ## ## STARTING STATE ## ALICE_ADDRESS = t.a1 ALICE_PRIVATE_KEY = t.k1 log.info("Contract Address: {}".format( rec_hex(self.verifier_contract.address))) log.info("State: Starting A1 has {} and has address {}".format( self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS)), rec_hex(ALICE_ADDRESS))) self.chain.mine(1) ## ## GENERATE UNLOCK AND BROADCAST TX, THEN BROADCAST JUST COMMIT TX ## addressB, commit, witness, unlock_tx_hex = generate_submarine_commit.generateCommitAddress( normalize_address(rec_hex(ALICE_ADDRESS)), normalize_address(rec_hex(self.verifier_contract.address)), UNLOCK_AMOUNT, b'', OURGASPRICE, OURGASLIMIT) log.info("Precomputed address of commit target: {}".format(addressB)) assert (isinstance(witness, str)) unlock_tx_info = rlp.decode(rec_bin(unlock_tx_hex)) log.info("Unlock tx hex object: {}".format(rec_hex(unlock_tx_info))) unlock_tx_object = transactions.Transaction( int.from_bytes(unlock_tx_info[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_info[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_info[2], byteorder="big"), # startgas unlock_tx_info[3], # to addr int.from_bytes(unlock_tx_info[4], byteorder="big"), # value unlock_tx_info[5], # data int.from_bytes(unlock_tx_info[6], byteorder="big"), # v int.from_bytes(unlock_tx_info[7], byteorder="big"), # r int.from_bytes(unlock_tx_info[8], byteorder="big") # s ) log.info("Unlock tx hash: {}".format(rec_hex(unlock_tx_object.hash))) unlock_tx_unsigned_object = transactions.UnsignedTransaction( int.from_bytes(unlock_tx_info[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_info[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_info[2], byteorder="big"), # startgas unlock_tx_info[3], # to addr int.from_bytes(unlock_tx_info[4], byteorder="big"), # value unlock_tx_info[5], # data ) unlock_tx_unsigned_rlp = rlp.encode(unlock_tx_unsigned_object, transactions.UnsignedTransaction) commit_tx_object = transactions.Transaction( 0, OURGASPRICE, BASIC_SEND_GAS_LIMIT, rec_bin(addressB), (UNLOCK_AMOUNT + extraTransactionFees), b'').sign(ALICE_PRIVATE_KEY) log.info("Commit TX Object: {}".format( str(commit_tx_object.to_dict()))) log.info("Commit TX gas used Intrinsic: {}".format( str(commit_tx_object.intrinsic_gas_used))) commit_gas = int(self.chain.head_state.gas_used) self.chain.direct_tx(commit_tx_object) log.info("Commit TX Gas Used HeadState {}".format( self.chain.head_state.gas_used)) self.chain.mine(1) ## ## CHECK STATE AFTER COMMIT TX ## commit_block_number, commit_block_index = self.chain.chain.get_tx_position( commit_tx_object) log.info("Commit Tx block number {} and tx block index {}".format( commit_block_number, commit_block_index)) log.info("State: After commit A1 has {} and has address {}".format( self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS)), rec_hex(ALICE_ADDRESS))) log.info("State: After commit B has {} and has address {}".format( self.chain.head_state.get_balance(addressB), addressB)) self.assertEqual(UNLOCK_AMOUNT + extraTransactionFees, self.chain.head_state.get_balance(addressB)) self.assertEqual( ACCOUNT_STARTING_BALANCE - (UNLOCK_AMOUNT + extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS))) session_data = self.verifier_contract.getSubmarineState(rec_bin(commit)) self.assertListEqual( session_data, [SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL], "The contract should not know anything about the commit until after it's been revealed... " ) finished_bool = self.verifier_contract.revealedAndUnlocked(rec_bin(commit)) self.assertFalse( finished_bool, "The contract should not be finished before it's even begun.") ## ## GENERATE AND BROADCAST REVEAL TX ## commit_block_object = self.chain.chain.get_block_by_number( commit_block_number) log.info("Block information: {}".format( str(commit_block_object.as_dict()))) log.info("Block header: {}".format( str(commit_block_object.as_dict()['header'].as_dict()))) log.info("Block transactions: {}".format( str(commit_block_object.as_dict()['transactions'][0].as_dict()))) proveth_commit_block = proveth_compatible_commit_block(commit_block_object, commit_tx_object) commit_proof_blob = proveth.generate_proof_blob( proveth_commit_block, commit_block_index) log.info("Proof Blob generate by proveth.py: {}".format( rec_hex(commit_proof_blob))) # Solidity Event log listener def _event_listener(llog): log.info('Solidity Event listener log fire: {}'.format(str(llog))) log.info('Solidity Event listener log fire hex: {}'.format( str(rec_hex(llog['data'])))) self.chain.head_state.log_listeners.append(_event_listener) _unlockExtraData = b'' # In this example we dont have any extra embedded data as part of the unlock TX self.chain.mine(20) self.verifier_contract.reveal( #print( commit_block_number, # uint32 _commitBlockNumber, _unlockExtraData, # bytes _commitData, rec_bin(witness), # bytes32 _witness, unlock_tx_unsigned_rlp, # bytes _rlpUnlockTxUnsigned, commit_proof_blob, # bytes _proofBlob sender=ALICE_PRIVATE_KEY) log.info("Reveal TX Gas Used HeadState {}".format( self.chain.head_state.gas_used)) reveal_gas = int(self.chain.head_state.gas_used) self.chain.mine(1) ## ## CHECK STATE AFTER REVEAL TX ## session_data = self.verifier_contract.getSubmarineState(rec_bin(commit)) self.assertListEqual( session_data, [UNLOCK_AMOUNT, SOLIDITY_NULL_INITIALVAL, commit_block_number, commit_block_index ], "After the Reveal, the state should report revealed but not unlocked." ) finished_bool = self.verifier_contract.revealedAndUnlocked(rec_bin(commit)) self.assertFalse( finished_bool, "The contract is only revealed, not unlocked and therefore finished." ) ## ## BROADCAST UNLOCK ## self.chain.direct_tx(unlock_tx_object) log.info("Unlock TX Gas Used HeadState {}".format( self.chain.head_state.gas_used)) unlock_gas = int(self.chain.head_state.gas_used) ## ## CHECK STATE AFTER UNLOCK ## log.info("State: After unlock B has {} and has address {}".format( self.chain.head_state.get_balance(addressB), addressB)) self.assertLess( self.chain.head_state.get_balance(addressB), UNLOCK_AMOUNT + extraTransactionFees, "Address B should send along the money and have almost 0 money left." ) self.assertEqual( 999998562999979000000000, self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS))) session_data = self.verifier_contract.getSubmarineState(rec_bin(commit)) self.assertListEqual( session_data, [UNLOCK_AMOUNT, UNLOCK_AMOUNT, commit_block_number, commit_block_index ], "State does not match expected value after unlock.") finished_bool = self.verifier_contract.revealedAndUnlocked(rec_bin(commit)) self.assertTrue(finished_bool, "After unlock, contract should be finished.") sumGas = commit_gas + reveal_gas + unlock_gas log.info("Final Gas Estimation {}".format(str(sumGas)))
def test_txValidate(self): block_hash = '0x51c92d45e39db17e43f0f7333de44c592b504bb8ac24dc3c39135d46655bae4f' print("Testing Tx validation for tx 0 in (ropsten) block {}".format( block_hash)) block_header = [ "0x5b5782c32df715c083da95b805959d4718ec698915a4b0288e325aa346436be1", "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "0xfee3a49dc4243fa92019fc4331228043b3c5e825", "0x13a50145091c1b5bae07abe10da88c54c5111c3fbb74fc91074ad2ffec311f6b", "0x0c673fc4822ba97cc737cfa7a839d6f6f755deedb1506490911f710bfa9315bf", "0x0c1fcb2441331ab1abc2e174a7293acce160d0b04f35a4b791bf89e9fd452b10", "0x00000000000000200000000000000000000000000010002000000000000000000040000000000000000000000010000000000000000000000040000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000100", 202070028, 1322230, 4712388, 272545, 1500404127, "0xd883010606846765746887676f312e382e338664617277696e", "0x6ebda3617b113ba6550d08cb34119f940ddb96b509c62b7d0a8420722329d5b4", "0x61ebb9e58c93ac26", ] self.assertEqual(utils.sha3(rlp.encode(rec_bin(block_header))), rec_bin(block_hash)) tx = collections.OrderedDict([ ('nonce', 3), ('gasprice', 0x06fc23ac00), ('startgas', 0x0494e5), ('to', rec_bin('0xb13f6f423781bd1934fc8599782f5e161ce7c816')), ('value', 0x2386f26fc10000), ('data', rec_bin( '0xf435f5a7000000000000000000000000c198eccab3fe1f35e9160b48eb18af7934a13262' )), ('v', 0x29), ('r', 0x4602fcb7ef369fbe1e6d7d1658934a18bcc3b373454fc33dedb53cd9dd0226d2 ), ('s', 0x3a94a58becc2493007a6411b73a2b5c5a58b17b7a79bbb103568cc62b8945961 ), ]) proof_type = 1 tx_index = 0 mpt_path = "0x0800" stack_indexes = "0x0801" stack = [ [ 'da42945ae3c75118e89abff39ad566fd0a30b574e5df8ae70ce59d4cc5f19cb1', '', '', '', '', '', '', '', 'ca85a0d0ed219e8583feadf2dce0a73aa05e7d6a790c32efcc1dd6c901195f16', '', '', '', '', '', '', '', '' ], ['30', rec_hex(rlp.encode(list(tx.values())))], ] proof_blob = rlp.encode( rec_bin([ proof_type, block_header, tx_index, mpt_path, stack_indexes, stack, ])) (result, index, nonce, gasprice, startgas, to, value, data, v, r, s, contract_creation) = \ self.verifier_contract.txProof( rec_bin(block_hash), proof_blob, startgas=10**6, ) self.assertEqual(result, self.verifier_contract.TX_PROOF_RESULT_PRESENT()) self.assertEqual(index, 0) self.assertEqual(nonce, tx['nonce']) self.assertEqual(gasprice, tx['gasprice']) self.assertEqual(startgas, tx['startgas']) self.assertEqualAddr(to, tx['to']) self.assertEqual(value, tx['value']) self.assertEqual(data, tx['data']) self.assertEqual(v, tx['v']) self.assertEqual(r, tx['r']) self.assertEqual(s, tx['s']) self.assertEqual(contract_creation, False)
def test_manual1(self): # from block 1322230 on ropsten decoded_proof_blob = [ '01', [ '5b5782c32df715c083da95b805959d4718ec698915a4b0288e325aa346436be1', '1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347', 'fee3a49dc4243fa92019fc4331228043b3c5e825', '13a50145091c1b5bae07abe10da88c54c5111c3fbb74fc91074ad2ffec311f6b', '0c673fc4822ba97cc737cfa7a839d6f6f755deedb1506490911f710bfa9315bf', '0c1fcb2441331ab1abc2e174a7293acce160d0b04f35a4b791bf89e9fd452b10', '00000000000000200000000000000000000000000010002000000000000000000040000000000000000000000010000000000000000000000040000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000100', '0c0b580c', '142cf6', '47e7c4', '0428a1', '596e599f', 'd883010606846765746887676f312e382e338664617277696e', '6ebda3617b113ba6550d08cb34119f940ddb96b509c62b7d0a8420722329d5b4', '61ebb9e58c93ac26', ], '01', '0001', '000101', [ [ 'da42945ae3c75118e89abff39ad566fd0a30b574e5df8ae70ce59d4cc5f19cb1', '', '', '', '', '', '', '', 'ca85a0d0ed219e8583feadf2dce0a73aa05e7d6a790c32efcc1dd6c901195f16', '', '', '', '', '', '', '', '' ], [ '', 'e61bb422a77353192ae2b4b29c3773b018da71d1425b2a48cca04d7da9917fab', '6b46aad90e0a9eeede8f2ad992401e52b3e52ce7d5bf723a48922401d5af95cc', '997f63912b72cdf8a907025644e1df51c313015c4e9e51500fa6ffa52241eef4', '5ad4d0c46a043da4e1da601955a1d29d5bd3b6c5b2dfc2776c8a898f998af498', '457048648440cf69193e770035a2df6f42ab5a6b8bc4d789a92074dc2beb2091', '', '', '', '', '', '', '', '', '', '', '' ], [ '20', 'f88b820beb8506fc23ac00832dd5d8943d04303126cd6e75324825455685b028401e0ec280a4e733ca974e6964610000000000000000000000000000000000000000000000000000000029a0f5405ffd54b78fc27dc56c49364ec22ba94c471f4639f052cfe324e3fc05d1d3a041291d64a8cdf499c386fde5bc04a1ca743aa81f65dc59198d29f8d66ee588a5' ], ], ] block_hash = utils.decode_hex( '51c92d45e39db17e43f0f7333de44c592b504bb8ac24dc3c39135d46655bae4f') result, index, nonce, gas_price, gas, to, value, data, v, r, s, contract_creation = self.verifier_contract.txProof( block_hash, rlp.encode(rec_bin(decoded_proof_blob)), startgas=10**6) self.assertEqual(result, self.verifier_contract.TX_PROOF_RESULT_PRESENT()) self.assertEqual(index, 1) def assert_failed_call(modified_decoded_proof_blob, block_hash=block_hash): with self.assertRaises(t.TransactionFailed): _ = self.verifier_contract.txProof( block_hash, rlp.encode(rec_bin(modified_decoded_proof_blob)), startgas=10**6) assert_failed_call( decoded_proof_blob, block_hash=utils.decode_hex( '51c92d45e39db17e43f0f7333de44c592b504bb8ac24dc3c39135d46655bae40' )) modified_decoded_proof_blob = copy.deepcopy(decoded_proof_blob) modified_decoded_proof_blob[0] = 'ab' assert_failed_call(modified_decoded_proof_blob) modified_decoded_proof_blob = copy.deepcopy(decoded_proof_blob) modified_decoded_proof_blob[1][ 0] = '5b5782c32df715c083da95b805959d4718ec698915a4b0288e325aa346436be2' assert_failed_call(modified_decoded_proof_blob) modified_decoded_proof_blob = copy.deepcopy(decoded_proof_blob) modified_decoded_proof_blob[2] = '02' assert_failed_call(modified_decoded_proof_blob) modified_decoded_proof_blob = copy.deepcopy(decoded_proof_blob) modified_decoded_proof_blob[3] = '0101' assert_failed_call(modified_decoded_proof_blob) modified_decoded_proof_blob = copy.deepcopy(decoded_proof_blob) modified_decoded_proof_blob[3] = '000100' assert_failed_call(modified_decoded_proof_blob) modified_decoded_proof_blob = copy.deepcopy(decoded_proof_blob) modified_decoded_proof_blob[4] = '0001ff' assert_failed_call(modified_decoded_proof_blob) modified_decoded_proof_blob = copy.deepcopy(decoded_proof_blob) modified_decoded_proof_blob[5][0][ 0] = 'da42945ae3c75118e89abff39ad566fd0a30b574e5df8ae70ce59d4cc5f19cb2' assert_failed_call(modified_decoded_proof_blob) modified_decoded_proof_blob = copy.deepcopy(decoded_proof_blob) modified_decoded_proof_blob[5][1][ 1] = 'e61bb422a77353192ae2b4b29c3773b018da71d1425b2a48cca04d7da9917fac' assert_failed_call(modified_decoded_proof_blob) modified_decoded_proof_blob = copy.deepcopy(decoded_proof_blob) modified_decoded_proof_blob[5][2][0] = '21' assert_failed_call(modified_decoded_proof_blob) modified_decoded_proof_blob = copy.deepcopy(decoded_proof_blob) modified_decoded_proof_blob[5][2][1] = modified_decoded_proof_blob[5][ 2][1].replace( 'e733ca974e69646100000000000000000000000000000000000000000000000000000000', 'f733ca974e69646100000000000000000000000000000000000000000000000000000000' ) assert_failed_call(modified_decoded_proof_blob)
def test_workflow(self): DAPP_ADDRESS = t.a2 DAPP_PRIVATE_KEY = t.k2 print("Contract Address:", rec_hex(self.verifier_contract.address)) print("A1 has {} and has address {}".format( self.chain.head_state.get_balance(rec_hex(t.a1)), rec_hex(t.a1))) addressB, commit, witness, tx_hex = generate_submarine_commit.generateAddressBexport( normalize_address(rec_hex(t.a1)), normalize_address(rec_hex(self.verifier_contract.address)), UNLOCK_AMOUNT, b'', OURGASPRICE, OURGASLIMIT) print("Address of commit: {}".format(addressB)) commit_tx_object = transactions.Transaction( 0, OURGASPRICE, OURGASLIMIT, rec_bin(addressB), (UNLOCK_AMOUNT + extraTransactionFees), b'').sign(t.k1) print("New transaction hash") print(rec_hex(commit_tx_object.hash)) self.chain.mine(3) self.chain.direct_tx(commit_tx_object) self.chain.mine(3) commitBlockNumber, commitBlockIndex = self.chain.chain.get_tx_position( commit_tx_object) print("tx block number {} and tx block index {}".format( commitBlockNumber, commitBlockIndex)) #tx_reciept = self.chain.tx(t.k1, rec_bin(addressB), (UNLOCK_AMOUNT + extraTransactionFees), b'', 21000, 10**6) print("A1 has {} and has address {}".format( self.chain.head_state.get_balance(rec_hex(t.a1)), rec_hex(t.a1))) print("B has {} and has address {}".format( self.chain.head_state.get_balance(addressB), addressB)) self.assertEqual(1437000000000000000, self.chain.head_state.get_balance(addressB)) self.assertEqual(999998562999979000000000, self.chain.head_state.get_balance(rec_hex(t.a1))) assert (isinstance(witness, str)) self.verifier_contract.reveal(commitBlockNumber, commitBlockIndex, DAPP_ADDRESS, UNLOCK_AMOUNT, b'', rec_bin(witness), OURGASPRICE, OURGASLIMIT, sender=t.k1, to=self.verifier_contract.address, value=1009, gasprice=OURGASPRICE, startgas=OURGASLIMIT) revealTestSession = self.verifier_contract.getSession(rec_bin(commit)) print(revealTestSession) # see getSession function return values for reference self.assertEqual(False, revealTestSession[0]) self.assertEqual(True, revealTestSession[1]) self.assertEqual(False, revealTestSession[2]) self.assertEqual(UNLOCK_AMOUNT, revealTestSession[3]) self.assertEqual(commitBlockNumber, revealTestSession[4]) self.assertEqual(commitBlockIndex, revealTestSession[5]) # todo make reveal by instatiating transaction class so that # todo we can get the tx hash and look up the block instead of hard coding self.assertEqual(8, revealTestSession[6]) self.assertEqual(b'', revealTestSession[7]) self.assertEqual(rec_hex(DAPP_ADDRESS), revealTestSession[8]) isfine, unlockAmount, unlockdata = self.verifier_contract.isFinalizable( rec_bin(commit)) self.assertFalse(isfine) unlock_tx_info = rlp.decode(rec_bin(tx_hex)) print(rec_hex(unlock_tx_info)) unlock_tx_object = transactions.Transaction( int.from_bytes(unlock_tx_info[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_info[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_info[2], byteorder="big"), # startgas unlock_tx_info[3], # to addr int.from_bytes(unlock_tx_info[4], byteorder="big"), # value unlock_tx_info[5], # data int.from_bytes(unlock_tx_info[6], byteorder="big"), # v int.from_bytes(unlock_tx_info[7], byteorder="big"), # r int.from_bytes(unlock_tx_info[8], byteorder="big") # s ) print("Unlock hash: ") print(rec_hex(unlock_tx_object.hash)) self.chain.direct_tx(unlock_tx_object) self.chain.mine(3) unlockTestSession = self.verifier_contract.getSession(rec_bin(commit)) print(unlockTestSession) self.assertEqual(True, unlockTestSession[0]) self.assertEqual(True, unlockTestSession[1]) self.assertEqual(False, unlockTestSession[2]) self.assertEqual(UNLOCK_AMOUNT, unlockTestSession[3]) self.assertEqual(commitBlockNumber, unlockTestSession[4]) self.assertEqual(commitBlockIndex, unlockTestSession[5]) # todo make reveal by instatiating transaction class so that # todo we can get the tx hash and look up the block instead of hard coding self.assertEqual(8, unlockTestSession[6]) self.assertEqual(b'', unlockTestSession[7]) self.assertEqual(rec_hex(DAPP_ADDRESS), unlockTestSession[8]) unlockBlockNumber, unlockBlockIndex = self.chain.chain.get_tx_position( unlock_tx_object) print("tx block number {} and tx block index {}".format( unlockBlockNumber, unlockBlockIndex)) self.chain.mine(CHALLENGE_PERIOD_LENGTH) isfine, unlockAmount, unlockData = self.verifier_contract.isFinalizable( rec_bin(commit)) self.assertTrue(isfine) self.assertEqual(UNLOCK_AMOUNT, unlockAmount) self.assertEqual(b'', unlockData) print("DAPP Address has {} and has address {}".format( self.chain.head_state.get_balance(rec_hex(DAPP_ADDRESS)), rec_hex(DAPP_ADDRESS))) unlockAmount, unlockData = self.verifier_contract.finalize( rec_bin(commit), sender=DAPP_PRIVATE_KEY, to=self.verifier_contract.address, value=0, gasprice=OURGASPRICE, startgas=OURGASLIMIT) self.chain.mine(1) self.assertEqual(UNLOCK_AMOUNT, unlockAmount) self.assertEqual(b'', unlockData) print("DAPP Address has {} and has address {}".format( self.chain.head_state.get_balance(rec_hex(DAPP_ADDRESS)), rec_hex(DAPP_ADDRESS))) print()
def test_auctionWorkflow(self): ## ## STARTING STATE ## starting_block_height = self.chain.head_state.block_number starting_owner_eth_holdings = self.chain.head_state.get_balance( rec_hex(CONTRACT_OWNER_ADDRESS)) self.chain.mine(1) self.assertEqual( ACCOUNT_STARTING_BALANCE, self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS))) self.assertEqual( ACCOUNT_STARTING_BALANCE, self.chain.head_state.get_balance(rec_hex(BOB_ADDRESS))) self.assertEqual( ACCOUNT_STARTING_BALANCE, self.chain.head_state.get_balance(rec_hex(CHARLIE_ADDRESS))) self.assertEqual(27, self.verifier_contract.vee()) self.assertEqual(COMMIT_PERIOD_LENGTH, self.verifier_contract.commitPeriodLength()) self.assertEqual(REVEAL_PERIOD_LENGTH, self.verifier_contract.revealPeriodLength()) self.assertEqual( starting_block_height + COMMIT_PERIOD_LENGTH + REVEAL_PERIOD_LENGTH, self.verifier_contract.auctionEndBlock()) # # GENERATE UNLOCK TXs # commitAddressAlice, commitAlice, witnessAlice, unlock_tx_hexAlice = generate_submarine_commit.generateCommitAddress( normalize_address(rec_hex(ALICE_ADDRESS)), normalize_address(rec_hex(self.verifier_contract.address)), BID_AMOUNT_Alice, b'', OURGASPRICE, OURGASLIMIT) unlock_tx_infoAlice = rlp.decode(rec_bin(unlock_tx_hexAlice)) unlock_tx_objectAlice = transactions.Transaction( int.from_bytes(unlock_tx_infoAlice[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoAlice[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoAlice[2], byteorder="big"), # startgas unlock_tx_infoAlice[3], # to addr int.from_bytes(unlock_tx_infoAlice[4], byteorder="big"), # value unlock_tx_infoAlice[5], # data int.from_bytes(unlock_tx_infoAlice[6], byteorder="big"), # v int.from_bytes(unlock_tx_infoAlice[7], byteorder="big"), # r int.from_bytes(unlock_tx_infoAlice[8], byteorder="big") # s ) commitAddressBob, commitBob, witnessBob, unlock_tx_hexBob = generate_submarine_commit.generateCommitAddress( normalize_address(rec_hex(BOB_ADDRESS)), normalize_address(rec_hex(self.verifier_contract.address)), BID_AMOUNT_Bob, b'', OURGASPRICE, OURGASLIMIT) unlock_tx_infoBob = rlp.decode(rec_bin(unlock_tx_hexBob)) unlock_tx_objectBob = transactions.Transaction( int.from_bytes(unlock_tx_infoBob[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoBob[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoBob[2], byteorder="big"), # startgas unlock_tx_infoBob[3], # to addr int.from_bytes(unlock_tx_infoBob[4], byteorder="big"), # value unlock_tx_infoBob[5], # data int.from_bytes(unlock_tx_infoBob[6], byteorder="big"), # v int.from_bytes(unlock_tx_infoBob[7], byteorder="big"), # r int.from_bytes(unlock_tx_infoBob[8], byteorder="big") # s ) commitAddressCharlie, commitCharlie, witnessCharlie, unlock_tx_hexCharlie = generate_submarine_commit.generateCommitAddress( normalize_address(rec_hex(CHARLIE_ADDRESS)), normalize_address(rec_hex(self.verifier_contract.address)), BID_AMOUNT_Charlie, b'', OURGASPRICE, OURGASLIMIT) unlock_tx_infoCharlie = rlp.decode(rec_bin(unlock_tx_hexCharlie)) unlock_tx_objectCharlie = transactions.Transaction( int.from_bytes(unlock_tx_infoCharlie[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoCharlie[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoCharlie[2], byteorder="big"), # startgas unlock_tx_infoCharlie[3], # to addr int.from_bytes(unlock_tx_infoCharlie[4], byteorder="big"), # value unlock_tx_infoCharlie[5], # data int.from_bytes(unlock_tx_infoCharlie[6], byteorder="big"), # v int.from_bytes(unlock_tx_infoCharlie[7], byteorder="big"), # r int.from_bytes(unlock_tx_infoCharlie[8], byteorder="big") # s ) # # GENERATE + BROADCAST COMMIT TXs # commit_tx_objectAlice = transactions.Transaction( 0, OURGASPRICE, BASIC_SEND_GAS_LIMIT, rec_bin(commitAddressAlice), (BID_AMOUNT_Alice + extraTransactionFees), b'').sign(ALICE_PRIVATE_KEY) commit_gasAlice = int(self.chain.head_state.gas_used) self.chain.direct_tx(commit_tx_objectAlice) self.chain.mine(1) commit_tx_objectBob = transactions.Transaction( 0, OURGASPRICE, BASIC_SEND_GAS_LIMIT, rec_bin(commitAddressBob), (BID_AMOUNT_Bob + extraTransactionFees), b'').sign(BOB_PRIVATE_KEY) commit_gasBob = int(self.chain.head_state.gas_used) self.chain.direct_tx(commit_tx_objectBob) self.chain.mine(1) commit_tx_objectCharlie = transactions.Transaction( 0, OURGASPRICE, BASIC_SEND_GAS_LIMIT, rec_bin(commitAddressCharlie), (BID_AMOUNT_Charlie + extraTransactionFees), b'').sign(CHARLIE_PRIVATE_KEY) commit_gasCharlie = int(self.chain.head_state.gas_used) self.chain.direct_tx(commit_tx_objectCharlie) self.chain.mine(1) ## ## CHECK STATE AFTER COMMIT TX ## commit_block_numberAlice, commit_block_indexAlice = self.chain.chain.get_tx_position( commit_tx_objectAlice) self.assertEqual(BID_AMOUNT_Alice + extraTransactionFees, self.chain.head_state.get_balance(commitAddressAlice)) self.assertEqual( ACCOUNT_STARTING_BALANCE - (BID_AMOUNT_Alice + extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS))) session_dataAlice = self.verifier_contract.getCommitState( rec_bin(commitAlice)) self.assertListEqual(session_dataAlice, [ SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL ]) finished_boolAlice = self.verifier_contract.finished( rec_bin(commitAlice)) self.assertFalse( finished_boolAlice, "The contract should not be finished before it's even begun.") commit_block_numberBob, commit_block_indexBob = self.chain.chain.get_tx_position( commit_tx_objectBob) self.assertEqual(BID_AMOUNT_Bob + extraTransactionFees, self.chain.head_state.get_balance(commitAddressBob)) self.assertEqual( ACCOUNT_STARTING_BALANCE - (BID_AMOUNT_Bob + extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(BOB_ADDRESS))) session_dataBob = self.verifier_contract.getCommitState( rec_bin(commitBob)) self.assertListEqual(session_dataBob, [ SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL ]) finished_boolBob = self.verifier_contract.finished(rec_bin(commitBob)) self.assertFalse( finished_boolBob, "The contract should not be finished before it's even begun.") commit_block_numberCharlie, commit_block_indexCharlie = self.chain.chain.get_tx_position( commit_tx_objectCharlie) self.assertEqual( BID_AMOUNT_Charlie + extraTransactionFees, self.chain.head_state.get_balance(commitAddressCharlie)) self.assertEqual( ACCOUNT_STARTING_BALANCE - (BID_AMOUNT_Charlie + extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(CHARLIE_ADDRESS))) session_dataCharlie = self.verifier_contract.getCommitState( rec_bin(commitCharlie)) self.assertListEqual(session_dataCharlie, [ SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL, SOLIDITY_NULL_INITIALVAL ]) finished_boolCharlie = self.verifier_contract.finished( rec_bin(commitCharlie)) self.assertFalse( finished_boolCharlie, "The contract should not be finished before it's even begun.") ## ## GENERATE AND BROADCAST REVEAL BID TXS ## self.chain.mine(COMMIT_PERIOD_LENGTH) commit_block_objectAlice = self.chain.chain.get_block_by_number( commit_block_numberAlice) proveth_expected_block_format_dictAlice = dict() proveth_expected_block_format_dictAlice[ 'parentHash'] = commit_block_objectAlice['prevhash'] proveth_expected_block_format_dictAlice[ 'sha3Uncles'] = commit_block_objectAlice['uncles_hash'] proveth_expected_block_format_dictAlice[ 'miner'] = commit_block_objectAlice['coinbase'] proveth_expected_block_format_dictAlice[ 'stateRoot'] = commit_block_objectAlice['state_root'] proveth_expected_block_format_dictAlice[ 'transactionsRoot'] = commit_block_objectAlice['tx_list_root'] proveth_expected_block_format_dictAlice[ 'receiptsRoot'] = commit_block_objectAlice['receipts_root'] proveth_expected_block_format_dictAlice[ 'logsBloom'] = commit_block_objectAlice['bloom'] proveth_expected_block_format_dictAlice[ 'difficulty'] = commit_block_objectAlice['difficulty'] proveth_expected_block_format_dictAlice[ 'number'] = commit_block_objectAlice['number'] proveth_expected_block_format_dictAlice[ 'gasLimit'] = commit_block_objectAlice['gas_limit'] proveth_expected_block_format_dictAlice[ 'gasUsed'] = commit_block_objectAlice['gas_used'] proveth_expected_block_format_dictAlice[ 'timestamp'] = commit_block_objectAlice['timestamp'] proveth_expected_block_format_dictAlice[ 'extraData'] = commit_block_objectAlice['extra_data'] proveth_expected_block_format_dictAlice[ 'mixHash'] = commit_block_objectAlice['mixhash'] proveth_expected_block_format_dictAlice[ 'nonce'] = commit_block_objectAlice['nonce'] proveth_expected_block_format_dictAlice[ 'hash'] = commit_block_objectAlice.hash proveth_expected_block_format_dictAlice['uncles'] = [] proveth_expected_block_format_dictAlice['transactions'] = ({ "blockHash": commit_block_objectAlice.hash, "blockNumber": str(hex((commit_block_objectAlice['number']))), "from": checksum_encode(ALICE_ADDRESS), "gas": str(hex(commit_tx_objectAlice['startgas'])), "gasPrice": str(hex(commit_tx_objectAlice['gasprice'])), "hash": rec_hex(commit_tx_objectAlice['hash']), "input": rec_hex(commit_tx_objectAlice['data']), "nonce": str(hex(commit_tx_objectAlice['nonce'])), "to": checksum_encode(commit_tx_objectAlice['to']), "transactionIndex": str(hex(0)), "value": str(hex(commit_tx_objectAlice['value'])), "v": str(hex(commit_tx_objectAlice['v'])), "r": str(hex(commit_tx_objectAlice['r'])), "s": str(hex(commit_tx_objectAlice['s'])) }, ) commit_proof_blobAlice = proveth.generate_proof_blob( proveth_expected_block_format_dictAlice, commit_block_indexAlice) _unlockExtraData = b'' # In this example we dont have any extra embedded data as part of the unlock TX unlock_tx_unsigned_objectAlice = transactions.UnsignedTransaction( int.from_bytes(unlock_tx_infoAlice[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoAlice[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoAlice[2], byteorder="big"), # startgas unlock_tx_infoAlice[3], # to addr int.from_bytes(unlock_tx_infoAlice[4], byteorder="big"), # value unlock_tx_infoAlice[5], # data ) unlock_tx_unsigned_rlpAlice = rlp.encode( unlock_tx_unsigned_objectAlice, transactions.UnsignedTransaction) self.verifier_contract.revealBid( commit_block_numberAlice, # uint32 _commitBlockNumber, _unlockExtraData, # bytes _commitData, rec_bin(witnessAlice), # bytes32 _witness, unlock_tx_unsigned_rlpAlice, # bytes _rlpUnlockTxUnsigned, commit_proof_blobAlice, # bytes _proofBlob sender=ALICE_PRIVATE_KEY) reveal_gasAlice = int(self.chain.head_state.gas_used) self.chain.mine(1) commit_block_objectBob = self.chain.chain.get_block_by_number( commit_block_numberBob) proveth_expected_block_format_dictBob = dict() proveth_expected_block_format_dictBob[ 'parentHash'] = commit_block_objectBob['prevhash'] proveth_expected_block_format_dictBob[ 'sha3Uncles'] = commit_block_objectBob['uncles_hash'] proveth_expected_block_format_dictBob[ 'miner'] = commit_block_objectBob['coinbase'] proveth_expected_block_format_dictBob[ 'stateRoot'] = commit_block_objectBob['state_root'] proveth_expected_block_format_dictBob[ 'transactionsRoot'] = commit_block_objectBob['tx_list_root'] proveth_expected_block_format_dictBob[ 'receiptsRoot'] = commit_block_objectBob['receipts_root'] proveth_expected_block_format_dictBob[ 'logsBloom'] = commit_block_objectBob['bloom'] proveth_expected_block_format_dictBob[ 'difficulty'] = commit_block_objectBob['difficulty'] proveth_expected_block_format_dictBob[ 'number'] = commit_block_objectBob['number'] proveth_expected_block_format_dictBob[ 'gasLimit'] = commit_block_objectBob['gas_limit'] proveth_expected_block_format_dictBob[ 'gasUsed'] = commit_block_objectBob['gas_used'] proveth_expected_block_format_dictBob[ 'timestamp'] = commit_block_objectBob['timestamp'] proveth_expected_block_format_dictBob[ 'extraData'] = commit_block_objectBob['extra_data'] proveth_expected_block_format_dictBob[ 'mixHash'] = commit_block_objectBob['mixhash'] proveth_expected_block_format_dictBob[ 'nonce'] = commit_block_objectBob['nonce'] proveth_expected_block_format_dictBob[ 'hash'] = commit_block_objectBob.hash proveth_expected_block_format_dictBob['uncles'] = [] proveth_expected_block_format_dictBob['transactions'] = ({ "blockHash": commit_block_objectBob.hash, "blockNumber": str(hex((commit_block_objectBob['number']))), "from": checksum_encode(BOB_ADDRESS), "gas": str(hex(commit_tx_objectBob['startgas'])), "gasPrice": str(hex(commit_tx_objectBob['gasprice'])), "hash": rec_hex(commit_tx_objectBob['hash']), "input": rec_hex(commit_tx_objectBob['data']), "nonce": str(hex(commit_tx_objectBob['nonce'])), "to": checksum_encode(commit_tx_objectBob['to']), "transactionIndex": str(hex(0)), "value": str(hex(commit_tx_objectBob['value'])), "v": str(hex(commit_tx_objectBob['v'])), "r": str(hex(commit_tx_objectBob['r'])), "s": str(hex(commit_tx_objectBob['s'])) }, ) commit_proof_blobBob = proveth.generate_proof_blob( proveth_expected_block_format_dictBob, commit_block_indexBob) _unlockExtraData = b'' # In this example we dont have any extra embedded data as part of the unlock TX unlock_tx_unsigned_objectBob = transactions.UnsignedTransaction( int.from_bytes(unlock_tx_infoBob[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoBob[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoBob[2], byteorder="big"), # startgas unlock_tx_infoBob[3], # to addr int.from_bytes(unlock_tx_infoBob[4], byteorder="big"), # value unlock_tx_infoBob[5], # data ) unlock_tx_unsigned_rlpBob = rlp.encode( unlock_tx_unsigned_objectBob, transactions.UnsignedTransaction) self.verifier_contract.revealBid( commit_block_numberBob, # uint32 _commitBlockNumber, _unlockExtraData, # bytes _commitData, rec_bin(witnessBob), # bytes32 _witness, unlock_tx_unsigned_rlpBob, # bytes _rlpUnlockTxUnsigned, commit_proof_blobBob, # bytes _proofBlob sender=BOB_PRIVATE_KEY) reveal_gasBob = int(self.chain.head_state.gas_used) self.chain.mine(1) commit_block_objectCharlie = self.chain.chain.get_block_by_number( commit_block_numberCharlie) proveth_expected_block_format_dictCharlie = dict() proveth_expected_block_format_dictCharlie[ 'parentHash'] = commit_block_objectCharlie['prevhash'] proveth_expected_block_format_dictCharlie[ 'sha3Uncles'] = commit_block_objectCharlie['uncles_hash'] proveth_expected_block_format_dictCharlie[ 'miner'] = commit_block_objectCharlie['coinbase'] proveth_expected_block_format_dictCharlie[ 'stateRoot'] = commit_block_objectCharlie['state_root'] proveth_expected_block_format_dictCharlie[ 'transactionsRoot'] = commit_block_objectCharlie['tx_list_root'] proveth_expected_block_format_dictCharlie[ 'receiptsRoot'] = commit_block_objectCharlie['receipts_root'] proveth_expected_block_format_dictCharlie[ 'logsBloom'] = commit_block_objectCharlie['bloom'] proveth_expected_block_format_dictCharlie[ 'difficulty'] = commit_block_objectCharlie['difficulty'] proveth_expected_block_format_dictCharlie[ 'number'] = commit_block_objectCharlie['number'] proveth_expected_block_format_dictCharlie[ 'gasLimit'] = commit_block_objectCharlie['gas_limit'] proveth_expected_block_format_dictCharlie[ 'gasUsed'] = commit_block_objectCharlie['gas_used'] proveth_expected_block_format_dictCharlie[ 'timestamp'] = commit_block_objectCharlie['timestamp'] proveth_expected_block_format_dictCharlie[ 'extraData'] = commit_block_objectCharlie['extra_data'] proveth_expected_block_format_dictCharlie[ 'mixHash'] = commit_block_objectCharlie['mixhash'] proveth_expected_block_format_dictCharlie[ 'nonce'] = commit_block_objectCharlie['nonce'] proveth_expected_block_format_dictCharlie[ 'hash'] = commit_block_objectCharlie.hash proveth_expected_block_format_dictCharlie['uncles'] = [] proveth_expected_block_format_dictCharlie['transactions'] = ({ "blockHash": commit_block_objectCharlie.hash, "blockNumber": str(hex((commit_block_objectCharlie['number']))), "from": checksum_encode(CHARLIE_ADDRESS), "gas": str(hex(commit_tx_objectCharlie['startgas'])), "gasPrice": str(hex(commit_tx_objectCharlie['gasprice'])), "hash": rec_hex(commit_tx_objectCharlie['hash']), "input": rec_hex(commit_tx_objectCharlie['data']), "nonce": str(hex(commit_tx_objectCharlie['nonce'])), "to": checksum_encode(commit_tx_objectCharlie['to']), "transactionIndex": str(hex(0)), "value": str(hex(commit_tx_objectCharlie['value'])), "v": str(hex(commit_tx_objectCharlie['v'])), "r": str(hex(commit_tx_objectCharlie['r'])), "s": str(hex(commit_tx_objectCharlie['s'])) }, ) commit_proof_blobCharlie = proveth.generate_proof_blob( proveth_expected_block_format_dictCharlie, commit_block_indexCharlie) _unlockExtraData = b'' # In this example we dont have any extra embedded data as part of the unlock TX unlock_tx_unsigned_objectCharlie = transactions.UnsignedTransaction( int.from_bytes(unlock_tx_infoCharlie[0], byteorder="big"), # nonce; int.from_bytes(unlock_tx_infoCharlie[1], byteorder="big"), # gasprice int.from_bytes(unlock_tx_infoCharlie[2], byteorder="big"), # startgas unlock_tx_infoCharlie[3], # to addr int.from_bytes(unlock_tx_infoCharlie[4], byteorder="big"), # value unlock_tx_infoCharlie[5], # data ) unlock_tx_unsigned_rlpCharlie = rlp.encode( unlock_tx_unsigned_objectCharlie, transactions.UnsignedTransaction) self.verifier_contract.revealBid( commit_block_numberCharlie, # uint32 _commitBlockNumber, _unlockExtraData, # bytes _commitData, rec_bin(witnessCharlie), # bytes32 _witness, unlock_tx_unsigned_rlpCharlie, # bytes _rlpUnlockTxUnsigned, commit_proof_blobCharlie, # bytes _proofBlob sender=CHARLIE_PRIVATE_KEY) reveal_gasCharlie = int(self.chain.head_state.gas_used) self.chain.mine(1) ## ## CHECK THE STATE AFTER REVEAL ## bidListLength = self.verifier_contract.getBidListLength() self.assertEqual( bidListLength, 3, "Number of bids should match the number of participants in the auction" ) bidListItemAlice = self.verifier_contract.BidList(0) self.assertListEqual( ["0x" + ALICE_ADDRESS.hex(), bytearray.fromhex(commitAlice)], bidListItemAlice) session_dataAlice = self.verifier_contract.getCommitState( rec_bin(commitAlice)) self.assertListEqual(session_dataAlice, [ BID_AMOUNT_Alice, SOLIDITY_NULL_INITIALVAL, commit_block_numberAlice, commit_block_indexAlice ]) finished_boolAlice = self.verifier_contract.finished( rec_bin(commitAlice)) self.assertFalse(finished_boolAlice) bidListItemBob = self.verifier_contract.BidList(1) self.assertListEqual( ["0x" + BOB_ADDRESS.hex(), bytearray.fromhex(commitBob)], bidListItemBob) session_dataBob = self.verifier_contract.getCommitState( rec_bin(commitBob)) self.assertListEqual(session_dataBob, [ BID_AMOUNT_Bob, SOLIDITY_NULL_INITIALVAL, commit_block_numberBob, commit_block_indexBob ]) finished_boolBob = self.verifier_contract.finished(rec_bin(commitBob)) self.assertFalse(finished_boolBob) bidListItemCharlie = self.verifier_contract.BidList(2) self.assertListEqual( ["0x" + CHARLIE_ADDRESS.hex(), bytearray.fromhex(commitCharlie)], bidListItemCharlie) session_dataCharlie = self.verifier_contract.getCommitState( rec_bin(commitCharlie)) self.assertListEqual(session_dataCharlie, [ BID_AMOUNT_Charlie, SOLIDITY_NULL_INITIALVAL, commit_block_numberCharlie, commit_block_indexCharlie ]) finished_boolCharlie = self.verifier_contract.finished( rec_bin(commitCharlie)) self.assertFalse(finished_boolCharlie) ## ## BROADCAST UNLOCK ## self.chain.mine(1) self.chain.direct_tx(unlock_tx_objectAlice) unlock_gasAlice = int(self.chain.head_state.gas_used) self.chain.mine(1) self.chain.mine(1) self.chain.direct_tx(unlock_tx_objectBob) unlock_gasBob = int(self.chain.head_state.gas_used) self.chain.mine(1) self.chain.mine(1) self.chain.direct_tx(unlock_tx_objectCharlie) unlock_gasCharlie = int(self.chain.head_state.gas_used) self.chain.mine(1) ## ## CHECK STATE AFTER UNLOCK ## # stuff to help with debugging # unlock_block_numberAlice, unlock_block_indexAlice = self.chain.chain.get_tx_position( # unlock_tx_objectAlice) # unlock_block_objectAlice = self.chain.chain.get_block_by_number(unlock_block_numberAlice) # print(unlock_block_objectAlice.as_dict()) self.assertEqual( self.chain.head_state.get_balance(commitAddressAlice), (extraTransactionFees - unlock_gasAlice * OURGASPRICE), "Commit address should send along the money and have almost 0 money left." ) self.assertEqual( self.chain.head_state.get_balance(commitAddressBob), (extraTransactionFees - unlock_gasBob * OURGASPRICE), "Commit address should send along the money and have almost 0 money left." ) self.assertEqual( self.chain.head_state.get_balance(commitAddressCharlie), (extraTransactionFees - unlock_gasCharlie * OURGASPRICE), "Commit address should send along the money and have almost 0 money left." ) self.assertEqual( self.chain.head_state.get_balance(self.verifier_contract.address), (BID_AMOUNT_Alice + BID_AMOUNT_Bob + BID_AMOUNT_Charlie), "Contract address should have the sum of the bids balance.") session_dataAlice = self.verifier_contract.getCommitState( rec_bin(commitAlice)) self.assertListEqual(session_dataAlice, [ BID_AMOUNT_Alice, BID_AMOUNT_Alice, commit_block_numberAlice, commit_block_indexAlice ]) finished_boolAlice = self.verifier_contract.finished( rec_bin(commitAlice)) self.assertTrue(finished_boolAlice) session_dataBob = self.verifier_contract.getCommitState( rec_bin(commitBob)) self.assertListEqual(session_dataBob, [ BID_AMOUNT_Bob, BID_AMOUNT_Bob, commit_block_numberBob, commit_block_indexBob ]) finished_boolBob = self.verifier_contract.finished(rec_bin(commitBob)) self.assertTrue(finished_boolBob) session_dataCharlie = self.verifier_contract.getCommitState( rec_bin(commitCharlie)) self.assertListEqual(session_dataCharlie, [ BID_AMOUNT_Charlie, BID_AMOUNT_Charlie, commit_block_numberCharlie, commit_block_indexCharlie ]) finished_boolCharlie = self.verifier_contract.finished( rec_bin(commitCharlie)) self.assertTrue(finished_boolCharlie) self.assertFalse(self.verifier_contract.auctionIsOver()) ## ## END AUCTION ## self.chain.mine(REVEAL_PERIOD_LENGTH) self.verifier_contract.endauction(sender=RANDO_ADDRESS_PRIVATE_KEY) ## ## CHECK STATE NOW THAT AUCTION IS OVER self.assertTrue(self.verifier_contract.auctionIsOver()) self.assertEqual(rec_hex(CHARLIE_ADDRESS), self.verifier_contract.dogieOwner()) self.assertEqual( ACCOUNT_STARTING_BALANCE - (extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(ALICE_ADDRESS))) self.assertEqual( ACCOUNT_STARTING_BALANCE - (extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(BOB_ADDRESS))) self.assertEqual( ACCOUNT_STARTING_BALANCE - (BID_AMOUNT_Charlie + extraTransactionFees + BASIC_SEND_GAS_LIMIT * OURGASPRICE), self.chain.head_state.get_balance(rec_hex(CHARLIE_ADDRESS))) self.assertEqual( starting_owner_eth_holdings + BID_AMOUNT_Charlie, self.chain.head_state.get_balance(rec_hex(CONTRACT_OWNER_ADDRESS)))
def main(): ''' Main method. Runs the program if it is used standalone (rather than as an exported library). ''' parser = _get_args() if len(parser.target_address) != 42: log.error( "Target Address length does not appear to match the correct length of an Ethereum address" ) sys.exit(1) if len(parser.from_address) != 42: log.error( "From Address length does not appear to match the correct length of an Ethereum address" ) sys.exit(1) if parser.target_address[0:2] != "0x": log.error( "Target address not in expected format, expected address to start with 0x" ) sys.exit(1) if parser.from_address[0:2] != "0x": log.error( "From address not in expected format, expected address to start with 0x" ) sys.exit(1) if not check_checksum(parser.target_address): log.error( "Target address is not correctly encoded using EIP-55 {}".format( parser.target_address)) sys.exit(1) if not check_checksum(parser.from_address): log.error( "From address is not correctly encoded using EIP-55 {}".format( parser.from_address)) sys.exit(1) toAddress = normalize_address(parser.target_address) fromAddress = normalize_address(parser.from_address) gasPrice = parser.gas_price gasLimit = parser.gas_limit sendAmount = parser.amount if (parser.dapp_data): dappData = rec_bin(parser.dapp_data) else: dappData = b"" tx, addressB, commit, randw = _generateAddressBInternal( fromAddress, toAddress, sendAmount, dappData, gasPrice, gasLimit) # print("-"* 35) # printRemix(fromAddress, tx, encode_hex(randw)) print("-" * 35) print("AddressB: {}".format(addressB) ) # addressB also can retrieved using tx.to_dict().get("sender") print("commit: {}".format(encode_hex(commit))) print("witness (w): {}".format(encode_hex(randw))) # print("Reveal Transation (json): {}".format(tx.to_dict())) print("Reveal Transaction (hex): {}".format(encode_hex(rlp.encode(tx)))) print( "You can use the reveal transaction hex to broadcast with any service you like, e.g.: https://ropsten.etherscan.io/pushTx" )