def get_unsigned_contract_create(owner_id, contract, external_api, internal_api):
bytecode = read_id_contract(internal_api)
call_input = ContractCallInput("sophia",
bytecode,
contract["function"],
contract["argument"])
print("Call input:", call_input)
result = internal_api.encode_calldata(call_input)
call_data = result.calldata
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=call_data)
tx_obj = internal_api.post_contract_create(contract_create_tx_obj)
return (tx_obj.tx, tx_obj.contract_id)
def test_contract_on_chain_call_off_chain():
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)
common.ensure_transaction_posted(external_api, signed)
call_contract = test_settings["contract_call"]
call_input = ContractCallInput("sophia-address", encoded_contract_id,\
call_contract["data"]["function"],\
call_contract["data"]["argument"])
result = internal_api.call_contract(call_input)
assert_equals(common.hexstring_to_contract_bytearray('0x000000000000000000000000000000000000000000000000000000000000002a'),
result.out)
cleanup(node, root_dir)
def test_compile_and_call_id():
# Alice should be able to compile a sophia contract with an identity
# function into bytecode and call it.
test_settings = settings["test_compile_and_call_id"]
(root_dir, node, api) = setup_node(test_settings, "alice")
# Read a contract
currentFile = __file__
dirPath = os.path.dirname(currentFile)
contract_file = open(dirPath + "/identity.aes", "r")
contract_string = contract_file.read()
# Compile contract to bytecode
contract = Contract(contract_string, "")
compilation_result = api.compile_contract(contract)
assert_regexp_matches(compilation_result.bytecode, '0x.*')
# Call contract bytecode
call_input = ContractCallInput("sophia", compilation_result.bytecode,
"main", "42")
call_result = api.call_contract(call_input)
assert_regexp_matches(call_result.out, '0x.*')
# stop node
common.stop_node(node)
shutil.rmtree(root_dir)
def test_compile_and_call_id():
# Alice should be able to compile a sophia contract with an identity
# function into bytecode and call it.
test_settings = settings["test_compile_and_call_id"]
(root_dir, node, api) = setup_node(test_settings, "alice")
bytecode = read_id_contract(api)
# Call contract bytecode
call_input = ContractCallInput("sophia", bytecode, "main", "42")
call_result = api.call_contract(call_input)
assert_regexp_matches(call_result.out, '0x.*')
# stop node
common.stop_node(node)
shutil.rmtree(root_dir)
def test_encode_id_call():
# Alice should be able to encode a call to a function in
# a sophia contract.
test_settings = settings["test_encode_id_call"]
(root_dir, node, api) = setup_node(test_settings, "alice")
bytecode = '0x36600080376200002160005180805180516004146200002d57505b5060011951005b80590390f35b80905090565b602001517f6d61696e00000000000000000000000000000000000000000000000000000000146200005e576200001a565b60200151806200006e9062000027565b5960008152818162000081918091505090565b8152915050905090565b825180599081525060208401602084038393509350935050600082136200008b5780925050509056'
call_input = ContractCallInput("sophia", bytecode, "main", "42")
result = api.encode_calldata(call_input)
calldata = '0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000002a00000000000000000000000000000000000000000000000000000000000000046d61696e00000000000000000000000000000000000000000000000000000000'
assert_equals(result.calldata, calldata)
# stop node
common.stop_node(node)
shutil.rmtree(root_dir)
def test_contract_on_chain_call_off_chain():
test_settings = settings["test_contract_call"]
create_settings = settings["test_contract_create"]
beneficiary = common.setup_beneficiary()
(node, (root_dir, external_api,
top)) = setup_node_with_tokens(test_settings, beneficiary, "node")
internal_api = common.internal_api(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.base58_decode(encoded_tx)
signed = keys.sign_verify_encode_tx(unsigned_tx, private_key, public_key)
alice_balance0 = common.get_account_balance(external_api,
internal_api,
pub_key=alice_address).balance
tx_object = Tx(tx=signed)
external_api.post_transaction(tx_object)
top = external_api.get_top_block()
common.wait_until_height(external_api, top.height + 3)
call_contract = test_settings["contract_call"]
call_input = ContractCallInput("sophia-address", encoded_contract_id,\
call_contract["data"]["function"],\
call_contract["data"]["argument"])
result = internal_api.call_contract(call_input)
assert_equals(
'0x000000000000000000000000000000000000000000000000000000000000002a',
result.out)
cleanup(node, root_dir)
def test_id_call():
# Alice should be able to call the id function in
# an Id contract.
test_settings = settings["test_id_call"]
(root_dir, node, api) = setup_node(test_settings, "alice")
bytecode = '0x36600080376200002160008080805180516004146200003057505b5060011951005b60005260206000f35b80905090565b602001517f6d61696e000000000000000000000000000000000000000000000000000000001462000061576200001a565b602001519050809150506200002a56'
call_input = ContractCallInput(bytecode, "main", "42")
result = api.call_contract(call_input)
print(result)
retval = '0x000000000000000000000000000000000000000000000000000000000000002a'
assert_equals(result.out, retval)
# stop node
common.stop_node(node)
shutil.rmtree(root_dir)
def test_encode_id_call():
# Alice should be able to encode a call to a function in
# a ring contract.
test_settings = settings["test_encode_id_call"]
(root_dir, node, api) = setup_node(test_settings, "alice")
bytecode = '0x36600080376200002160008080805180516004146200003057505b5060011951005b60005260206000f35b80905090565b602001517f6d61696e000000000000000000000000000000000000000000000000000000001462000061576200001a565b602001519050809150506200002a56'
call_input = ContractCallInput(bytecode, "main", "42")
result = api.encode_calldata(call_input)
calldata = '0x0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000002a00000000000000000000000000000000000000000000000000000000000000046d61696e00000000000000000000000000000000000000000000000000000000'
assert_equals(result.calldata, calldata)
# stop node
common.stop_node(node)
shutil.rmtree(root_dir)
def test_id_call():
# Alice should be able to call the id function in
# an Id contract.
test_settings = settings["test_id_call"]
(root_dir, node, api) = setup_node(test_settings, "alice")
bytecode = '0x366000602037620000606200003460205180805180516004146200007b57505b80518051600414620000d857505b5060011951005b805903906000518059600081529081818162000056915b805081590391505090565b8352505060005250f35b8059039060008052f35b5990565b5080620001289080905090565b602001517f696e69740000000000000000000000000000000000000000000000000000000014620000ac576200001f565b50829150620000ba6200006a565b596000815290818181620000ce916200004b565b835250505b905090565b602001517f6d61696e000000000000000000000000000000000000000000000000000000001462000109576200002d565b6020015159506000516200006e90805180826200017291600091505090565b5960008152908181816200013d918091505090565b835250509050620000d3565b825180599081525060208401602084038393509350935050600082136200014957809250505090565b915050806000525959905090509056'
call_input = ContractCallInput("sophia", bytecode, "main", "42")
result = api.call_contract(call_input)
print(result)
retval = '0x000000000000000000000000000000000000000000000000000000000000002a'
assert_equals(result.out, retval)
# stop node
common.stop_node(node)
shutil.rmtree(root_dir)
def test_encode_id_call():
# Alice should be able to encode a call to a function in
# a sophia contract.
test_settings = settings["test_encode_id_call"]
(root_dir, node, api) = setup_node(test_settings, "alice")
bytecode = read_id_contract(api)
call_input = ContractCallInput("sophia", bytecode, "main", "42")
result = api.encode_calldata(call_input)
calldata = '0x0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000046d61696e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002a'
assert_equals(result.calldata, calldata)
# stop node
common.stop_node(node)
shutil.rmtree(root_dir)
def test_encode_id_call():
# Alice should be able to encode a call to a function in
# a sophia contract.
test_settings = settings["test_encode_id_call"]
(root_dir, node, external_api,
internal_api) = setup_node(test_settings, "alice")
bytecode = read_id_contract(internal_api)
call_input = ContractCallInput("sophia", bytecode, "main", "42")
result = internal_api.encode_calldata(call_input)
assert_regexp_matches(result.calldata, 'cb_.*')
# stop node
common.stop_node(node)
shutil.rmtree(root_dir)
def test_id_call():
# Alice should be able to call the id function in
# an Id contract.
test_settings = settings["test_id_call"]
(root_dir, node, api) = setup_node(test_settings, "alice")
bytecode = read_id_contract(api)
call_input = ContractCallInput("sophia", bytecode, "main", "42")
result = api.call_contract(call_input)
print(result)
retval = '0x000000000000000000000000000000000000000000000000000000000000002a'
assert_equals(result.out, retval)
# stop node
common.stop_node(node)
shutil.rmtree(root_dir)
def test_solidity_greeter():
# Alice should be able to initialize
# the gretee Solidity contract.
test_settings = settings["test_id_call"]
(root_dir, node, api) = setup_node(test_settings, "alice")
bytecode = greeter_code()
call_input = ContractCallInput("evm", bytecode, "", "0x00")
result = api.call_contract(call_input)
print(result)
generatedcode = greeter_generated_code()
assert_equals(result.out, generatedcode)
# stop node
common.stop_node(node)
shutil.rmtree(root_dir)
def test_call_solidity_greeter():
# Alice should be able to call the greet function in
# an greete Solidity contract.
test_settings = settings["test_id_call"]
(root_dir, node, api) = setup_node(test_settings, "alice")
bytecode = greeter_generated_code()
setGreeting = "0xa4136862"
HelloWorld = "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000d48656c6c6c6f20576f726c642100000000000000000000000000000000000000"
call_input = ContractCallInput("evm", bytecode, "",
setGreeting + HelloWorld)
result = api.call_contract(call_input)
print(result)
generatedcode = greeter_generated_code()
# assert_equals(result.out, generatedcode)
# stop node
common.stop_node(node)
shutil.rmtree(root_dir)
def test_contract_call():
test_settings = settings["test_contract_call"]
create_settings = settings["test_contract_create"]
(root_dir, node, external_api, top) = setup_node_with_tokens(test_settings, "node")
internal_api = common.internal_api(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("alice", test_settings, external_api, internal_api)
## create contract
encoded_tx, encoded_contract_address = get_unsigned_contract_create(alice_address, create_settings["create_contract"], external_api)
unsigned_tx = common.base58_decode(encoded_tx)
signed = keys.sign_verify_encode_tx(unsigned_tx, private_key, public_key)
alice_balance0 = common.get_account_balance(external_api, internal_api, pub_key=alice_address).balance
tx_object = Tx(tx=signed)
external_api.post_tx(tx_object)
top = external_api.get_top()
common.wait_until_height(external_api, top.height + 3)
alice_balance = common.get_account_balance(external_api, internal_api, pub_key=alice_address).balance
# 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"]["deposit"]
+ create_settings["create_contract"]["amount"])
call_input = ContractCallInput("sophia", create_settings["create_contract"]["code"],\
call_contract["data"]["function"],\
call_contract["data"]["argument"])
result = external_api.call_contract(call_input)
contract_call_obj = ContractCallData(
caller=test_settings["alice"]["pubkey"],
contract=encoded_contract_address,
vm_version=call_contract["vm_version"],
fee=call_contract["fee"],
ttl=100,
amount=call_contract["amount"],
gas=call_contract["gas"],
gas_price=call_contract["gas_price"],
call_data=result.out)
call_tx_obj = external_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.base58_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, internal_api, pub_key=alice_address).balance
tx_object = Tx(tx=signed_call)
external_api.post_tx(tx_object)
top = external_api.get_top()
common.wait_until_height(external_api, top.height + 3)
alice_balance = common.get_account_balance(external_api, internal_api, pub_key=alice_address).balance
# The call runs out of gas and all gas is consumed
# assert contract called:
assert_equals(alice_balance0, alice_balance
+ test_settings["contract_call"]["fee"]
+ test_settings["contract_call"]["gas"]
+ test_settings["contract_call"]["amount"])
print("Fee and gas was consumed, transaction is part of the chain")
cleanup(node, root_dir)
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"]["deposit"] +
create_settings["create_contract"]["amount"])
bytecode = read_id_contract(internal_api)
call_input = ContractCallInput("sophia-address", encoded_contract_id,
call_contract["data"]["function"],
call_contract["data"]["argument"])
result = internal_api.call_contract(call_input)
contract_call_obj = ContractCallTx(
caller_id=test_settings["alice"]["pubkey"],
contract_id=encoded_contract_id,
vm_version=call_contract["vm_version"],
fee=call_contract["fee"],
ttl=100,
amount=call_contract["amount"],
gas=call_contract["gas"],
gas_price=call_contract["gas_price"],
call_data=result.out)
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)
# The call runs out of gas and all gas is consumed
# assert contract called:
assert_equals(
alice_balance0, alice_balance + test_settings["contract_call"]["fee"] +
test_settings["contract_call"]["gas"])
print("Fee and gas was consumed, transaction is part of the chain")
cleanup(node, root_dir)
def test_contract_call():
test_settings = settings["test_contract_call"]
create_settings = settings["test_contract_create"]
(root_dir, node, external_api, top) = setup_node_with_tokens(test_settings, "node")
internal_api = common.internal_api(node)
send_tokens_to_user("alice", test_settings, internal_api, external_api)
## create contract
encoded_tx = get_unsigned_contract_create(test_settings["alice"]["pubkey"], create_settings["create_contract"], external_api)
unsigned_tx = common.base58_decode(encoded_tx)
unpacked_tx = common.unpack_tx(unsigned_tx)
signature = bytearray(list(map(int, create_settings["create_contract"]["signature"].split(","))))
signed = common.encode_signed_tx(unpacked_tx,[signature])
alice_balance0 = common.get_account_balance(internal_api, pub_key=test_settings["alice"]["pubkey"]).balance
tx_object = Tx(tx=signed)
external_api.post_tx(tx_object)
top = external_api.get_top()
common.wait_until_height(external_api, top.height + 3)
alice_balance = common.get_account_balance(internal_api, pub_key=test_settings["alice"]["pubkey"]).balance
# assert contract created:
call_contract = test_settings["contract_call"]
assert_equals(alice_balance0, alice_balance + create_settings["create_contract"]["fee"])
call_input = ContractCallInput("ring", create_settings["create_contract"]["code"],\
call_contract["data"]["function"],\
call_contract["data"]["argument"])
result = external_api.call_contract(call_input)
contract_call_obj = ContractCallData(
caller=test_settings["alice"]["pubkey"],
contract=call_contract["contract"],
vm_version=call_contract["vm_version"],
fee=call_contract["fee"],
amount=call_contract["amount"],
gas=call_contract["gas"],
gas_price=call_contract["gas_price"],
call_data=result.out)
call_tx_obj = external_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.base58_decode(encoded_call_tx)
unpacked_call_tx = common.unpack_tx(unsigned_call_tx)
tx = common.parse_tx(unpacked_call_tx)
print("Unsigned decoded transaction: " + str(tx))
signature = bytearray(list(map(int, test_settings["contract_call"]["signature"].split(","))))
signed = common.encode_signed_tx(unpacked_call_tx,[signature])
print("Signed transaction: " + signed)
alice_balance0 = common.get_account_balance(internal_api, pub_key=test_settings["alice"]["pubkey"]).balance
tx_object = Tx(tx=signed)
external_api.post_tx(tx_object)
top = external_api.get_top()
common.wait_until_height(external_api, top.height + 3)
alice_balance = common.get_account_balance(internal_api, pub_key=test_settings["alice"]["pubkey"]).balance
print("BALANCE0 " + str(alice_balance0))
print("BALANCE " + str(alice_balance))
# assert contract created:
assert_equals(alice_balance0, alice_balance + test_settings["contract_call"]["fee"])
cleanup(node, root_dir)
