def test_reveal_returns_entropy(self): assert self.c.commit(1, self.COW_HASH, value=self.DEPOSIT_COST) == [1] assert self.c.request_entropy(sender=tester.k1, value=self.ENTROPY_COST) == [0, 4] assert self.c.get_block(self.s.block.number + 1) == [0, 1, 0, 1] self.s.mine(2) COW_SEED = utils.big_endian_to_int( utils.sha3( utils.sha3(utils.zpad('cow', 32)) + utils.zpad('cow', 32))) COW_HASH_1 = utils.big_endian_to_int( utils.sha3(utils.int_to_big_endian(COW_SEED))) balance = self.s.block.get_balance(tester.a0) assert self.c.reveal(1, self.COW_INT) == [1] assert self.s.block.get_balance( tester.a0 ) - balance == self.DEPOSIT_COST + self.ENTROPY_COST # deposit return + payout of committer share assert self.c.get_block(1) == [COW_SEED, 1, 1, 1] # signed vs unsigned as introduced by tester.send assert self.c.get_entropy_ticket(0) == [ int(tester.a1, 16), 1, 1, COW_HASH_1 - 2**256 ] assert self.c.get_entropy( 0, sender=tester.k1) == [1, COW_HASH_1 - 2**256] # ready
def run_test_vm(params): print params pre = params['pre'] exek = params['exec'] callcreates = params.get('callcreates', []) env = params['env'] post = params.get('post', {}) check_testdata(env.keys(), ['currentGasLimit', 'currentTimestamp', 'previousHash', 'currentCoinbase', 'currentDifficulty', 'currentNumber']) # setup env blk = blocks.Block(db, prevhash=env['previousHash'].decode('hex'), number=int(env['currentNumber']), coinbase=env['currentCoinbase'], difficulty=int(env['currentDifficulty']), gas_limit=int(env['currentGasLimit']), timestamp=int(env['currentTimestamp'])) # code FIXME WHAT TO DO WITH THIS CODE??? # if isinstance(env['code'], str): # continue # else: # addr = 0 # FIXME # blk.set_code(addr, ''.join(map(chr, env['code']))) # setup state for address, h in pre.items(): check_testdata(h.keys(), ['code', 'nonce', 'balance', 'storage']) blk.set_nonce(address, int(h['nonce'])) blk.set_balance(address, int(h['balance'])) blk.set_code(address, h['code'][2:].decode('hex')) for k, v in h['storage'].iteritems(): blk.set_storage_data(address, u.big_endian_to_int(k[2:].decode('hex')), u.big_endian_to_int(v[2:].decode('hex'))) # execute transactions sender = exek['caller'] # a party that originates a call recvaddr = exek['address'] tx = transactions.Transaction( nonce=blk._get_acct_item(exek['caller'], 'nonce'), gasprice=int(exek['gasPrice']), startgas=int(exek['gas']), to=recvaddr, value=int(exek['value']), data=exek['data'][2:].decode('hex')) tx.sender = sender # capture apply_message calls apply_message_calls = [] orig_apply_msg = pb.apply_msg ext = pb.VMExt(blk, tx) def call_wrapper(msg): ext.set_balance(msg.sender, ext.get_balance(msg.sender) - msg.value) hexdata = msg.data.extract_all().encode('hex') apply_message_calls.append(dict(gasLimit=msg.gas, value=msg.value, destination=msg.to, data=hexdata)) return 1, msg.gas, '' def sendmsg_wrapper(msg, code): ext.set_balance(msg.sender, ext.get_balance(msg.sender) - msg.value) hexdata = msg.data.extract_all().encode('hex') apply_message_calls.append(dict(gasLimit=msg.gas, value=msg.value, destination=msg.to, data=hexdata)) return 1, msg.gas, '' def create_wrapper(msg): ext.set_balance(msg.sender, ext.get_balance(msg.sender) - msg.value) sender = msg.sender.decode('hex') if len(msg.sender) == 40 else msg.sender nonce = u.encode_int(ext._block.get_nonce(msg.sender)) addr = u.sha3(rlp.encode([sender, nonce]))[12:].encode('hex') hexdata = msg.data.extract_all().encode('hex') apply_message_calls.append(dict(gasLimit=msg.gas, value=msg.value, destination='', data=hexdata)) return 1, msg.gas, addr ext.sendmsg = sendmsg_wrapper ext.call = call_wrapper ext.create = create_wrapper def blkhash(n): if n >= ext.block_number or n < ext.block_number - 256: return '' else: return u.sha3(str(n)) ext.block_hash = blkhash msg = vm.Message(tx.sender, tx.to, tx.value, tx.startgas, vm.CallData([ord(x) for x in tx.data])) success, gas_remained, output = \ vm.vm_execute(ext, msg, exek['code'][2:].decode('hex')) pb.apply_msg = orig_apply_msg blk.commit_state() """ generally expected that the test implementer will read env, exec and pre then check their results against gas, logs, out, post and callcreates. If an exception is expected, then latter sections are absent in the test. Since the reverting of the state is not part of the VM tests. """ if not success: assert 'gas' not in params assert 'post' not in params return for k in ['gas', 'logs', 'out', 'post', 'callcreates']: assert k in params assert len(callcreates) == len(apply_message_calls) # check against callcreates for i, callcreate in enumerate(callcreates): amc = apply_message_calls[i] assert callcreate['data'] == '0x' + amc['data'] assert callcreate['gasLimit'] == str(amc['gasLimit']) assert callcreate['value'] == str(amc['value']) assert callcreate['destination'] == amc['destination'] if 'out' in params: assert '0x' + ''.join(map(chr, output)).encode('hex') == params['out'] if 'gas' in params: assert str(gas_remained) == params['gas'] if 'logs' in params: """ The logs sections is a mapping between the blooms and their corresponding logentries. Each logentry has the format: address: The address of the logentry. data: The data of the logentry. topics: The topics of the logentry, given as an array of values. """ test_logs = params['logs'] vm_logs = [] for log in tx.logs: vm_logs.append({ "bloom": bloom.b64(bloom.bloom_from_list(log.bloomables())).encode('hex'), "address": log.address, "data": '0x' + log.data.encode('hex'), "topics": [u.zpad(u.int_to_big_endian(t), 32).encode('hex') for t in log.topics] }) assert len(vm_logs) == len(test_logs) assert vm_logs == test_logs # check state for address, data in post.items(): state = blk.account_to_dict(address, for_vmtest=True) state.pop('storage_root', None) # attribute not present in vmtest fixtures assert data == state
def run_test_vm(params): pre = params['pre'] exek = params['exec'] callcreates = params.get('callcreates', []) env = params['env'] post = params.get('post', {}) check_testdata(env.keys(), [ 'currentGasLimit', 'currentTimestamp', 'previousHash', 'currentCoinbase', 'currentDifficulty', 'currentNumber' ]) # setup env db = new_db() blk = blocks.Block(db, prevhash=env['previousHash'].decode('hex'), number=int(env['currentNumber']), coinbase=env['currentCoinbase'], difficulty=int(env['currentDifficulty']), gas_limit=int(env['currentGasLimit']), timestamp=int(env['currentTimestamp'])) # code FIXME WHAT TO DO WITH THIS CODE??? # if isinstance(env['code'], str): # continue # else: # addr = 0 # FIXME # blk.set_code(addr, ''.join(map(chr, env['code']))) # setup state for address, h in pre.items(): check_testdata(h.keys(), ['code', 'nonce', 'balance', 'storage']) blk.set_nonce(address, int(h['nonce'])) blk.set_balance(address, int(h['balance'])) blk.set_code(address, h['code'][2:].decode('hex')) for k, v in h['storage']: blk.set_storage_data(address, u.big_endian_to_int(k.decode('hex')), u.big_endian_to_int(v.decode('hex'))) # execute transactions sender = exek['caller'] # a party that originates a call recvaddr = exek['address'] tx = transactions.Transaction(nonce=blk._get_acct_item( exek['caller'], 'nonce'), gasprice=int(exek['gasPrice']), startgas=int(exek['gas']), to=recvaddr, value=int(exek['value']), data=exek['data'][2:].decode('hex')) tx.sender = sender # capture apply_message calls apply_message_calls = [] orig_apply_msg = pb.apply_msg def apply_msg_wrapper(_ext, msg, code, toplevel=False): hexdata = msg.data.extract_all().encode('hex') apply_message_calls.append( dict(gasLimit=msg.gas, value=msg.value, destination=msg.to, data=hexdata)) if not toplevel: pb.apply_msg = orig_apply_msg result, gas_rem, data = orig_apply_msg(_ext, msg, code) if not toplevel: pb.apply_msg = apply_msg_wrapper return result, gas_rem, data pb.apply_msg = apply_msg_wrapper ext = pb.VMExt(blk, tx) msg = vm.Message(tx.sender, tx.to, tx.value, tx.startgas, vm.CallData([ord(x) for x in tx.data])) success, gas_remained, output = \ vm.vm_execute(ext, msg, exek['code'][2:].decode('hex')) pb.apply_msg = orig_apply_msg blk.commit_state() """ generally expected that the test implementer will read env, exec and pre then check their results against gas, logs, out, post and callcreates. If an exception is expected, then latter sections are absent in the test. Since the reverting of the state is not part of the VM tests. """ if not success: return for k in ['gas', 'logs', 'out', 'post', 'callcreates']: assert k in params assert len(callcreates) == len(apply_message_calls) # check against callcreates for i, callcreate in enumerate(callcreates): amc = apply_message_calls[i] assert callcreate['data'] == '0x' + amc['data'] assert callcreate['gasLimit'] == str(amc['gasLimit']) assert callcreate['value'] == str(amc['value']) assert callcreate['destination'] == amc['destination'] if 'out' in params: assert '0x' + ''.join(map(chr, output)).encode('hex') == params['out'] if 'gas' in params: assert str(gas_remained) == params['gas'] if 'logs' in params: """ The logs sections is a mapping between the blooms and their corresponding logentries. Each logentry has the format: address: The address of the logentry. data: The data of the logentry. topics: The topics of the logentry, given as an array of values. """ test_logs = params['logs'] vm_logs = [] for log in tx.logs: vm_logs.append({ "bloom": bloom.b64(bloom.bloom_from_list( log.bloomables())).encode('hex'), "address": log.address, "data": '0x' + log.data.encode('hex'), "topics": [ u.zpad(u.int_to_big_endian(t), 32).encode('hex') for t in log.topics ] }) assert len(vm_logs) == len(test_logs) assert vm_logs == test_logs # check state for address, data in post.items(): state = blk.account_to_dict(address, for_vmtest=True) state.pop('storage_root', None) # attribute not present in vmtest fixtures assert data == state db.delete_db()
def encode_hex_from_int(x): return utils.zpad(utils.int_to_big_endian(x), 64).encode('hex')
def g(x): if type(x) in [int, long]: x=utils.int_to_big_endian(x) return x
def step_impl(context): total_payload_length = sum(len(rlp.encode(x)) for x in context.src) context.length_bin = int_to_big_endian(total_payload_length) assert context.dst[0] == chr(0xf7 + len(context.length_bin))
def step_impl(context): context.length_bin = int_to_big_endian(len(context.src)) assert context.dst[0] == chr(0xb7 + len(context.length_bin))
def g(x): if type(x) in [int, long]: x = utils.int_to_big_endian(x) return x