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
