private void extractSignatures(final Block block) { final List<CompletableFuture<Void>> futures = new ArrayList<>(block.getBody().getTransactions().size()); for (final Transaction tx : block.getBody().getTransactions()) { futures.add(CompletableFuture.runAsync(tx::getSender, validationExecutor)); } for (final CompletableFuture<Void> future : futures) { future.join(); } }
@Test public void traceTransactionShouldReturnTraceFramesFromExecutionTracer() { when(blockchain.getBlockHeader(blockHash)).thenReturn(Optional.of(blockHeader)); when(blockchain.getBlockHeader(previousBlockHash)).thenReturn(Optional.of(previousBlockHeader)); when(blockBody.getTransactions()).thenReturn(Collections.singletonList(transaction)); when(blockchain.getBlockBody(blockHash)).thenReturn(Optional.of(blockBody)); final List<TraceFrame> traceFrames = Collections.singletonList(mock(TraceFrame.class)); when(tracer.getTraceFrames()).thenReturn(traceFrames); final Optional<TransactionTrace> transactionTrace = transactionTracer.traceTransaction(blockHash, transactionHash, tracer); assertEquals(traceFrames, transactionTrace.get().getTraceFrames()); }
@Test public void traceTransactionShouldReturnEmptyResultWhenTransactionNotInCurrentBlock() { when(blockchain.getBlockHeader(blockHash)).thenReturn(Optional.of(blockHeader)); when(blockchain.getBlockHeader(previousBlockHash)).thenReturn(Optional.of(previousBlockHeader)); when(blockBody.getTransactions()).thenReturn(Collections.singletonList(otherTransaction)); when(blockchain.getBlockBody(blockHash)).thenReturn(Optional.of(blockBody)); final Optional<TransactionTrace> transactionTrace = transactionTracer.traceTransaction(blockHash, transactionHash, tracer); assertEquals(Optional.empty(), transactionTrace); }
@Test public void traceTransactionShouldReturnTraceFramesFromExecutionTracerAfterExecutingOtherTransactions() { when(blockchain.getBlockHeader(blockHash)).thenReturn(Optional.of(blockHeader)); when(blockchain.getBlockHeader(previousBlockHash)).thenReturn(Optional.of(previousBlockHeader)); when(blockBody.getTransactions()).thenReturn(Arrays.asList(otherTransaction, transaction)); when(blockchain.getBlockBody(blockHash)).thenReturn(Optional.of(blockBody)); final List<TraceFrame> traceFrames = Collections.singletonList(mock(TraceFrame.class)); when(tracer.getTraceFrames()).thenReturn(traceFrames); final Optional<TransactionTrace> transactionTrace = transactionTracer.traceTransaction(blockHash, transactionHash, tracer); assertEquals(traceFrames, transactionTrace.get().getTraceFrames()); }
@Before public void setup() { ibftMiningCoordinator = new IbftMiningCoordinator(ibftProcessor, ibftBlockCreatorFactory, blockChain, eventQueue); when(block.getBody()).thenReturn(blockBody); when(block.getHeader()).thenReturn(blockHeader); when(blockBody.getTransactions()).thenReturn(Lists.emptyList()); }
private Hash recordPendingTransaction(final int blockNumber, final int transactionIndex) { final Block block = BLOCKS.get(1); final Transaction transaction = block.getBody().getTransactions().get(0); filterManager.recordPendingTransactionEvent(transaction); return transaction.hash(); }
@Test public void calculateTransactionsRoot() throws IOException { for (final int block : Arrays.asList(300006, 4400002)) { final BlockHeader header = ValidationTestUtils.readHeader(block); final BlockBody body = ValidationTestUtils.readBody(block); final Bytes32 transactionRoot = BodyValidation.transactionsRoot(body.getTransactions()); Assertions.assertThat(header.getTransactionsRoot()).isEqualTo(transactionRoot); } }
@Test public void traceTransactionShouldReturnResultFromProcessTransaction() { final Result result = mock(Result.class); when(blockchain.getBlockHeader(blockHash)).thenReturn(Optional.of(blockHeader)); when(blockchain.getBlockHeader(previousBlockHash)).thenReturn(Optional.of(previousBlockHeader)); when(blockBody.getTransactions()).thenReturn(Collections.singletonList(transaction)); when(blockchain.getBlockBody(blockHash)).thenReturn(Optional.of(blockBody)); final WorldUpdater updater = mutableWorldState.updater(); final Address coinbase = blockHeader.getCoinbase(); when(transactionProcessor.processTransaction( eq(blockchain), eq(updater), eq(blockHeader), eq(transaction), eq(coinbase), eq(tracer), any())) .thenReturn(result); final Optional<TransactionTrace> transactionTrace = transactionTracer.traceTransaction(blockHash, transactionHash, tracer); assertEquals(result, transactionTrace.get().getResult()); }
public BlockWithMetadata<Hash, Hash> blockWithMetadataAndTxHashes(final Block block) { final UInt256 td = block.getHeader().getDifficulty().plus(10L); final int size = block.calculateSize(); final List<Hash> txs = block .getBody() .getTransactions() .stream() .map(Transaction::hash) .collect(Collectors.toList()); final List<Hash> ommers = block.getBody().getOmmers().stream().map(BlockHeader::getHash).collect(Collectors.toList()); return new BlockWithMetadata<>(block.getHeader(), txs, ommers, td, size); }
public BlockWithMetadata<TransactionWithMetadata, Hash> blockWithMetadata(final Block block) { final UInt256 td = block.getHeader().getDifficulty().plus(10L); final int size = block.calculateSize(); final List<Transaction> txs = block.getBody().getTransactions(); final List<TransactionWithMetadata> formattedTxs = new ArrayList<>(txs.size()); for (int i = 0; i < txs.size(); i++) { formattedTxs.add( new TransactionWithMetadata( txs.get(i), block.getHeader().getNumber(), block.getHash(), i)); } final List<Hash> ommers = block.getBody().getOmmers().stream().map(BlockHeader::getHash).collect(Collectors.toList()); return new BlockWithMetadata<>(block.getHeader(), formattedTxs, ommers, td, size); }
private void assertBlockMatchesResultWithTxHashes( final Block targetBlock, final BlockWithMetadata<Hash, Hash> result) { assertEquals(targetBlock.getHeader(), result.getHeader()); final List<Hash> expectedOmmers = targetBlock .getBody() .getOmmers() .stream() .map(BlockHeader::getHash) .collect(Collectors.toList()); assertEquals(expectedOmmers, result.getOmmers()); for (int i = 0; i < result.getTransactions().size(); i++) { final Hash txResult = result.getTransactions().get(i); final Transaction actualTx = targetBlock.getBody().getTransactions().get(i); assertEquals(actualTx.hash(), txResult); } }
for (final Transaction tx : originalHead.getBody().getTransactions()) { assertThat(blockchain.getTransactionByHash(tx.hash())).isNotPresent();
assertTotalDifficultiesAreConsistent(blockchain, originalHead); for (final Transaction tx : forkBlocks.get(0).getBody().getTransactions()) { assertThat(blockchain.getTransactionByHash(tx.hash())).isNotPresent(); removedTransactions.addAll(chain.get(i).getBody().getTransactions());
assertThat(transactionsResult.size()).isEqualTo(block.getBody().getTransactions().size()); for (int i = 0; i < block.getBody().getTransactions().size(); i++) { final Transaction transaction = block.getBody().getTransactions().get(i); if (shouldTransactionsBeHashed) { assertThat(Hash.fromHexString(transactionsResult.getString(i)))
blockchain.appendBlock(chain.get(i), blockReceipts.get(i)); final Transaction overlappingTx = chain.get(chainLength - 1).getBody().getTransactions().get(0); for (final Transaction tx : chain.get(chainLength - 1).getBody().getTransactions()) { final Optional<Transaction> actualTransaction = blockchain.getTransactionByHash(tx.hash()); if (tx.equals(overlappingTx)) {
private void assertBlockDataIsStored( final Blockchain blockchain, final Block block, final List<TransactionReceipt> receipts) { final Hash hash = block.getHash(); assertEquals(hash, blockchain.getBlockHashByNumber(block.getHeader().getNumber()).get()); assertEquals(block.getHeader(), blockchain.getBlockHeader(block.getHeader().getNumber()).get()); assertEquals(block.getHeader(), blockchain.getBlockHeader(hash).get()); assertEquals(block.getBody(), blockchain.getBlockBody(hash).get()); assertThat(blockchain.blockIsOnCanonicalChain(block.getHash())).isTrue(); final List<Transaction> txs = block.getBody().getTransactions(); for (int i = 0; i < txs.size(); i++) { final Transaction expected = txs.get(i); final Transaction actual = blockchain.getTransactionByHash(expected.hash()).get(); assertEquals(expected, actual); } final List<TransactionReceipt> actualReceipts = blockchain.getTxReceipts(hash).get(); assertEquals(receipts, actualReceipts); }
assertTotalDifficultiesAreConsistent(blockchain, originalHead); for (final Transaction tx : forkBlocks.get(0).getBody().getTransactions()) { assertThat(blockchain.getTransactionByHash(tx.hash())).isNotPresent(); removedTransactions.addAll(chain.get(i).getBody().getTransactions());
assertTotalDifficultiesAreConsistent(blockchain, originalHead); for (final Transaction tx : forkBlock.getBody().getTransactions()) { assertThat(blockchain.getTransactionByHash(tx.hash())).isNotPresent();
private void assertBlockMatchesResult( final Block targetBlock, final BlockWithMetadata<TransactionWithMetadata, Hash> result) { assertEquals(targetBlock.getHeader(), result.getHeader()); final List<Hash> expectedOmmers = targetBlock .getBody() .getOmmers() .stream() .map(BlockHeader::getHash) .collect(Collectors.toList()); assertEquals(expectedOmmers, result.getOmmers()); for (int i = 0; i < result.getTransactions().size(); i++) { final TransactionWithMetadata txResult = result.getTransactions().get(i); final Transaction targetTx = targetBlock.getBody().getTransactions().get(i); assertEquals(targetTx, txResult.getTransaction()); assertEquals(i, txResult.getTransactionIndex()); assertEquals(targetBlock.getHash(), txResult.getBlockHash()); assertEquals(targetBlock.getHeader().getNumber(), txResult.getBlockNumber()); } }
private byte[] serializeBlock(final Block block) { final BytesValueRLPOutput out = new BytesValueRLPOutput(); out.startList(); block.getHeader().writeTo(out); out.writeList(block.getBody().getTransactions(), Transaction::writeTo); out.writeList(block.getBody().getOmmers(), BlockHeader::writeTo); out.endList(); return out.encoded().extractArray(); } }