def get_unsigned_contract_create(owner_id, contract, external_api,
internal_api):
bytecode = common.compile_contract(id_contract())
calldata = common.encode_calldata(id_contract(), contract["function"],
contract["argument"])
print("OWNERID", owner_id)
contract_create_tx_obj = ContractCreateTx(
owner_id=owner_id,
code=bytecode,
vm_version=contract["vm_version"],
abi_version=contract["abi_version"],
deposit=contract["deposit"],
amount=contract["amount"],
gas=contract["gas"],
gas_price=contract["gas_price"],
fee=contract["fee"],
ttl=100,
call_data=calldata)
tx_obj = internal_api.post_contract_create(contract_create_tx_obj)
return (tx_obj.tx, tx_obj.contract_id)
def test_contract_call():
test_settings = settings["test_contract_call"]
create_settings = settings["test_contract_create"]
beneficiary = common.setup_beneficiary()
(node, (root_dir, external_api, internal_api,
top)) = setup_node_with_tokens(test_settings, beneficiary, "node")
private_key = keys.new_private()
public_key = keys.public_key(private_key)
alice_address = keys.address(public_key)
test_settings["alice"]["pubkey"] = alice_address
send_tokens_to_user(beneficiary, "alice", test_settings, external_api,
internal_api)
## create contract
encoded_tx, encoded_contract_id = get_unsigned_contract_create(
alice_address, create_settings["create_contract"], external_api,
internal_api)
unsigned_tx = common.api_decode(encoded_tx)
signed = keys.sign_verify_encode_tx(unsigned_tx, private_key, public_key)
alice_balance0 = common.get_account_balance(external_api, alice_address)
common.ensure_transaction_posted(external_api, signed)
alice_balance = common.get_account_balance(external_api,
pub_key=alice_address)
# assert contract created:
call_contract = test_settings["contract_call"]
assert_equals(
alice_balance0,
alice_balance + create_settings["create_contract"]["fee"] +
create_settings["create_contract"]["gas_used"] *
create_settings["create_contract"]["gas_price"] +
create_settings["create_contract"]["deposit"] +
create_settings["create_contract"]["amount"])
bytecode = common.compile_contract(id_contract())
calldata = common.encode_calldata(id_contract(),
call_contract["data"]["function"],
call_contract["data"]["argument"])
contract_call_obj = ContractCallTx(
caller_id=test_settings["alice"]["pubkey"],
contract_id=encoded_contract_id,
abi_version=call_contract["abi_version"],
fee=call_contract["fee"],
ttl=100,
amount=call_contract["amount"],
gas=call_contract["gas"],
gas_price=call_contract["gas_price"],
call_data=calldata)
call_tx_obj = internal_api.post_contract_call(contract_call_obj)
encoded_call_tx = call_tx_obj.tx
print("Unsigned encoded transaction: " + encoded_call_tx)
unsigned_call_tx = common.api_decode(encoded_call_tx)
signed_call = keys.sign_verify_encode_tx(unsigned_call_tx, private_key,
public_key)
print("Signed transaction: " + signed_call)
alice_balance0 = common.get_account_balance(external_api, alice_address)
common.ensure_transaction_posted(external_api, signed_call)
alice_balance = common.get_account_balance(external_api, alice_address)
assert_equals(
alice_balance0, alice_balance + test_settings["contract_call"]["fee"] +
test_settings["contract_call"]["amount"] +
test_settings["contract_call"]["gas_used"] *
test_settings["contract_call"]["gas_price"])
print("Fee and gas was consumed, transaction is part of the chain")
cleanup(node, root_dir)
def test_encode_calldata():
bytecode = common.compile_contract(id_contract())
calldata = common.encode_calldata(id_contract(), "main", "42")
assert_regexp_matches(bytecode, 'cb_.*')
assert_regexp_matches(calldata, 'cb_.*')