private void assertBlockResultMatchesBlock(final JsonObject result, final Block block) { final BlockHeader header = block.getHeader(); assertThat(Hash.fromHexString(result.getString("parentHash"))) .isEqualTo(header.getParentHash()); assertThat(Hash.fromHexString(result.getString("sha3Uncles"))) .isEqualTo(header.getOmmersHash()); assertThat(Hash.fromHexString(result.getString("transactionsRoot"))) .isEqualTo(header.getTransactionsRoot()); assertThat(Hash.fromHexString(result.getString("stateRoot"))).isEqualTo(header.getStateRoot()); assertThat(Hash.fromHexString(result.getString("receiptsRoot"))) .isEqualTo(header.getReceiptsRoot()); assertThat(Address.fromHexString(result.getString("miner"))).isEqualTo(header.getCoinbase()); assertThat(UInt256.fromHexString(result.getString("difficulty"))) .isEqualTo(header.getDifficulty()); assertThat(BytesValue.fromHexString(result.getString("extraData"))) .isEqualTo(header.getExtraData()); assertThat(hexStringToInt(result.getString("size"))).isEqualTo(block.calculateSize()); assertThat(Long.decode(result.getString("gasLimit"))).isEqualTo(header.getGasLimit()); assertThat(Long.decode(result.getString("gasUsed"))).isEqualTo(header.getGasUsed()); assertThat(Long.decode(result.getString("timestamp"))).isEqualTo(header.getTimestamp()); assertThat(Long.decode(result.getString("number"))).isEqualTo(header.getNumber()); // Nonce is a data field and should represent 8 bytes exactly final String nonceResult = result.getString("nonce").toLowerCase(); assertThat(nonceResult.length() == 18 && nonceResult.startsWith("0x")).isTrue(); assertThat(Long.parseUnsignedLong(nonceResult.substring(2), 16)).isEqualTo(header.getNonce()); assertThat(Hash.fromHexString(result.getString("hash"))).isEqualTo(header.getHash()); assertThat(LogsBloomFilter.fromHexString(result.getString("logsBloom"))) .isEqualTo(header.getLogsBloom()); }
blocks, rlp -> BlockHeader.readFrom( rlp, ScheduleBasedBlockHashFunction.create(protocolSchedule)))) { BlockHeader previousHeader = null; final Block block = iterator.next(); final BlockHeader header = block.getHeader(); if (header.getNumber() == BlockHeader.GENESIS_BLOCK_NUMBER) { continue; if (header.getNumber() % 100 == 0) { LOG.info("Import at block {}", header.getNumber()); if (blockchain.contains(header.getHash())) { continue; previousHeader = lookupPreviousHeader(blockchain, header); final ProtocolSpec<C> protocolSpec = protocolSchedule.getByBlockNumber(header.getNumber()); final BlockHeader lastHeader = previousHeader;
private BlockHeader lookupPreviousHeader( final MutableBlockchain blockchain, final BlockHeader header) { return blockchain .getBlockHeader(header.getParentHash()) .orElseThrow( () -> new IllegalStateException( String.format( "Block %s does not connect to the existing chain. Current chain head %s", header.getNumber(), blockchain.getChainHeadBlockNumber()))); }
@Override protected EthTask<PeerTaskResult<List<BlockHeader>>> createTask( final List<BlockHeader> requestedData) { final BlockHeader firstHeader = requestedData.get(0); return GetHeadersFromPeerByHashTask.startingAtHash( protocolSchedule, ethContext, firstHeader.getHash(), firstHeader.getNumber(), requestedData.size(), ethTasksTimer); }
private void mockBlockchainForBlockHeader(final Hash stateRoot, final long blockNumber) { final BlockHeader blockHeader = mock(BlockHeader.class); when(blockHeader.getStateRoot()).thenReturn(stateRoot); when(blockHeader.getNumber()).thenReturn(blockNumber); when(blockchain.getBlockHeader(blockNumber)).thenReturn(Optional.of(blockHeader)); }
@Test public void calculateBlockHash() { assertThat(header.getHash()).isEqualTo(KNOWN_BLOCK_HASH); }
@Before public void setUp() throws Exception { transactionTracer = new TransactionTracer(new BlockReplay(protocolSchedule, blockchain, worldStateArchive)); when(transaction.hash()).thenReturn(transactionHash); when(otherTransaction.hash()).thenReturn(otherTransactionHash); when(blockHeader.getNumber()).thenReturn(12L); when(blockHeader.getHash()).thenReturn(blockHash); when(blockHeader.getParentHash()).thenReturn(previousBlockHash); when(previousBlockHeader.getStateRoot()).thenReturn(Hash.ZERO); when(worldStateArchive.getMutable(Hash.ZERO)).thenReturn(mutableWorldState); when(protocolSchedule.getByBlockNumber(12)).thenReturn(protocolSpec); when(protocolSpec.getTransactionProcessor()).thenReturn(transactionProcessor); when(protocolSpec.getMiningBeneficiaryCalculator()).thenReturn(BlockHeader::getCoinbase); }
@Test public void createFromJsonNoAllocs() throws Exception { final GenesisState genesisState = GenesisState.fromJson( Resources.toString(GenesisStateTest.class.getResource("genesis2.json"), Charsets.UTF_8), MainnetProtocolSchedule.create()); final BlockHeader header = genesisState.getBlock().getHeader(); assertThat(header.getStateRoot()).isEqualTo(Hash.EMPTY_TRIE_HASH); assertThat(header.getTransactionsRoot()).isEqualTo(Hash.EMPTY_TRIE_HASH); assertThat(header.getReceiptsRoot()).isEqualTo(Hash.EMPTY_TRIE_HASH); assertThat(header.getOmmersHash()).isEqualTo(Hash.EMPTY_LIST_HASH); assertThat(header.getExtraData()).isEqualTo(BytesValue.EMPTY); assertThat(header.getParentHash()).isEqualTo(Hash.ZERO); }
@Override protected EthTask<AbstractPeerTask.PeerTaskResult<List<BlockHeader>>> createTask( final List<BlockHeader> requestedData) { final BlockHeader firstHeader = requestedData.get(0); return GetHeadersFromPeerByNumberTask.startingAtNumber( protocolSchedule, ethContext, firstHeader.getNumber(), requestedData.size(), NoOpMetricsSystem.NO_OP_LABELLED_TIMER); }
@Test public void nonVoteBlendedIntoHeaderResultsInACoinbaseOfZero() { final BlockHeaderBuilder builderWithVote = IbftLegacyBlockInterface.insertVoteToHeaderBuilder(builder, Optional.empty()); final BlockHeader header = builderWithVote.buildBlockHeader(); assertThat(header.getCoinbase()).isEqualTo(AddressHelpers.ofValue(0)); assertThat(header.getNonce()).isEqualTo(0x0L); }
@Test @Ignore public void hashimotoFull() throws Exception { try (final EthHasher.Full hasher = new EthHasher.Full(folder.newFile().toPath())) { final RLPInput input = new BytesValueRLPInput( BytesValue.wrap( Resources.toByteArray(EthHashTest.class.getResource("block_300005.blocks"))), false); input.enterList(); final BlockHeader header = BlockHeader.readFrom(input, MainnetBlockHashFunction::createHash); final byte[] buffer = new byte[64]; hasher.hash(buffer, header.getNonce(), header.getNumber(), EthHash.hashHeader(header)); Assertions.assertThat( ByteArrayUtil.compare(buffer, 0, 32, header.getMixHash().extractArray(), 0, 32)) .isEqualTo(0); } } }
public BlockWithMetadata<TransactionWithMetadata, Hash> blockWithMetadata( final BlockHeader header) { final KeyPair keyPair = KeyPair.generate(); final List<TransactionWithMetadata> transactions = new ArrayList<>(); for (int i = 0; i < 3; i++) { final Transaction transaction = transactionTestFixture.createTransaction(keyPair); transactions.add( new TransactionWithMetadata(transaction, header.getNumber(), header.getHash(), 0)); } final List<Hash> ommers = new ArrayList<>(); ommers.add(Hash.ZERO); return new BlockWithMetadata<>(header, transactions, ommers, header.getDifficulty(), 0); } }
private void insertRoundToBlockHeader(final int round) { final IbftExtraData extraData = new IbftExtraData( BytesValue.wrap(new byte[32]), Collections.emptyList(), empty(), round, validators); final BlockHeader header = mock(BlockHeader.class); when(header.getExtraData()).thenReturn(extraData.encode()); when(block.getHeader()).thenReturn(header); }
if (transaction.getGasLimit() > blockHeader.getGasLimit() - blockHeader.getGasUsed()) { return; final TestBlockchain blockchain = new TestBlockchain(blockHeader.getNumber()); final TransactionProcessor.Result result = processor.processTransaction( blockHeader, transaction, blockHeader.getCoinbase(), new BlockHashLookup(blockHeader, blockchain)); final Account coinbase = worldStateUpdater.getOrCreate(spec.blockHeader().getCoinbase()); if (coinbase != null && coinbase.isEmpty() && shouldClearEmptyAccounts(spec.eip())) { worldStateUpdater.deleteAccount(coinbase.getAddress());
when(blockchain.getChainHeadHash()).thenReturn(parentHeader.getHash()); when(blockchain.getBlockHeader(any())).thenReturn(optionalHeader); final IbftExtraData extraData = IbftExtraData.decode(header.getExtraData()); assertThat(block.getHash()) .isEqualTo(IbftBlockHashing.calculateDataHashForCommittedSeal(header, extraData));
@Test public void getBlockBodiesRoundTrip() throws IOException { final List<Hash> hashes = new ArrayList<>(); final ByteBuffer buffer = ByteBuffer.wrap(Resources.toByteArray(Resources.getResource("50.blocks"))); for (int i = 0; i < 50; ++i) { final int blockSize = RLP.calculateSize(BytesValue.wrapBuffer(buffer)); final byte[] block = new byte[blockSize]; buffer.get(block); buffer.compact().position(0); final RLPInput oneBlock = new BytesValueRLPInput(BytesValue.wrap(block), false); oneBlock.enterList(); hashes.add(BlockHeader.readFrom(oneBlock, MainnetBlockHashFunction::createHash).getHash()); // We don't care about the bodies, just the headers oneBlock.skipNext(); oneBlock.skipNext(); } final MessageData initialMessage = GetBlockBodiesMessage.create(hashes); final MessageData raw = new RawMessage(EthPV62.GET_BLOCK_BODIES, initialMessage.getData()); final GetBlockBodiesMessage message = GetBlockBodiesMessage.readFrom(raw); final Iterator<Hash> readHeaders = message.hashes().iterator(); for (int i = 0; i < 50; ++i) { Assertions.assertThat(readHeaders.next()).isEqualTo(hashes.get(i)); } } }
public static BlockHeader readHeader(final long num) throws IOException { final RLPInput input = new BytesValueRLPInput( BytesValue.wrap( Resources.toByteArray( EthHashTest.class.getResource(String.format("block_%d.blocks", num)))), false); input.enterList(); return BlockHeader.readFrom(input, MainnetBlockHashFunction::createHash); }
@Before public void setUp() { when(blockchainQueries.headBlockNumber()).thenReturn(1L); when(blockchainQueries.getBlockchain()).thenReturn(blockchain); when(blockchain.getBlockHeader(eq(1L))).thenReturn(Optional.of(blockHeader)); when(blockHeader.getGasLimit()).thenReturn(Long.MAX_VALUE); when(blockHeader.getNumber()).thenReturn(1L); method = new EthEstimateGas( blockchainQueries, transientTransactionProcessor, new JsonRpcParameter()); }
.build(new MutableProtocolSchedule<>(CHAIN_ID)); final TestBlockchain blockchain = new TestBlockchain(execEnv.getBlockHeader().getNumber()); final MessageFrame frame = MessageFrame.builder() .depth(execEnv.getDepth()) .completer(c -> {}) .miningBeneficiary(execEnv.getBlockHeader().getCoinbase()) .blockHashLookup(new BlockHashLookup(execEnv.getBlockHeader(), blockchain)) .build();
@Test public void validateHeaderChain() { final BlockHeader blockHeader = generator.header(); when(blockchain.getBlockHeader(blockHeader.getParentHash())) .thenReturn(Optional.of(blockHeader)); final BlockHeaderValidator<Void> validator = new BlockHeaderValidator.Builder<Void>().addRule(createPassingAttachedRule()).build(); assertThat(validator.validateHeader(blockHeader, protocolContext, HeaderValidationMode.FULL)) .isTrue(); }