def post(self):
try:
App = _eth_worker.App
parser = reqparse.RequestParser()
parser.add_argument('account', type=str)
args = parser.parse_args()
# do something this values
_accounts = App.services.accounts.accounts
account_index = ENUMS[args['account']]
account_info = _accounts[account_index]
block_head = App.services.chain.chain.head
state = State(block_head.state_root, App.services.chain.chain.env)
log.info(state.get_balance(account_info.address))
balance_amount = int(
state.get_balance(account_info.address) / 10**22)
# TODO: account info parsing
return {
'status': 200,
'pubkey': account_info.pubkey[0],
'balance_amount': balance_amount
}
except Exception as e:
return {'error': str(e)}
def test_send_transaction_with_contract(test_app):
serpent_code = '''
def main(a,b):
return(a ^ b)
'''
tx_to = b''
evm_code = serpent.compile(serpent_code)
chainservice = test_app.services.chain
chain = test_app.services.chain.chain
state = State(chainservice.head_candidate.state_root, chain.env)
sender = test_app.services.accounts.unlocked_accounts[0].address
assert state.get_balance(sender) > 0
tx = {
'from': address_encoder(sender),
'to': address_encoder(tx_to),
'data': encode_hex(evm_code)
}
data_decoder(test_app.client.call('eth_sendTransaction', tx))
assert len(chainservice.head_candidate.transactions) == 1
creates = chainservice.head_candidate.transactions[0].creates
candidate_state_dict = State(chainservice.head_candidate.state_root,
chain.env).to_dict()
code = candidate_state_dict[encode_hex(creates)]['code']
assert len(code) > 2
assert code != '0x'
test_app.mine_next_block()
assert len(chain.head.transactions) == 1
creates = chain.head.transactions[0].creates
state_dict = State(chain.head.state_root, chain.env).to_dict()
code = state_dict[encode_hex(creates)]['code']
assert len(code) > 2
assert code != '0x'
def test_send_transaction_with_contract(test_app):
serpent_code = '''
def main(a,b):
return(a ^ b)
'''
tx_to = b''
evm_code = serpent.compile(serpent_code)
chain = test_app.services.chain.chain
chainservice = test_app.services.chain
hc_state = State(chainservice.head_candidate.state_root, chain.env)
sender = test_app.services.accounts.unlocked_accounts[0].address
assert hc_state.get_balance(sender) > 0
eth = test_app.services.console.console_locals['eth']
tx = eth.transact(to='', data=evm_code, startgas=500000, sender=sender)
hc_state_dict = State(chainservice.head_candidate.state_root,
chain.env).to_dict()
code = hc_state_dict[encode_hex(tx.creates)]['code']
assert len(code) > 2
assert code != '0x'
test_app.mine_next_block()
creates = chain.head.transactions[0].creates
code = chain.state.to_dict()[encode_hex(creates)]['code']
assert len(code) > 2
assert code != '0x'
def test_genesis_config():
"test setting genesis alloc using the config"
alloc = {
'1' * 40: {
'wei': 1
}, # wei
'2' * 40: {
'balance': 2
}, # balance
'3' * 20: {
'balance': 3
}, # 20 bytes
}
config = dict(eth=dict(genesis=dict(alloc=alloc)))
konfig.update_config_with_defaults(config,
{'eth': {
'block': default_config
}})
# Load genesis config
update_config_from_genesis_json(config, config['eth']['genesis'])
bc = config['eth']['block']
pprint(bc)
env = Env(DB(), bc)
genesis = mk_genesis_block(env)
state = State(genesis.state_root, env)
for address, value_dict in list(alloc.items()):
value = list(value_dict.values())[0]
assert state.get_balance(address) == value
def test_console_name_reg_contract(test_app, solidity_code):
"""
exercise the console service with the NameReg contract found in The_Console wiki
https://github.com/ethereum/pyethapp/wiki/The_Console#creating-contracts
"""
import ethereum.tools._solidity
solidity = ethereum.tools._solidity.get_solidity()
if solidity is None:
pytest.xfail("solidity not installed, not tested")
else:
# create the NameReg contract
tx_to = b''
evm_code = solidity.compile(solidity_code)
chainservice = test_app.services.chain
chain = test_app.services.chain.chain
hc_state = State(chainservice.head_candidate.state_root, chain.env)
sender = test_app.services.accounts.unlocked_accounts[0].address
assert hc_state.get_balance(sender) > 0
eth = test_app.services.console.console_locals['eth']
tx = eth.transact(to='', data=evm_code, startgas=500000, sender=sender)
hc_state_dict = State(chainservice.head_candidate.state_root,
chain.env).to_dict()
code = hc_state_dict[encode_hex(tx.creates)]['code']
assert len(code) > 2
assert code != '0x'
test_app.mine_next_block()
creates = chain.head.transactions[0].creates
state_dict = chain.state.to_dict()
code = state_dict[encode_hex(creates)]['code']
assert len(code) > 2
assert code != '0x'
# interact with the NameReg contract
abi = solidity.mk_full_signature(solidity_code)
namereg = eth.new_contract(abi, creates, sender=sender)
register_tx = namereg.register('alice',
startgas=90000,
gasprice=50 * 10**9)
test_app.mine_next_block()
result = namereg.resolve(sender)
assert result == b'alice' + ('\x00' * 27).encode()
def test_send_transaction(test_app):
chainservice = test_app.services.chain
chain = chainservice.chain
hc = chainservice.head_candidate
state = State(hc.state_root, chain.env)
assert state.get_balance(b'\xff' * 20) == 0
sender = test_app.services.accounts.unlocked_accounts[0].address
assert state.get_balance(sender) > 0
tx = {
'from': address_encoder(sender),
'to': address_encoder(b'\xff' * 20),
'value': quantity_encoder(1)
}
tx_hash = data_decoder(test_app.client.call('eth_sendTransaction', tx))
test_app.mine_next_block()
assert len(chain.head.transactions) == 1
assert tx_hash == chain.head.transactions[0].hash
assert chain.state.get_balance(b'\xff' * 20) == 1
# send transactions from account which can't pay gas
tx['from'] = address_encoder(
test_app.services.accounts.unlocked_accounts[1].address)
tx_hash = data_decoder(test_app.client.call('eth_sendTransaction', tx))
assert chainservice.head_candidate.transactions == []
def send_transaction(app, sender_id, receiver_id,value):
chain = app.services.chain.chain
chainservice = app.services.chain
hc_state = State(chainservice.head_candidate.state_root, chain.env)
sender = app.services.accounts.unlocked_accounts[sender_id].address
receiver = app.services.accounts.unlocked_accounts[receiver_id].address
print sender
print type(sender)
assert hc_state.get_balance(sender) > 0
eth = app.services.console.console_locals['eth']
tx = eth.transact(to=receiver, value=value, startgas=500000, sender=sender)
return tx
def test_send_raw_transaction_with_contract(test_app):
serpent_code = '''
def main(a,b):
return(a ^ b)
'''
tx_to = b''
evm_code = serpent.compile(serpent_code)
chainservice = test_app.services.chain
chain = test_app.services.chain.chain
state = State(chainservice.head_candidate.state_root, chain.env)
sender = test_app.services.accounts.unlocked_accounts[0].address
assert state.get_balance(sender) > 0
nonce = state.get_nonce(sender)
tx = ethereum.transactions.Transaction(nonce, default_gasprice,
default_startgas, tx_to, 0,
evm_code, 0, 0, 0)
test_app.services.accounts.sign_tx(sender, tx)
raw_transaction = data_encoder(
rlp.codec.encode(tx, ethereum.transactions.Transaction))
data_decoder(
test_app.client.call('eth_sendRawTransaction', raw_transaction))
assert len(chainservice.head_candidate.transactions) == 1
creates = chainservice.head_candidate.transactions[0].creates
candidate_state_dict = State(chainservice.head_candidate.state_root,
chain.env).to_dict()
code = candidate_state_dict[encode_hex(creates)]['code']
assert len(code) > 2
assert code != '0x'
test_app.mine_next_block()
assert len(chain.head.transactions) == 1
creates = chain.head.transactions[0].creates
state_dict = State(chain.head.state_root, chain.env).to_dict()
code = state_dict[encode_hex(creates)]['code']
assert len(code) > 2
assert code != '0x'
def test_send_transaction_with_contract(test_app, serpent_code, sender_id,
receiver_id):
evm_code = serpent.compile(serpent_code)
chain = test_app.services.chain.chain
chainservice = test_app.services.chain
hc_state = State(chainservice.head_candidate.state_root, chain.env)
sender = test_app.services.accounts.unlocked_accounts[sender_id].address
receiver = test_app.services.accounts.unlocked_accounts[
receiver_id].address
print sender
print type(sender)
assert hc_state.get_balance(sender) > 0
eth = test_app.services.console.console_locals['eth']
tx = eth.transact(to=receiver,
value=1,
data=evm_code,
startgas=500000,
sender=sender)
test_app.mine_next_block()
return tx
block_head = test.services.chain.chain.head
log.info(block_head.header)
value = test.config['node']['id'].encode('hex')
# read_blocks = read_blocks_thread(test)
# time.sleep(2)
# test_receive_newblock(test)
# # Make contract code
serpent_code = '''
def main(a,b):
return(a ^ b)
'''
state = State(block_head.state_root, test.services.chain.chain.env)
log.info('Andy accounts\' coin amount: ' +
str(state.get_balance(accounts_list[Andy].address)))
# Make transaction with contract, sender of transaction is 'Andy', receiver is 'Choi'
tx = test_send_transaction_with_contract(test,
serpent_code,
sender_id=Andy,
receiver_id=Choi)
log.info(tx.__dict__)
log.info(tx.sender.encode('hex'))
# Check latest block, Not mining yet
block_head = test.services.chain.chain.head
state = State(block_head.state_root, test.services.chain.chain.env)
log.info('Andy accounts\' coin amount: ' +
str(state.get_balance(accounts_list[Andy].address)))
# proto.send_packet(test.services.chain.chain.head)
def test_console_name_reg_contract(test_app):
solidity_code = """
contract NameReg {
event AddressRegistered(bytes32 indexed name, address indexed account);
mapping (address => bytes32) toName;
function register(bytes32 name) {
toName[msg.sender] = name;
AddressRegistered(name, msg.sender);
}
function resolve(address addr) constant returns (bytes32 name) {
return toName[addr];
}
}
"""
import ethereum.tools._solidity
solidity = ethereum.tools._solidity.get_solidity()
if solidity is None:
pytest.xfail("solidity not installed, not tested")
else:
# create the NameReg contract
tx_to = b''
evm_code = solidity.compile(solidity_code)
chainservice = test_app.services.chain
chain = test_app.services.chain.chain
hc_state = State(chainservice.head_candidate.state_root, chain.env)
sender = test_app.services.accounts.unlocked_accounts[0].address
assert hc_state.get_balance(sender) > 0
eth = test_app.services.console.console_locals['eth']
tx = eth.transact(to='', data=evm_code, startgas=500000, sender=sender)
hc_state_dict = State(chainservice.head_candidate.state_root,
chain.env).to_dict()
code = hc_state_dict[encode_hex(tx.creates)]['code']
assert len(code) > 2
assert code != '0x'
test_app.mine_next_block()
creates = chain.head.transactions[0].creates
state_dict = chain.state.to_dict()
code = state_dict[encode_hex(creates)]['code']
assert len(code) > 2
assert code != '0x'
# interact with the NameReg contract
abi = solidity.mk_full_signature(solidity_code)
namereg = eth.new_contract(abi, creates, sender=sender)
register_tx = namereg.register('alice',
startgas=90000,
gasprice=50 * 10**9)
test_app.mine_next_block()
result = namereg.resolve(sender)
assert result == b'alice' + ('\x00' * 27).encode()
