def create_utxo(self, to_contractaddress, provide_amount): utxos = self.get_utxos() for blknum, txindex, oindex, contractaddress, amount, tokenid in utxos: if contractaddress.lower() == to_contractaddress[2:].lower(): if amount == provide_amount: return blknum, txindex, oindex, contractaddress, amount, tokenid for blknum, txindex, oindex, contractaddress, amount, tokenid in utxos: if contractaddress.lower() == to_contractaddress[2:].lower(): if amount > provide_amount: tx = Transaction(blknum, txindex, oindex, 0, 0, 0, utils.normalize_address(self.address), utils.normalize_address(contractaddress), provide_amount, 0, utils.normalize_address(self.address), utils.normalize_address(contractaddress), amount - provide_amount, 0) tx.sign1( utils.normalize_key(plasma_config["AUTHORITY_KEY"])) tx.sign2( utils.normalize_key(plasma_config["AUTHORITY_KEY"])) self.child_chain.apply_transaction( rlp.encode(tx, Transaction).hex()) break else: raise ValueError("no available utxo") utxos = self.get_utxos() for blknum, txindex, oindex, contractaddress, amount, tokenid in utxos: if contractaddress.lower() == to_contractaddress[2:].lower(): if amount == provide_amount: return blknum, txindex, oindex, contractaddress, amount, tokenid raise Exception("Something went wrong")
def test_transaction(t): blknum1, txindex1, oindex1 = 1, 1, 0 blknum2, txindex2, oindex2 = 2, 2, 1 newowner1, amount1 = t.a1, 100 newowner2, amount2 = t.a2, 150 fee = 5 oldowner1, oldowner2 = t.a1, t.a2 key1, key2 = t.k1, t.k2 tx = Transaction(blknum1, txindex1, oindex1, blknum2, txindex2, oindex2, newowner1, amount1, newowner2, amount2, fee) assert tx.blknum1 == blknum1 assert tx.txindex1 == txindex1 assert tx.oindex1 == oindex1 assert tx.blknum2 == blknum2 assert txindex2 == txindex2 assert tx.oindex2 == oindex2 assert tx.newowner1 == newowner1 assert tx.amount1 == amount1 assert tx.newowner2 == newowner2 assert tx.amount2 == amount2 assert tx.sig1 == b'\x00' * 65 assert tx.sig2 == b'\x00' * 65 tx.sign1(key1) assert tx.sender1 == oldowner1 tx.sign2(key2) assert tx.sender2 == oldowner2
def test_start_exit(t, root_chain, assert_tx_failed): week_and_a_half = 60 * 60 * 24 * 13 owner, value_1, key = t.a1, 100, t.k1 null_address = b'\x00' * 20 tx1 = Transaction(0, 0, 0, 0, 0, 0, owner, value_1, null_address, 0, 0) tx_bytes1 = rlp.encode(tx1, UnsignedTransaction) root_chain.deposit(tx_bytes1, value=value_1) merkle = FixedMerkle(16, [tx1.merkle_hash], True) proof = merkle.create_membership_proof(tx1.merkle_hash) confirmSig1 = confirm_tx(tx1, root_chain.getChildChain(1)[0], key) priority1 = 1 * 1000000000 + 10000 * 0 + 0 snapshot = t.chain.snapshot() sigs = tx1.sig1 + tx1.sig2 + confirmSig1 # Deposit exit root_chain.startExit([1, 0, 0], tx_bytes1, proof, sigs, sender=key) t.chain.head_state.timestamp += week_and_a_half # Cannot exit twice off of the same utxo assert_tx_failed(lambda: root_chain.startExit( [1, 0, 0], tx_bytes1, proof, sigs, sender=key)) assert root_chain.getExit(priority1) == [ '0x' + owner.hex(), 100, [1, 0, 0] ] t.chain.revert(snapshot) tx2 = Transaction(1, 0, 0, 0, 0, 0, owner, value_1, null_address, 0, 0) tx2.sign1(key) tx_bytes2 = rlp.encode(tx2, UnsignedTransaction) merkle = FixedMerkle(16, [tx2.merkle_hash], True) proof = merkle.create_membership_proof(tx2.merkle_hash) t.chain.head_state.block_number += 7 root_chain.submitBlock(merkle.root) confirmSig1 = confirm_tx(tx2, root_chain.getChildChain(2)[0], key) priority2 = 2 * 1000000000 + 10000 * 0 + 0 sigs = tx2.sig1 + tx2.sig2 + confirmSig1 snapshot = t.chain.snapshot() # Single input exit root_chain.startExit([2, 0, 0], tx_bytes2, proof, sigs, sender=key) assert root_chain.getExit(priority2) == [ '0x' + owner.hex(), 100, [2, 0, 0] ] t.chain.revert(snapshot) root_chain.deposit(tx_bytes1, value=value_1) tx3 = Transaction(2, 0, 0, 3, 0, 0, owner, value_1, null_address, 0, 0) tx3.sign1(key) tx3.sign2(key) tx_bytes3 = rlp.encode(tx3, UnsignedTransaction) merkle = FixedMerkle(16, [tx3.merkle_hash], True) proof = merkle.create_membership_proof(tx3.merkle_hash) t.chain.head_state.block_number += 7 root_chain.submitBlock(merkle.root) confirmSig1 = confirm_tx(tx3, root_chain.getChildChain(4)[0], key) confirmSig2 = confirm_tx(tx3, root_chain.getChildChain(4)[0], key) priority3 = 4 * 1000000000 + 10000 * 0 + 0 sigs = tx3.sig1 + tx3.sig2 + confirmSig1 + confirmSig2 # Double input exit root_chain.startExit([4, 0, 0], tx_bytes3, proof, sigs, sender=key) assert root_chain.getExit(priority3) == [ '0x' + owner.hex(), 100, [4, 0, 0] ]
def sendtx(client, blknum1, txindex1, oindex1, blknum2, txindex2, oindex2, newowner1, contractaddress1, amount1, tokenid1, newowner2, contractaddress2, amount2, tokenid2, key1, key2): if newowner1 == "0x0": newowner1 = NULL_ADDRESS if newowner2 == "0x0": newowner2 = NULL_ADDRESS if contractaddress1 == "0x0": contractaddress1 = NULL_ADDRESS if contractaddress2 == "0x0": contractaddress2 = NULL_ADDRESS if key2 is None: key2 = key1 # Form a transaction tx = Transaction(blknum1, txindex1, oindex1, blknum2, txindex2, oindex2, utils.normalize_address(newowner1), utils.normalize_address(contractaddress1), amount1, tokenid1, utils.normalize_address(newowner2), utils.normalize_address(contractaddress2), amount2, tokenid2) # Sign it tx.sign1(utils.normalize_key(key1)) tx.sign2(utils.normalize_key(key2)) client.apply_transaction(tx) print("Sent transaction")
def test_send_tx_with_sig(child_chain): tx3 = Transaction(1, 0, 0, 1, 1, 0, newowner1, amount2, b'\x00' * 20, 0, 0) # Sign the transaction tx3.sign1(tx_key) tx3.sign2(tx_key) child_chain.apply_transaction(rlp.encode(tx3).hex())
def test_send_tx_invalid_sig(child_chain): tx3 = Transaction(1, 0, 0, 1, 1, 0, newowner1, amount2, b'\x00' * 20, 0, 0) # Sign with an invalid key tx3.sign1(invalid_tx_key) tx3.sign2(invalid_tx_key) with pytest.raises(InvalidTxSignatureException): child_chain.apply_transaction(rlp.encode(tx3).hex())
def test_send_tx_with_sig(child_chain): # Valid key key = b'8b76243a95f959bf101248474e6bdacdedc8ad995d287c24616a41bd51642965' newowner, amount2 = '0x4b3ec6c9dc67079e82152d6d55d8dd96a8e6aa26', 400 tx3 = Transaction(1, 0, 0, 1, 1, 0, newowner, amount2, b'\x00' * 20, 0, 0) # Sign the transaction tx3.sign1(key) tx3.sign2(key) child_chain.apply_transaction(rlp.encode(tx3).hex())
def test_send_tx_double_spend(child_chain): tx3 = Transaction(1, 0, 0, 1, 1, 0, newowner1, amount2, b'\x00' * 20, 0, 0) tx3.sign1(tx_key) tx3.sign2(tx_key) # Submit once child_chain.apply_transaction(rlp.encode(tx3).hex()) # Try to submit again with pytest.raises(TxAlreadySpentException): child_chain.apply_transaction(rlp.encode(tx3).hex())
def test_send_tx_double_spend(child_chain, u): tx3 = Transaction(1, 0, 0, 1, 1, 0, newowner1, amount2, b'\x00' * 20, 0, 0) tx3.sign1(key1) tx3.sign2(key1) # Submit once child_chain.apply_transaction(rlp.encode(tx3).hex()) # Try to submit again with pytest.raises(AssertionError): child_chain.apply_transaction(rlp.encode(tx3).hex())
def test_send_tx_invalid_sig(child_chain): # Invalid key key = b'8a76243a95f959bf101248474e6bdacdedc8ad995d287c24616a41bd51642965' newowner, amount2 = '0x4b3ec6c9dc67079e82152d6d55d8dd96a8e6aa26', 400 tx3 = Transaction(1, 0, 0, 1, 1, 0, newowner, amount2, b'\x00' * 20, 0, 0) # Sign with an invalid key tx3.sign1(key) tx3.sign2(key) with pytest.raises(AssertionError): child_chain.apply_transaction(rlp.encode(tx3).hex())
def transfer(self, input1, oindex1, newowner1, amount1, signatory1, input2=None, oindex2=0, newowner2=None, amount2=None, signatory2=None): newowner_address1 = newowner1['address'] amount1 = int(amount1) newowner_address2 = NULL_ADDRESS if newowner2 is not None: newowner_address2 = newowner2['address'] amount2 = int(amount2) if amount2 is not None else 0 encoded_input_tx1 = rlp.encode(self.transactions[input1]['tx']).hex() blknum1, txindex1 = self.child_chain.get_tx_pos(encoded_input_tx1) blknum2, txindex2 = 0, 0 if input2 is not None: encoded_input_tx2 = rlp.encode( self.transactions[input2]['tx']).hex() blknum2, txindex2 = self.child_chain.get_tx_pos(encoded_input_tx2) tx = Transaction(blknum1, txindex1, oindex1, blknum2, txindex2, oindex2, newowner_address1, amount1, newowner_address2, amount2) if signatory1 is not None: key1 = signatory1['key'] tx.sign1(key1) if signatory2 is not None: key2 = signatory2['key'] tx.sign2(key2) encoded_tx = rlp.encode(tx).hex() self.child_chain.apply_transaction(encoded_tx) self.transactions.append({ 'tx': tx, 'confirm_sigs': b'', 'is_deposit': False }) return len(self.transactions) - 1
def test_send_tx_double_spend(child_chain): key = b'8b76243a95f959bf101248474e6bdacdedc8ad995d287c24616a41bd51642965' newowner, amount2 = '0x4b3ec6c9dc67079e82152d6d55d8dd96a8e6aa26', 400 tx3 = Transaction(1, 0, 0, 1, 1, 0, newowner, amount2, b'\x00' * 20, 0, 0) tx3.sign1(key) tx3.sign2(key) # Submit once child_chain.apply_transaction(rlp.encode(tx3).hex()) # Try to submit again with pytest.raises(AssertionError): child_chain.apply_transaction(rlp.encode(tx3).hex())
def sendtx(client, blknum1, txindex1, oindex1, blknum2, txindex2, oindex2, amount1, newowner1, amount2, newowner2, fee, key1, key2): if newowner1 == "0x0": newowner1 = NULL_ADDRESS if newowner2 == "0x0": newowner2 = NULL_ADDRESS # Form a transaction tx = Transaction(blknum1, txindex1, oindex1, blknum2, txindex2, oindex2, utils.normalize_address(newowner1), amount1, utils.normalize_address(newowner2), amount2, fee) # Sign it if key1: tx.sign1(utils.normalize_key(key1)) if key2: tx.sign2(utils.normalize_key(key2)) client_call(client.apply_transaction, [tx], "Sent transaction")
def send_tx(self): if len(self.inp) != 14 and len(self.inp) != 13: raise Exception( "Wrong number of inputs for sending a transaction!") blknum1, tx_pos1, utxo_pos1 = int(self.inp[1]), int(self.inp[2]), int( self.inp[3]) blknum2, tx_pos2, utxo_pos2 = int(self.inp[4]), int(self.inp[5]), int( self.inp[6]) newowner1 = utils.normalize_address(self.inp[7]) amount1 = int(self.inp[8]) newowner2 = utils.normalize_address(self.inp[9]) amount2 = int(self.inp[10]) fee = int(self.inp[11]) key1 = utils.normalize_key(self.inp[12]) key2 = utils.normalize_key(self.inp[13]) if len( self.inp) == 14 else b'' tx = Transaction(blknum1, tx_pos1, utxo_pos1, blknum2, tx_pos2, utxo_pos2, newowner1, amount1, newowner2, amount2, fee) tx.sign1(key1) if key2: tx.sign2(key2) self.client.apply_transaction(tx) print("Succesfully added transaction!")
def test_start_exit(t, root_chain, assert_tx_failed): week_and_a_half = 60 * 60 * 24 * 13 owner, value_1, key = t.a1, 100, t.k1 null_address = b'\x00' * 20 tx1 = Transaction(0, 0, 0, 0, 0, 0, null_address, owner, value_1, null_address, 0) deposit_tx_hash = get_deposit_hash(owner, null_address, value_1) dep_blknum = root_chain.getDepositBlock() assert dep_blknum == 1 root_chain.deposit(value=value_1, sender=key) merkle = FixedMerkle(16, [deposit_tx_hash], True) proof = merkle.create_membership_proof(deposit_tx_hash) confirmSig1 = confirm_tx(tx1, root_chain.getChildChain(dep_blknum)[0], key) priority1 = dep_blknum * 1000000000 + 10000 * 0 + 1 snapshot = t.chain.snapshot() sigs = tx1.sig1 + tx1.sig2 + confirmSig1 utxoId = dep_blknum * 1000000000 + 10000 * 0 + 1 # Deposit exit root_chain.startDepositExit(utxoId, null_address, tx1.amount1, sender=key) t.chain.head_state.timestamp += week_and_a_half # Cannot exit twice off of the same utxo utxo_pos1 = dep_blknum * 1000000000 + 10000 * 0 + 1 assert_tx_failed(lambda: root_chain.startExit( utxo_pos1, deposit_tx_hash, proof, sigs, sender=key)) enc_null_address = "0x" + "00" * 20 assert root_chain.getExit(priority1) == [ '0x' + owner.hex(), enc_null_address, 100 ] t.chain.revert(snapshot) tx2 = Transaction(dep_blknum, 0, 0, 0, 0, 0, null_address, owner, value_1, null_address, 0) tx2.sign1(key) tx_bytes2 = rlp.encode(tx2, UnsignedTransaction) merkle = FixedMerkle(16, [tx2.merkle_hash], True) proof = merkle.create_membership_proof(tx2.merkle_hash) child_blknum = root_chain.currentChildBlock() assert child_blknum == 1000 root_chain.submitBlock(merkle.root) confirmSig1 = confirm_tx(tx2, root_chain.getChildChain(child_blknum)[0], key) priority2 = child_blknum * 1000000000 + 10000 * 0 + 0 sigs = tx2.sig1 + tx2.sig2 + confirmSig1 snapshot = t.chain.snapshot() # # Single input exit utxo_pos2 = child_blknum * 1000000000 + 10000 * 0 + 0 root_chain.startExit(utxo_pos2, tx_bytes2, proof, sigs, sender=key) assert root_chain.getExit(priority2) == [ '0x' + owner.hex(), enc_null_address, 100 ] t.chain.revert(snapshot) dep2_blknum = root_chain.getDepositBlock() assert dep2_blknum == 1001 root_chain.deposit(value=value_1, sender=key) tx3 = Transaction(child_blknum, 0, 0, dep2_blknum, 0, 0, null_address, owner, value_1, null_address, 0, 0) tx3.sign1(key) tx3.sign2(key) tx_bytes3 = rlp.encode(tx3, UnsignedTransaction) merkle = FixedMerkle(16, [tx3.merkle_hash], True) proof = merkle.create_membership_proof(tx3.merkle_hash) child2_blknum = root_chain.currentChildBlock() assert child2_blknum == 2000 root_chain.submitBlock(merkle.root) confirmSig1 = confirm_tx(tx3, root_chain.getChildChain(child2_blknum)[0], key) confirmSig2 = confirm_tx(tx3, root_chain.getChildChain(child2_blknum)[0], key) priority3 = child2_blknum * 1000000000 + 10000 * 0 + 0 sigs = tx3.sig1 + tx3.sig2 + confirmSig1 + confirmSig2 # Double input exit utxoPos3 = child2_blknum * 1000000000 + 10000 * 0 + 0 root_chain.startExit(utxoPos3, tx_bytes3, proof, sigs, sender=key) assert root_chain.getExit(priority3) == [ '0x' + owner.hex(), enc_null_address, 100 ]