def get_eth1_shell_context( database_dir: Path, trinity_config: TrinityConfig) -> Iterator[Dict[str, Any]]: app_config = trinity_config.get_app_config(Eth1AppConfig) ipc_path = trinity_config.database_ipc_path trinity_already_running = ipc_path.exists() with _get_base_db(database_dir, ipc_path) as db: chaindb = ChainDB(db) head = chaindb.get_canonical_head() chain_config = app_config.get_chain_config() chain = chain_config.full_chain_class(db) mining_chain_class = MiningChain.configure( __name__=chain_config.full_chain_class.__name__, vm_configuration=chain.vm_configuration, consensus_context_class=chain.consensus_context_class, chain_id=chain.chain_id, ) mining_chain = mining_chain_class(db) yield { 'db': db, 'chaindb': chaindb, 'trinity_config': trinity_config, 'chain_config': chain_config, 'chain': chain, 'mining_chain': mining_chain, 'block_number': head.block_number, 'hex_hash': head.hex_hash, 'state_root_hex': encode_hex(head.state_root), 'trinity_already_running': trinity_already_running, }
def get_eth1_shell_context(database_dir: Path, trinity_config: TrinityConfig) -> Dict[str, Any]: app_config = trinity_config.get_app_config(Eth1AppConfig) ipc_path = trinity_config.database_ipc_path db: DatabaseAPI trinity_already_running = ipc_path.exists() if trinity_already_running: db = DBClient.connect(ipc_path) else: db = LevelDB(database_dir) chaindb = ChainDB(db) head = chaindb.get_canonical_head() chain_config = app_config.get_chain_config() chain = chain_config.full_chain_class(db) mining_chain_class = MiningChain.configure( __name__=chain_config.full_chain_class.__name__, vm_configuration=chain.vm_configuration, chain_id=chain.chain_id, ) mining_chain = mining_chain_class(db) return { 'db': db, 'chaindb': chaindb, 'trinity_config': trinity_config, 'chain_config': chain_config, 'chain': chain, 'mining_chain': mining_chain, 'block_number': head.block_number, 'hex_hash': head.hex_hash, 'state_root_hex': encode_hex(head.state_root), 'trinity_already_running': trinity_already_running, }
def chain_without_block_validation( base_db, genesis_state): """ Return a Chain object containing just the genesis block. This Chain does not perform any validation when importing new blocks. The Chain's state includes one funded account and a private key for it, which can be found in the funded_address and private_keys variables in the chain itself. """ klass = MiningChain.configure( __name__='TestChainWithoutBlockValidation', vm_configuration=ConsensusApplier(NoProofConsensus).amend_vm_configuration( ( (eth_constants.GENESIS_BLOCK_NUMBER, SpuriousDragonVM), ) ), chain_id=1337, ) genesis_params = { 'block_number': eth_constants.GENESIS_BLOCK_NUMBER, 'difficulty': eth_constants.GENESIS_DIFFICULTY, 'gas_limit': 3141592, 'parent_hash': eth_constants.GENESIS_PARENT_HASH, 'coinbase': eth_constants.GENESIS_COINBASE, 'nonce': eth_constants.GENESIS_NONCE, 'mix_hash': eth_constants.GENESIS_MIX_HASH, 'extra_data': eth_constants.GENESIS_EXTRA_DATA, 'timestamp': 1501851927, } chain = klass.from_genesis(base_db, genesis_params, genesis_state) return chain
def chain_without_pow(base_db: AtomicDB, vm: Type[BaseVM], genesis_params: Any, genesis_state: Any) -> MiningChain: vm_without_pow = vm.configure(validate_seal=lambda block: None) klass = MiningChain.configure( __name__='TestChain', vm_configuration=((constants.GENESIS_BLOCK_NUMBER, vm_without_pow), )) chain = klass.from_genesis(base_db, genesis_params, genesis_state) return chain
def main(): args = parse_args() # print('Called with args:') # print(args) # genesis address init_address = to_canonical_address( "8888f1f195afa192cfee860698584c030f4c9db1") base_state = base_genesis_state(init_address, funded_address_initial_balance()) # just an address simple_contract_address = create_simple_contract_address() # create chain klass = MiningChain.configure( __name__='MyTestChain', vm_configuration=((constants.GENESIS_BLOCK_NUMBER, SpuriousDragonVM), ), network_id=1337, ) chain = klass.from_genesis( MemoryDB(), GENESIS_PARAMS, genesis_state(base_state, simple_contract_address, args.data)) # TODO # signature = 'getMeaningOfLife()' # function name # function_selector = function_signature_to_4byte_selector(signature) ''' new_transaction( vm, from_, to, amount=0, private_key=None, gas_price=10, gas=100000, data=b'' ) ''' call_txn = new_transaction( chain.get_vm(), SENDER, simple_contract_address, gas_price=0, # data=function_selector, data=decode_hex(args.signature), ) result_bytes = chain.get_transaction_result(call_txn, chain.get_canonical_head())
def goerli_chain(base_db): vms = (( 0, PetersburgVM, ), ) clique_vms = CliqueApplier().amend_vm_configuration(vms) chain = MiningChain.configure( vm_configuration=clique_vms, consensus_context_class=CliqueConsensusContext, chain_id=5, ).from_genesis_header(base_db, GOERLI_GENESIS_HEADER) return chain
def _configure_mining_chain(starting_vm, vm_under_test): return MiningChain.configure( __name__="AllVMs", vm_configuration=( ( constants.GENESIS_BLOCK_NUMBER, starting_vm.configure(consensus_class=NoProofConsensus), ), ( constants.GENESIS_BLOCK_NUMBER + 1, vm_under_test.configure(consensus_class=NoProofConsensus), ), ), chain_id=1337, )
def paragon_chain_with_clique(base_db): vms = (( 0, PetersburgVM, ), ) clique = CliqueConsensus(base_db) vms = clique.amend_vm_configuration(vms) chain = MiningChain.configure( vm_configuration=vms, chain_id=5, ).from_genesis(base_db, PARAGON_GENESIS_PARAMS, PARAGON_GENESIS_STATE) return chain, clique
def make_chain(self): klass = MiningChain.configure( __name__='Shard{}Chain'.format(self.shard_id), vm_configuration=((constants.GENESIS_BLOCK_NUMBER, ByzantiumVM), )) self.chain = klass.from_genesis(AtomicDB(), self.genesis_params, self.genesis_state) self.vm = self.chain.get_vm() print("Shard " + str(self.shard_id) + " was initialized") print("Parent Shard ID:", self.parent_id) print("Child Shard IDs:", self.child_ids) print("\tAccounts on this shard are:") for address in self.accounts['addresses']: print("\t\t", encode_hex(address)) print("\tMagic Account is:") print("\t\t", encode_hex(MAGIC_ADDRESS)) return self.chain
def paragon_chain(base_db): vms = (( 0, PetersburgVM, ), ( 2, IstanbulVM, )) clique_vms = CliqueApplier().amend_vm_configuration(vms) chain = MiningChain.configure( vm_configuration=clique_vms, consensus_context_class=CliqueConsensusContext, chain_id=5, ).from_genesis(base_db, PARAGON_GENESIS_PARAMS, PARAGON_GENESIS_STATE) return chain
def vm_crossover_chain(request, base_db, genesis_state): start_vm, end_vm = request.param klass = MiningChain.configure( __name__='CrossoverTestChain', vm_configuration=( ( constants.GENESIS_BLOCK_NUMBER, start_vm.configure(consensus_class=NoProofConsensus), ), # Can mine one block of the first VM, then the next block with be the next VM ( constants.GENESIS_BLOCK_NUMBER + 2, end_vm.configure(consensus_class=NoProofConsensus), ), ), chain_id=1337, ) return klass.from_genesis(base_db, dict(difficulty=1), genesis_state)
def main(): # genesis address init_address = to_canonical_address( "8888f1f195afa192cfee860698584c030f4c9db1") base_state = base_genesis_state(init_address, funded_address_initial_balance()) simple_contract_address = RECEIVER # create chain klass = MiningChain.configure( __name__='MyTestChain', vm_configuration=((constants.GENESIS_BLOCK_NUMBER, ByzantiumVM), )) chain = klass.from_genesis( MemoryDB(), GENESIS_PARAMS, genesis_state(base_state, simple_contract_address)) # chain = klass.from_genesis(MemoryDB(), GENESIS_PARAMS, base_state) vm = chain.get_vm() # tx = vm.create_unsigned_transaction( # nonce=vm.state.account_db.get_nonce(SENDER), # gas_price=0x1, # gas=0x90710, # to=simple_contract_address, # value=0x10, # data=DATA.encode(), # ) # signed_tx = tx.as_signed_transaction(SENDER_PRIVATE_KEY) # _, _, computation = chain.apply_transaction(signed_tx, 0x90777) call_txn = new_transaction( vm, SENDER, RECEIVER, amount=0x10, data=DATA.encode(), ) result_bytes = chain.get_transaction_result(call_txn, chain.get_canonical_head(), 1000)
def chain_without_block_validation(base_db, genesis_state): """ Return a Chain object containing just the genesis block. This Chain does not perform any validation when importing new blocks. The Chain's state includes one funded account and a private key for it, which can be found in the funded_address and private_keys variables in the chain itself. """ # Disable block validation so that we don't need to construct finalized blocks. overrides = { 'import_block': import_block_without_validation, 'validate_block': lambda self, block: None, } SpuriousDragonVMForTesting = SpuriousDragonVM.configure( validate_seal=lambda block: None) klass = MiningChain.configure( __name__='TestChainWithoutBlockValidation', vm_configuration=((eth_constants.GENESIS_BLOCK_NUMBER, SpuriousDragonVMForTesting), ), chain_id=1337, **overrides, ) genesis_params = { 'block_number': eth_constants.GENESIS_BLOCK_NUMBER, 'difficulty': eth_constants.GENESIS_DIFFICULTY, 'gas_limit': 3141592, 'parent_hash': eth_constants.GENESIS_PARENT_HASH, 'coinbase': eth_constants.GENESIS_COINBASE, 'nonce': eth_constants.GENESIS_NONCE, 'mix_hash': eth_constants.GENESIS_MIX_HASH, 'extra_data': eth_constants.GENESIS_EXTRA_DATA, 'timestamp': 1501851927, } chain = klass.from_genesis(base_db, genesis_params, genesis_state) return chain
'timestamp': 1514764800, 'extra_data': constants.GENESIS_EXTRA_DATA, 'nonce': constants.GENESIS_NONCE } SENDER_PRIVATE_KEY = keys.PrivateKey( decode_hex('0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8') ) SENDER = Address(SENDER_PRIVATE_KEY.public_key.to_canonical_address()) RECEIVER = Address(b'\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x02') klass = MiningChain.configure( __name__='TestChain', vm_configuration=( (constants.GENESIS_BLOCK_NUMBER, ByzantiumVM), )) chain = klass.from_genesis(AtomicDB(), GENESIS_PARAMS) vm = chain.get_vm() nonce = vm.state.get_nonce(SENDER) tx = vm.create_unsigned_transaction( nonce=nonce, gas_price=0, gas=100000, to=RECEIVER, value=0, data=b'',
def test_header_chain_invalid_if_no_vm_configuration(base_db, genesis_header): chain_class = MiningChain.configure('ChainNoEmptyConfiguration', vm_configuration=()) with pytest.raises(ValueError): chain_class(base_db, genesis_header)
## FIXME -- does not work, traceback at bottom. from eth import constants from eth.chains.base import MiningChain from eth.vm.forks.homestead import HomesteadVM from eth.vm.forks.frontier import FrontierVM from eth.db.atomic import AtomicDB from eth.chains.mainnet import MAINNET_GENESIS_HEADER from eth.chains.mainnet import HOMESTEAD_MAINNET_BLOCK if __name__ == '__main__': chain_class = MiningChain.configure( __name__='Test Chain', vm_configuration=( (constants.GENESIS_BLOCK_NUMBER, FrontierVM), (HOMESTEAD_MAINNET_BLOCK, HomesteadVM), ), ) genesis_header = MAINNET_GENESIS_HEADER.copy(gas_limit=3141592) chain = chain_class.from_genesis_header(AtomicDB(), genesis_header) chain.mine_block() ''' @ commit 1af151ab218b905f4fdf7a285cbe14ebf094a7c4 Traceback (most recent call last): File "/path-to/py-evm/eth/db/batch.py", line 69, in __getitem__ value = self._track_diff[key] File "/path-to/py-evm/eth/db/diff.py", line 80, in __getitem__ raise DiffMissingError(key, result) # type: ignore # ignore over cast for perf reasons