def test_endpointregistry(tester_chain, tester_events): account0 = tester.a0 sender = address_encoder(account0) endpointregistry_path = get_contract_path('EndpointRegistry.sol') endpointregistry_compiled = _solidity.compile_contract( endpointregistry_path, "EndpointRegistry") tester_chain.head_state.log_listeners.append(tester_events.append) endpointregistry_address = tester_chain.contract( endpointregistry_compiled['bin'], language='evm') endpoint_registry = tester.ABIContract(tester_chain, endpointregistry_compiled['abi'], endpointregistry_address) endpoint_registry.registerEndpoint('127.0.0.1:4001') assert endpoint_registry.findAddressByEndpoint('127.0.0.1:4001') == sender assert endpoint_registry.findEndpointByAddress(sender) == b'127.0.0.1:4001' endpoint_registry.registerEndpoint('192.168.0.1:4002') assert endpoint_registry.findAddressByEndpoint( '192.168.0.1:4002') == sender assert endpoint_registry.findEndpointByAddress( sender) == b'192.168.0.1:4002' assert len(tester_events) == 2 event0 = event_decoder(tester_events[0], endpoint_registry.translator) event1 = event_decoder(tester_events[1], endpoint_registry.translator) assert event0['_event_type'] == b'AddressRegistered' assert event1['_event_type'] == b'AddressRegistered'
def init_chain_and_casper(): genesis = casper_utils.make_casper_genesis(ALLOC, EPOCH_LENGTH, 100, 0.02, 0.002) t = tester.Chain(genesis=genesis) casper = tester.ABIContract(t, casper_utils.casper_abi, t.chain.config['CASPER_ADDRESS']) return t, casper
def generate_commit_message(self, state): epoch = state.block_number // self.epoch_length # PREPARE_COMMIT_CONSISTENCY if self.prev_prepare_epoch < self.prev_commit_epoch and self.prev_commit_epoch < epoch: return None # Create a Casper contract which we can use to get related values casper = tester.ABIContract(tester.State(state), casper_utils.casper_abi, self.chain.casper_address) validator_index = self.get_validator_index(state) _e, _a, _se, _sa, _pce = self.get_recommended_casper_msg_contents( casper, validator_index) # Make the commit message commit_msg = casper_utils.mk_commit(validator_index, _e, _a, _pce, self.key) try: # Attempt to submit the commit, to make sure that it doesn't doesn't violate DBL_PREPARE & it is justified casper.commit(commit_msg) except tester.TransactionFailed: log.info( 'Commit failed! Validator {} - blockhash {} - valcode addr {}'. format(self.get_validator_index(state), self.epoch_blockhash(state, epoch), utils.encode_hex(self.valcode_addr))) return None # Save the commit as now our last commit epoch log.info( 'Commit submitted: validator %d - epoch %d - prev_commit_epoch %d - hash %s' % (self.get_validator_index(state), epoch, self.prev_commit_epoch, utils.encode_hex(self.epoch_blockhash(state, epoch)))) self.prev_commit_epoch = epoch return commit_msg
def deploy_auxiliary_tester(tester_chain, tester_nettingchannel_library_address): contracts_path = os.path.join(get_project_root(), 'smart_contracts') raiden_remap = 'raiden={}'.format(contracts_path) contract_libraries = { 'NettingChannelLibrary': hexlify(tester_nettingchannel_library_address), } auxiliary_tester_compiled = _solidity.compile_contract( get_relative_contract(__file__, 'AuxiliaryTester.sol'), 'AuxiliaryTester', contract_libraries, extra_args=raiden_remap ) auxiliary_tester_address = tester_chain.contract( auxiliary_tester_compiled['bin'], language='evm', sender=tester.k0 ) auxiliary = tester.ABIContract( tester_chain, auxiliary_tester_compiled['abi'], auxiliary_tester_address ) tester_chain.mine(number_of_blocks=1) return auxiliary
def epoch_info(epoch): height = epoch * 50 + 49 block = eth.chain.get_block_by_number(height) blockhash = block.hash ts = block.timestamp temp_state = eth.chain.mk_poststate_of_blockhash(blockhash) casper = tester.ABIContract(tester.State(temp_state), casper_utils.casper_abi, eth.chain.config['CASPER_ADDRESS']) ce, ese = casper.get_current_epoch(), casper.get_expected_source_epoch() deposit_scale_factor = casper.get_deposit_scale_factor(ce) storage = len( tester.State(temp_state).state.account_to_dict( eth.chain.config['CASPER_ADDRESS'])["storage"]) info = {} info["number"] = height info["blockhash"] = encode_hex(blockhash) info["timestamp"] = ts info["difficulty"] = block.difficulty info["current_epoch"] = ce info["validators"] = validators(casper, deposit_scale_factor) info["lje"] = casper.get_last_justified_epoch() info["lfe"] = casper.get_last_finalized_epoch() info["votes"] = votes_and_deposits(casper, ce, ese, deposit_scale_factor) info["deposit_scale_factor"] = deposit_scale_factor info["storage"] = storage return info
def create_registryproxy(tester_chain, tester_registry_address, log_listener): translator = tester.ContractTranslator(CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY)) tester_chain.head_state.log_listeners.append(log_listener) registry_abi = tester.ABIContract( tester_chain, translator, tester_registry_address, ) return registry_abi
def create_tokenproxy(tester_chain, tester_token_address, log_listener): translator = tester.ContractTranslator( CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN)) tester_chain.head_state.log_listeners.append(log_listener) token_abi = tester.ABIContract( tester_chain, translator, tester_token_address, ) return token_abi
def create_channelmanager_proxy(tester_chain, tester_channelmanager_address, log_listener): translator = tester.ContractTranslator( CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER) ) channel_manager_abi = tester.ABIContract( tester_chain, translator, tester_channelmanager_address, ) tester_chain.head_state.log_listeners.append(log_listener) return channel_manager_abi
def create_nettingchannel_proxy(tester_chain, tester_nettingchannel_address, log_listener): translator = tester.ContractTranslator( CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL) ) tester_chain.head_state.log_listeners.append(log_listener) netting_channel_abi = tester.ABIContract( tester_chain, translator, tester_nettingchannel_address, ) return netting_channel_abi
def get_validator_index(self, state): t = tester.State(state.ephemeral_clone()) t.state.gas_limit = 9999999999 casper = tester.ABIContract(t, casper_utils.casper_abi, self.chain.casper_address) if self.valcode_addr is None: raise Exception('Valcode address not set') try: return casper.get_validator_indexes(self.coinbase) except tester.TransactionFailed: return None
def __init__(self, tester_chain, private_key, address): if len(tester_chain.head_state.get_code(address)) == 0: raise Exception('Contract code empty') self.address = address self.tester_chain = tester_chain self.private_key = private_key self.proxy = tester.ABIContract( tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN), address)
def __init__(self, tester_chain, private_key, address): if len(tester_chain.head_state.get_code(address)) == 0: raise Exception('Contract code empty') self.address = address self.tester_chain = tester_chain self.private_key = private_key self.proxy = tester.ABIContract( tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER), address) self.participant_filter = defaultdict(list) self.address_filter = defaultdict(list)
def init_multi_validator_casper(num_validators): """" Initialize Casper genesis, login an initial validator, and create num_validators validators """ # Begin tests genesis = casper_utils.make_casper_genesis(ALLOC, EPOCH_LENGTH, 25, 0.02, 0.002) t = tester.Chain(genesis=genesis) casper = tester.ABIContract(t, casper_utils.casper_abi, t.chain.config['CASPER_ADDRESS']) # Get the val code addresses and network network = validator.Network() # Initialize validators, starting with the first validator validators = [] # Add our validators for i in range(0, num_validators): log.info('Adding validator {}'.format(i)) validators.append( validator.Validator(tester.keys[i], copy.deepcopy(genesis), network)) t = tester.Chain(genesis=genesis) casper = tester.ABIContract(t, casper_utils.casper_abi, t.chain.env.config['CASPER_ADDRESS']) t.mine(26) # Pump the blocks into the validators for i in range(1, 27): block = t.chain.get_block_by_number(i) log.info('Pumping block: {} {}'.format(utils.encode_hex(block.hash), block.transactions)) for v in validators: v.chain.add_block(block) if num_validators < 1: return t, casper # Submit deposits for new validators for i in range(0, num_validators): validators[i].broadcast_deposit() validators[0].mine_and_broadcast_blocks(1) return t, casper, validators
def get_contract_with_gas_estimation_for_constants(source_code, *args, **kwargs): abi = tester.languages['viper'].mk_full_signature(source_code) # Take out constants from the abi for the purpose of gas estimation for func in abi: func['constant'] = False ct = tester.ContractTranslator(abi) byte_code = tester.languages['viper'].compile(source_code) + ( ct.encode_constructor_arguments(kwargs['args']) if kwargs else b'') address = chain.tx(to=b'', data=byte_code) contract = tester.ABIContract(chain, abi, address) for func_name in contract.translator.function_data: set_decorator_to_contract_function(contract, source_code, func_name) return contract
def __init__(self, tester_chain, private_key, address): if len(tester_chain.head_state.get_code(address)) == 0: raise Exception('Contract code empty') self.address = address self.tester_chain = tester_chain self.private_key = private_key self.registry_proxy = tester.ABIContract( self.tester_chain, CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY), self.address) self.tokenadded_filters = list() self.address_to_channelmanager = dict() self.token_to_channelmanager = dict()
def generate_prepare_message(self, state): epoch = state.block_number // self.epoch_length # NO_DBL_PREPARE: Don't prepare if we have already if epoch in self.prepares: return None # Create a Casper contract which we can use to get related values casper = tester.ABIContract(tester.State(state), casper_utils.casper_abi, self.chain.casper_address) # Get the ancestry hash and source ancestry hash validator_index = self.get_validator_index(state) _e, _a, _se, _sa, _pce = self.get_recommended_casper_msg_contents( casper, validator_index) # PREPARE_COMMIT_CONSISTENCY if _se < self.prev_commit_epoch and self.prev_commit_epoch < epoch: return None prepare_msg = casper_utils.mk_prepare(validator_index, _e, _a, _se, _sa, self.key) try: # Attempt to submit the prepare, to make sure that it is justified casper.prepare(prepare_msg) except tester.TransactionFailed: log.info( 'Prepare failed! Validator {} - hash justified {} - validator start {} - valcode addr {}' .format( self.get_validator_index(state), casper.get_consensus_messages__ancestry_hash_justified( epoch, _a), casper.get_validators__dynasty_start(validator_index), utils.encode_hex(self.valcode_addr))) return None # Save the prepare message we generated self.prepares[epoch] = prepare_msg # Save the highest source epoch we have referenced in our prepare's source epoch if epoch > self.prev_prepare_epoch: self.prev_prepare_epoch = epoch log.info( 'Prepare submitted: validator %d - epoch %d - prev_commit_epoch %d - hash %s' % (self.get_validator_index(state), epoch, self.prev_commit_epoch, utils.encode_hex(self.epoch_blockhash(state, epoch)))) return prepare_msg
def main(): c = tester.Chain() owner = tester.a0 owner_key = tester.k0 whitelist_evm, whitelist_abi = sol_compile('whitelist.sol') addr = c.contract(whitelist_evm, language='evm', sender=owner_key) whitelist = tester.ABIContract(c, whitelist_abi, addr) assert binascii.unhexlify(whitelist.owner()[2:]) == owner whitelist.add(owner) assert whitelist.check(owner) addresses = [tester.a1, tester.a2, tester.a3] whitelist.add_all(addresses) assert all(map(whitelist.check, addresses)) whitelist.remove(owner) assert not whitelist.check(owner) for a in addresses: whitelist.remove(a) assert not whitelist.check(a) whitelist.destroy() print('TEST PASSED')
def __init__(self, test_string, epoch_length, withdrawal_delay, base_interest_factor, base_penalty_factor): if test_string == '': raise Exception("Please pass in a valid test string") self.test_string = test_string self.genesis = casper_utils.make_casper_genesis( ALLOC, epoch_length, withdrawal_delay, base_interest_factor, base_penalty_factor) self.t = tester.Chain(genesis=self.genesis) self.casper = tester.ABIContract( self.t, casper_utils.casper_abi, self.t.chain.env.config['CASPER_ADDRESS']) self.saved_blocks = dict() self.validators = dict() # Register token handlers self.handlers = dict() self.handlers['B'] = self.mine_blocks self.handlers['J'] = self.join self.handlers['P'] = self.prepare self.handlers['C'] = self.commit self.handlers['S'] = self.save_block self.handlers['R'] = self.revert_to_block self.handlers['H'] = self.check_head_equals_block self.handlers['X'] = self.slash
def pool(casper_chain, pool_abi, pool_address): return tester.ABIContract(casper_chain, pool_abi, pool_address)
init_txs, casper_address = mk_initializers(casper_config, t.k0) for tx in init_txs: if s.head_state.gas_used + tx.startgas > s.head_state.gas_limit: s.mine(1) s.direct_tx(tx) ct = abi.ContractTranslator(purity_checker_abi) # Check that the RLP decoding library and the sig hashing library are "pure" assert utils.big_endian_to_int( s.tx(t.k0, purity_checker_address, 0, ct.encode('submit', [viper_rlp_decoder_address]))) == 1 assert utils.big_endian_to_int( s.tx(t.k0, purity_checker_address, 0, ct.encode('submit', [sig_hasher_address]))) == 1 casper = t.ABIContract(s, casper_abi, casper_address) s.mine(1) # Helper functions for making a prepare, commit, login and logout message def mk_prepare(validator_index, epoch, ancestry_hash, source_epoch, source_ancestry_hash, key): sighash = utils.sha3( rlp.encode([ validator_index, epoch, ancestry_hash, source_epoch, source_ancestry_hash ])) v, r, s = utils.ecdsa_raw_sign(sighash, key) sig = utils.encode_int32(v) + utils.encode_int32(r) + utils.encode_int32(s) return rlp.encode([
t.gas_limit = 9999999 t.STARTGAS = 2000000 c.mine(1) EPOCH_LENGTH = c.chain.config['EPOCH_LENGTH'] ct = abi.ContractTranslator(purity_checker_abi) # Check that the RLP decoding library and the sig hashing library are "pure" assert utils.big_endian_to_int( c.tx(t.k0, purity_checker_address, 0, ct.encode('submit', [viper_rlp_decoder_address]))) == 1 assert utils.big_endian_to_int( c.tx(t.k0, purity_checker_address, 0, ct.encode('submit', [sig_hasher_address]))) == 1 casper = t.ABIContract(c, casper_abi, c.chain.config['CASPER_ADDRESS']) c.mine(1) # Begin the test print("Starting tests") # Initialize the first epoch c.mine(EPOCH_LENGTH - c.head_state.block_number) # casper.initialize_epoch(1) assert casper.get_nextValidatorIndex() == 0 assert casper.get_current_epoch() == 1 print("Epoch initialized") # Deposit one validator induct_validator(c, casper, t.k1, 200 * 10**18) # Mine two epochs
def add_block(self, block): # ~~~ Validate ~~~~ # # Validate that the block should be added if not self.should_add_block(block): return False # ~~~ Store ~~~~ # # Store the block self.db.put(block.header.hash, rlp.encode(block)) self.add_child(block) if block.number % self.config['EPOCH_LENGTH'] == 0: self.db.put(b'cp_subtree_score' + block.hash, 0) # Store the state root if block.header.prevhash == self.head_hash: temp_state = self.state.ephemeral_clone() else: temp_state = self.mk_poststate_of_blockhash(block.header.prevhash) apply_block(temp_state, block) self.db.put(b'state:' + block.header.hash, temp_state.trie.root_hash) # ~~~ Finality Gadget Fork Choice ~~~~ # old_head_chekpoint = self.head_checkpoint # Store the new score cp_hash = self.get_prev_checkpoint_hash(block.hash) casper = tester.ABIContract(tester.State(temp_state), casper_utils.casper_abi, self.config['CASPER_ADDRESS']) try: new_score = casper.get_main_hash_committed_frac() log.info('Got new score! {}'.format(new_score)) except tester.TransactionFailed: new_score = 0 if self.get_checkpoint_score( cp_hash) < new_score or self.get_checkpoint_score( cp_hash) == 0: log.info( 'Updating checkpoint score. Block num: {} - New Score: {}'. format(self.get_block(cp_hash).number, new_score)) self.db.put(b'cp_score:' + cp_hash, new_score) # Update our view self.update_subtree_scores_and_child_pointers(cp_hash) cp = self.get_block(cp_hash) # Store the block as its checkpoint child if is is heavier than the current child p_cp = cp while cp is not self.genesis and self.get_checkpoint_score( cp.hash) == 0: cp = self.get_prev_checkpoint_block(cp) log.info( 'Recieved block. Block num: {} - Prev cp num: {} - Prev committed cp num: {} - Head cp num: {} - Prev committed cp score: {} - Current head cp score: {}' .format(block.number, p_cp.number, cp.number, self.head_checkpoint.number, self.get_checkpoint_score(cp.hash), self.get_checkpoint_score(self.checkpoint_head_hash))) log.info('head cp hash: {} - block prev cp hash: {}'.format( utils.encode_hex(cp_hash), utils.encode_hex(self.checkpoint_head_hash))) # Recompute head self.recompute_head_checkpoint(cp) # Set a new head if required log.info('Head cp num: {} - block prev cp num: {}'.format( self.head_checkpoint.number, cp.number)) if self.head_checkpoint == cp: if self.head_checkpoint == old_head_chekpoint: log.info( 'Head checkpoint == old head. CP Head Num: {} - Head diff: {} - Block diff: {}' .format(self.head_checkpoint.number, self.get_pow_difficulty(self.head), self.get_pow_difficulty(block))) if self.get_pow_difficulty( self.head) < self.get_pow_difficulty(block): self.set_head(block) else: log.info('Head checkpoint changed to cp number: {}'.format( self.head_checkpoint.number)) new_head, _ = self.find_heaviest_pow_block( self.head_checkpoint) self.set_head(new_head) else: log.info('Skipping block: Head checkpoint is not equal to cp!') # Are there blocks that we received that were waiting for this block? # If so, process them. if block.header.hash in self.parent_queue: for _blk in self.parent_queue[block.header.hash]: self.add_block(_blk) del self.parent_queue[block.header.hash] return True
s = tester.Chain() s.mine() contract_path = './contractNipopow.sol' contract_name = 'Crosschain' contract_compiled = compile_file(contract_path) contract_data = solidity_get_contract_data( contract_compiled, contract_path, contract_name, ) contract_address = s.contract(contract_data['bin'], language='evm') contract_abi = tester.ABIContract(s, contract_data['abi'], contract_address) import cPickle as pickle proof = pickle.load(open('proof.pkl')) proof_f = pickle.load(open('proof-fork50k.pkl')) proof2 = pickle.load(open('proof-2.pkl')) proof3 = pickle.load(open('proof-3.pkl')) proof4 = pickle.load(open('proof-4.pkl')) # Take a snapshot before trying out test cases #try: s.revert(s.snapshot()) #except: pass # FIXME: I HAVE NO IDEA WHY THIS IS REQUIRED s.mine() base = s.snapshot()
language='vyper', args=[tester.accounts[0], FIVE_DAYS]) # Generate ABI from contract source code abi = tester.languages['vyper'].mk_full_signature(source_code) print("ABI: %s", abi) # Generate Contract Translator from ABI contract_translator = tester.ContractTranslator(abi) # Generate Bytecode from contract source code contract_constructor_args = [] byte_code = tester.languages['vyper'].compile(source_code) + \ get_encoded_contract_constructor_arguments(contract_constructor_args) # print("Bytecode: %s", byte_code) address = tester.s.tx(to=b'', data=byte_code) print("Address: %s", address) # Instantiate contract from its ABI and Bytecode contract_instance = tester.ABIContract(tester.s, abi, address) print("Contract Instance: %s", contract_instance) # Execute method on the tester chain to check the beneficiary is correct assert ethereum_utils.remove_0x_head( tester.c.beneficiary()) == tester.accounts[0].hex() # Execute method on the tester chain to check bidding time is 5 days assert tester.c.auction_end() == tester.s.head_state.timestamp + FIVE_DAYS # Revert chain state on failed transaction tester.s.revert(initial_chain_state) # Instantiate and deploy contract contract_instance_web3 = web3.eth.contract(abi=abi, bytecode=byte_code) print("Contract Instance with Web3: %s", contract_instance) # Note: If we're running a Geth Node then I can use # `web3.personal.listAccounts` but when I am using Ganache CLI
def mk_casper_tester(validator): return tester.ABIContract(tester.State(validator.chain.state), casper_utils.casper_abi, validator.chain.casper_address)