org.ethereum.net.eth.handler.Eth62 Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of ethereumj-core Show documentation
Show all versions of ethereumj-core Show documentation
Java implementation of the Ethereum protocol adapted to use for Hedera Smart Contract Service
The newest version!
/*
* Copyright (c) [2016] [ ]
* This file is part of the ethereumJ library.
*
* The ethereumJ library is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* The ethereumJ library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with the ethereumJ library. If not, see sentHeaders = Collections.synchronizedList(new ArrayList());
protected SettableFuture> futureBlocks;
protected final SyncStatistics syncStats = new SyncStatistics();
protected GetBlockHeadersMessageWrapper headerRequest;
private Map validatorMap;
protected long lastReqSentTime;
protected long connectedTime = System.currentTimeMillis();
protected long processingTime = 0;
private static final EthVersion version = V62;
public Eth62() {
this(version);
}
Eth62(final EthVersion version) {
super(version);
}
@Autowired
public Eth62(final SystemProperties config, final Blockchain blockchain,
final BlockStore blockStore, final CompositeEthereumListener ethereumListener) {
this(version, config, blockchain, blockStore, ethereumListener);
}
Eth62(final EthVersion version, final SystemProperties config,
final Blockchain blockchain, final BlockStore blockStore,
final CompositeEthereumListener ethereumListener) {
super(version, config, blockchain, blockStore, ethereumListener);
}
@Override
public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException {
super.channelRead0(ctx, msg);
switch (msg.getCommand()) {
case STATUS:
processStatus((StatusMessage) msg, ctx);
break;
case NEW_BLOCK_HASHES:
processNewBlockHashes((NewBlockHashesMessage) msg);
break;
case TRANSACTIONS:
processTransactions((TransactionsMessage) msg);
break;
case GET_BLOCK_HEADERS:
processGetBlockHeaders((GetBlockHeadersMessage) msg);
break;
case BLOCK_HEADERS:
processBlockHeaders((BlockHeadersMessage) msg);
break;
case GET_BLOCK_BODIES:
processGetBlockBodies((GetBlockBodiesMessage) msg);
break;
case BLOCK_BODIES:
processBlockBodies((BlockBodiesMessage) msg);
break;
case NEW_BLOCK:
processNewBlock((NewBlockMessage) msg);
break;
default:
break;
}
}
/*************************
* Message Sending *
*************************/
@Override
public synchronized void sendStatus() {
byte protocolVersion = getVersion().getCode();
int networkId = config.networkId();
final BigInteger totalDifficulty;
final byte[] bestHash;
if (syncManager.isFastSyncRunning()) {
// while fastsync is not complete reporting block #0
// until all blocks/receipts are downloaded
bestHash = blockstore.getBlockHashByNumber(0);
Block genesis = blockstore.getBlockByHash(bestHash);
totalDifficulty = genesis.getDifficultyBI();
} else {
// Getting it from blockstore, not blocked by blockchain sync
bestHash = blockstore.getBestBlock().getHash();
totalDifficulty = blockchain.getTotalDifficulty();
}
StatusMessage msg = new StatusMessage(protocolVersion, networkId,
ByteUtil.bigIntegerToBytes(totalDifficulty), bestHash, config.getGenesis().getHash());
sendMessage(msg);
ethState = EthState.STATUS_SENT;
sendNextHeaderRequest();
}
@Override
public synchronized void sendNewBlockHashes(Block block) {
BlockIdentifier identifier = new BlockIdentifier(block.getHash(), block.getNumber());
NewBlockHashesMessage msg = new NewBlockHashesMessage(singletonList(identifier));
sendMessage(msg);
}
@Override
public synchronized void sendTransaction(List txs) {
TransactionsMessage msg = new TransactionsMessage(txs);
sendMessage(msg);
}
@Override
public synchronized ListenableFuture> sendGetBlockHeaders(long blockNumber, int maxBlocksAsk, boolean reverse) {
if (ethState == EthState.STATUS_SUCCEEDED && peerState != IDLE) return null;
if(logger.isTraceEnabled()) logger.trace(
"Peer {}: queue GetBlockHeaders, blockNumber [{}], maxBlocksAsk [{}]",
channel.getPeerIdShort(),
blockNumber,
maxBlocksAsk
);
if (headerRequest != null) {
throw new RuntimeException("The peer is waiting for headers response: " + this);
}
GetBlockHeadersMessage headersRequest = new GetBlockHeadersMessage(blockNumber, null, maxBlocksAsk, 0, reverse);
GetBlockHeadersMessageWrapper messageWrapper = new GetBlockHeadersMessageWrapper(headersRequest);
headerRequest = messageWrapper;
sendNextHeaderRequest();
return messageWrapper.getFutureHeaders();
}
@Override
public synchronized ListenableFuture> sendGetBlockHeaders(byte[] blockHash, int maxBlocksAsk, int skip, boolean reverse) {
return sendGetBlockHeaders(blockHash, maxBlocksAsk, skip, reverse, false);
}
protected synchronized void sendGetNewBlockHeaders(byte[] blockHash, int maxBlocksAsk, int skip, boolean reverse) {
sendGetBlockHeaders(blockHash, maxBlocksAsk, skip, reverse, true);
}
protected synchronized ListenableFuture> sendGetBlockHeaders(byte[] blockHash, int maxBlocksAsk, int skip, boolean reverse, boolean newHashes) {
if (peerState != IDLE) return null;
if(logger.isTraceEnabled()) logger.trace(
"Peer {}: queue GetBlockHeaders, blockHash [{}], maxBlocksAsk [{}], skip[{}], reverse [{}]",
channel.getPeerIdShort(),
"0x" + toHexString(blockHash).substring(0, 8),
maxBlocksAsk, skip, reverse
);
if (headerRequest != null) {
throw new RuntimeException("The peer is waiting for headers response: " + this);
}
GetBlockHeadersMessage headersRequest = new GetBlockHeadersMessage(0, blockHash, maxBlocksAsk, skip, reverse);
GetBlockHeadersMessageWrapper messageWrapper = new GetBlockHeadersMessageWrapper(headersRequest, newHashes);
headerRequest = messageWrapper;
sendNextHeaderRequest();
lastReqSentTime = System.currentTimeMillis();
return messageWrapper.getFutureHeaders();
}
@Override
public synchronized ListenableFuture> sendGetBlockBodies(List headers) {
if (peerState != IDLE) return null;
peerState = BLOCK_RETRIEVING;
sentHeaders.clear();
sentHeaders.addAll(headers);
if(logger.isTraceEnabled()) logger.trace(
"Peer {}: send GetBlockBodies, hashes.count [{}]",
channel.getPeerIdShort(),
sentHeaders.size()
);
List hashes = new ArrayList<>(headers.size());
for (BlockHeaderWrapper header : headers) {
hashes.add(header.getHash());
}
GetBlockBodiesMessage msg = new GetBlockBodiesMessage(hashes);
sendMessage(msg);
lastReqSentTime = System.currentTimeMillis();
futureBlocks = SettableFuture.create();
return futureBlocks;
}
@Override
public synchronized void sendNewBlock(Block block) {
BigInteger parentTD = blockstore.getTotalDifficultyForHash(block.getParentHash());
byte[] td = ByteUtil.bigIntegerToBytes(parentTD.add(new BigInteger(1, block.getDifficulty())));
NewBlockMessage msg = new NewBlockMessage(block, td);
sendMessage(msg);
}
/*************************
* Message Processing *
*************************/
protected synchronized void processStatus(StatusMessage msg, ChannelHandlerContext ctx) throws InterruptedException {
try {
if (!Arrays.equals(msg.getGenesisHash(), config.getGenesis().getHash())) {
if (!peerDiscoveryMode) {
loggerNet.debug("Removing EthHandler for {} due to protocol incompatibility", ctx.channel().remoteAddress());
}
ethState = EthState.STATUS_FAILED;
disconnect(ReasonCode.INCOMPATIBLE_PROTOCOL);
ctx.pipeline().remove(this); // Peer is not compatible for the 'eth' sub-protocol
return;
}
if (msg.getNetworkId() != config.networkId()) {
ethState = EthState.STATUS_FAILED;
disconnect(ReasonCode.NULL_IDENTITY);
return;
}
// basic checks passed, update statistics
channel.getNodeStatistics().ethHandshake(msg);
ethereumListener.onEthStatusUpdated(channel, msg);
if (peerDiscoveryMode) {
loggerNet.trace("Peer discovery mode: STATUS received, disconnecting...");
disconnect(ReasonCode.REQUESTED);
ctx.close().sync();
ctx.disconnect().sync();
return;
}
// update bestKnownBlock info
sendGetBlockHeaders(msg.getBestHash(), 1, 0, false);
} catch (NoSuchElementException e) {
loggerNet.debug("EthHandler already removed");
}
}
protected synchronized void processNewBlockHashes(NewBlockHashesMessage msg) {
if(logger.isTraceEnabled()) logger.trace(
"Peer {}: processing NewBlockHashes, size [{}]",
channel.getPeerIdShort(),
msg.getBlockIdentifiers().size()
);
List identifiers = msg.getBlockIdentifiers();
if (identifiers.isEmpty()) return;
updateBestBlock(identifiers);
// queueing new blocks doesn't make sense
// while Long sync is in progress
if (!syncDone) return;
if (peerState != HEADER_RETRIEVING) {
long firstBlockAsk = Long.MAX_VALUE;
long lastBlockAsk = 0;
byte[] firstBlockHash = null;
for (BlockIdentifier identifier : identifiers) {
long blockNumber = identifier.getNumber();
if (blockNumber < firstBlockAsk) {
firstBlockAsk = blockNumber;
firstBlockHash = identifier.getHash();
}
if (blockNumber > lastBlockAsk) {
lastBlockAsk = blockNumber;
}
}
long maxBlocksAsk = lastBlockAsk - firstBlockAsk + 1;
if (firstBlockHash != null && maxBlocksAsk > 0 && maxBlocksAsk < MAX_HASHES_TO_SEND) {
sendGetNewBlockHeaders(firstBlockHash, (int) maxBlocksAsk, 0, false);
}
}
}
protected synchronized void processTransactions(TransactionsMessage msg) {
if(!processTransactions) {
return;
}
List txSet = msg.getTransactions();
List newPending = pendingState.addPendingTransactions(txSet);
if (!newPending.isEmpty()) {
TransactionTask transactionTask = new TransactionTask(newPending, channel.getChannelManager(), channel);
TransactionExecutor.instance.submitTransaction(transactionTask);
}
}
protected synchronized void processGetBlockHeaders(GetBlockHeadersMessage msg) {
Iterator headersIterator = blockchain.getIteratorOfHeadersStartFrom(
msg.getBlockIdentifier(),
msg.getSkipBlocks(),
min(msg.getMaxHeaders(), MAX_HASHES_TO_SEND),
msg.isReverse()
);
List blockHeaders = new ArrayList<>();
while (headersIterator.hasNext()) {
blockHeaders.add(headersIterator.next());
}
BlockHeadersMessage response = new BlockHeadersMessage(blockHeaders);
sendMessage(response);
}
protected synchronized void processBlockHeaders(BlockHeadersMessage msg) {
if(logger.isTraceEnabled()) logger.trace(
"Peer {}: processing BlockHeaders, size [{}]",
channel.getPeerIdShort(),
msg.getBlockHeaders().size()
);
GetBlockHeadersMessageWrapper request = headerRequest;
headerRequest = null;
if (!isValid(msg, request)) {
dropConnection();
return;
}
List received = msg.getBlockHeaders();
if (ethState == EthState.STATUS_SENT || ethState == EthState.HASH_CONSTRAINTS_CHECK)
processInitHeaders(received);
else {
syncStats.addHeaders(received.size());
request.getFutureHeaders().set(received);
}
processingTime += lastReqSentTime > 0 ? (System.currentTimeMillis() - lastReqSentTime) : 0;
lastReqSentTime = 0;
peerState = IDLE;
}
protected synchronized void processGetBlockBodies(GetBlockBodiesMessage msg) {
Iterator bodiesIterator = blockchain.getIteratorOfBodiesByHashes(msg.getBlockHashes());
List bodies = new ArrayList<>();
int sizeSum = 0;
while (bodiesIterator.hasNext()) {
byte[] body = bodiesIterator.next();
sizeSum += ByteArrayEstimator.estimateSize(body);
bodies.add(body);
if (sizeSum >= MAX_MESSAGE_SIZE) break;
}
BlockBodiesMessage response = new BlockBodiesMessage(bodies);
sendMessage(response);
}
protected synchronized void processBlockBodies(BlockBodiesMessage msg) {
if (logger.isTraceEnabled()) logger.trace(
"Peer {}: process BlockBodies, size [{}]",
channel.getPeerIdShort(),
msg.getBlockBodies().size()
);
if (!isValid(msg)) {
dropConnection();
return;
}
syncStats.addBlocks(msg.getBlockBodies().size());
List blocks = null;
try {
blocks = validateAndMerge(msg);
} catch (Exception e) {
logger.info("Fatal validation error while processing block bodies from peer {}", channel.getPeerIdShort());
}
if (blocks == null) {
// headers will be returned by #onShutdown()
dropConnection();
return;
}
futureBlocks.set(blocks);
futureBlocks = null;
processingTime += (System.currentTimeMillis() - lastReqSentTime);
lastReqSentTime = 0;
peerState = IDLE;
}
protected synchronized void processNewBlock(NewBlockMessage newBlockMessage) {
Block newBlock = newBlockMessage.getBlock();
logger.debug("New block received: block.index [{}]", newBlock.getNumber());
updateTotalDifficulty(newBlockMessage.getDifficultyAsBigInt());
updateBestBlock(newBlock);
if (!syncManager.validateAndAddNewBlock(newBlock, channel.getNodeId())) {
dropConnection();
}
}
/*************************
* Sync Management *
*************************/
@Override
public synchronized void onShutdown() {
}
@Override
public synchronized void fetchBodies(List headers) {
syncStats.reset();
sendGetBlockBodies(headers);
}
protected synchronized void sendNextHeaderRequest() {
// do not send header requests if status hasn't been passed yet
if (ethState == EthState.INIT) return;
GetBlockHeadersMessageWrapper wrapper = headerRequest;
if (wrapper == null || wrapper.isSent()) return;
peerState = HEADER_RETRIEVING;
wrapper.send();
sendMessage(wrapper.getMessage());
lastReqSentTime = System.currentTimeMillis();
}
protected synchronized void processInitHeaders(List received) {
final BlockHeader blockHeader = received.get(0);
final long blockNumber = blockHeader.getNumber();
if (ethState == EthState.STATUS_SENT) {
updateBestBlock(blockHeader);
logger.trace("Peer {}: init request succeeded, best known block {}",
channel.getPeerIdShort(), bestKnownBlock);
// checking if the peer has expected block hashes
ethState = EthState.HASH_CONSTRAINTS_CHECK;
validatorMap = Collections.synchronizedMap(new HashMap());
List> validators = config.getBlockchainConfig().
getConfigForBlock(blockNumber).headerValidators();
for (Pair validator : validators) {
if (validator.getLeft() <= getBestKnownBlock().getNumber()) {
validatorMap.put(validator.getLeft(), validator.getRight());
}
}
logger.trace("Peer " + channel.getPeerIdShort() + ": Requested " + validatorMap.size() +
" headers for hash check: " + validatorMap.keySet());
requestNextHashCheck();
} else {
BlockHeaderValidator validator = validatorMap.get(blockNumber);
if (validator != null) {
BlockHeaderRule.ValidationResult result = validator.validate(blockHeader);
if (result.success) {
validatorMap.remove(blockNumber);
requestNextHashCheck();
} else {
logger.debug("Peer {}: wrong fork ({}). Drop the peer and reduce reputation.", channel.getPeerIdShort(), result.error);
channel.getNodeStatistics().wrongFork = true;
dropConnection();
}
}
}
if (validatorMap.isEmpty()) {
ethState = EthState.STATUS_SUCCEEDED;
logger.trace("Peer {}: all validations passed", channel.getPeerIdShort());
}
}
private void requestNextHashCheck() {
if (!validatorMap.isEmpty()) {
final Long checkHeader = validatorMap.keySet().iterator().next();
sendGetBlockHeaders(checkHeader, 1, false);
logger.trace("Peer {}: Requested #{} header for hash check.", channel.getPeerIdShort(), checkHeader);
}
}
private void updateBestBlock(Block block) {
updateBestBlock(block.getHeader());
}
private void updateBestBlock(BlockHeader header) {
if (bestKnownBlock == null || header.getNumber() > bestKnownBlock.getNumber()) {
bestKnownBlock = new BlockIdentifier(header.getHash(), header.getNumber());
}
}
private void updateBestBlock(List identifiers) {
for (BlockIdentifier id : identifiers)
if (bestKnownBlock == null || id.getNumber() > bestKnownBlock.getNumber()) {
bestKnownBlock = id;
}
}
@Override
public BlockIdentifier getBestKnownBlock() {
return bestKnownBlock;
}
private void updateTotalDifficulty(BigInteger totalDiff) {
channel.getNodeStatistics().setEthTotalDifficulty(totalDiff);
this.totalDifficulty = totalDiff;
}
@Override
public BigInteger getTotalDifficulty() {
return totalDifficulty != null ? totalDifficulty : channel.getNodeStatistics().getEthTotalDifficulty();
}
/*************************
* Getters, setters *
*************************/
@Override
public boolean isHashRetrievingDone() {
return peerState == DONE_HASH_RETRIEVING;
}
@Override
public boolean isHashRetrieving() {
return peerState == HEADER_RETRIEVING;
}
@Override
public boolean hasStatusPassed() {
return ethState.ordinal() > EthState.HASH_CONSTRAINTS_CHECK.ordinal();
}
@Override
public boolean hasStatusSucceeded() {
return ethState == EthState.STATUS_SUCCEEDED;
}
@Override
public boolean isIdle() {
return peerState == IDLE;
}
@Override
public void enableTransactions() {
processTransactions = true;
}
@Override
public void disableTransactions() {
processTransactions = false;
}
@Override
public SyncStatistics getStats() {
return syncStats;
}
@Override
public void onSyncDone(boolean done) {
syncDone = done;
}
/*************************
* Validation *
*************************/
@Nullable
private List validateAndMerge(BlockBodiesMessage response) {
// merging received block bodies with requested headers
// the assumption is the following:
// - response may miss any bodies present in the request
// - response may not contain non-requested bodies
// - order of response bodies should be preserved
// Otherwise the response is assumed invalid and all bodies are dropped
List bodyList = response.getBlockBodies();
Iterator bodies = bodyList.iterator();
Iterator wrappers = sentHeaders.iterator();
List blocks = new ArrayList<>(bodyList.size());
List coveredHeaders = new ArrayList<>(sentHeaders.size());
boolean blockMerged = true;
byte[] body = null;
while (bodies.hasNext() && wrappers.hasNext()) {
BlockHeaderWrapper wrapper = wrappers.next();
if (blockMerged) {
body = bodies.next();
}
Block b = new Block.Builder()
.withHeader(wrapper.getHeader())
.withBody(body)
.create();
if (b == null) {
blockMerged = false;
} else {
blockMerged = true;
coveredHeaders.add(wrapper);
blocks.add(b);
}
}
if (bodies.hasNext()) {
logger.info("Peer {}: invalid BLOCK_BODIES response: at least one block body doesn't correspond to any of requested headers: ",
channel.getPeerIdShort(), toHexString(bodies.next()));
return null;
}
// remove headers covered by response
sentHeaders.removeAll(coveredHeaders);
return blocks;
}
private boolean isValid(BlockBodiesMessage response) {
return response.getBlockBodies().size() <= sentHeaders.size();
}
protected boolean isValid(BlockHeadersMessage response, GetBlockHeadersMessageWrapper requestWrapper) {
GetBlockHeadersMessage request = requestWrapper.getMessage();
List headers = response.getBlockHeaders();
// max headers
if (headers.size() > request.getMaxHeaders()) {
if (logger.isInfoEnabled()) logger.info(
"Peer {}: invalid response to {}, exceeds maxHeaders limit, headers count={}",
channel.getPeerIdShort(), request, headers.size()
);
return false;
}
// emptiness against best known block
if (headers.isEmpty()) {
// initial call after handshake
if (ethState == EthState.STATUS_SENT || ethState == EthState.HASH_CONSTRAINTS_CHECK) {
if (logger.isInfoEnabled()) logger.info(
"Peer {}: invalid response to initial {}, empty",
channel.getPeerIdShort(), request
);
return false;
}
if (request.getBlockHash() == null &&
request.getBlockNumber() <= bestKnownBlock.getNumber()) {
if (logger.isInfoEnabled()) logger.info(
"Peer {}: invalid response to {}, it's empty while bestKnownBlock is {}",
channel.getPeerIdShort(), request, bestKnownBlock
);
return false;
}
return true;
}
// first header
BlockHeader first = headers.get(0);
if (request.getBlockHash() != null) {
if (!Arrays.equals(request.getBlockHash(), first.getHash())) {
if (logger.isInfoEnabled()) logger.info(
"Peer {}: invalid response to {}, first header is invalid {}",
channel.getPeerIdShort(), request, first
);
return false;
}
} else {
if (request.getBlockNumber() != first.getNumber()) {
if (logger.isInfoEnabled()) logger.info(
"Peer {}: invalid response to {}, first header is invalid {}",
channel.getPeerIdShort(), request, first
);
return false;
}
}
// skip following checks in case of NEW_BLOCK_HASHES handling
if (requestWrapper.isNewHashesHandling()) return true;
// numbers and ancestors
int offset = 1 + request.getSkipBlocks();
if (request.isReverse()) offset = -offset;
for (int i = 1; i < headers.size(); i++) {
BlockHeader cur = headers.get(i);
BlockHeader prev = headers.get(i - 1);
long num = cur.getNumber();
long expectedNum = prev.getNumber() + offset;
if (num != expectedNum) {
if (logger.isInfoEnabled()) logger.info(
"Peer {}: invalid response to {}, got #{}, expected #{}",
channel.getPeerIdShort(), request, num, expectedNum
);
return false;
}
if (request.getSkipBlocks() == 0) {
BlockHeader parent;
BlockHeader child;
if (request.isReverse()) {
parent = cur;
child = prev;
} else {
parent = prev;
child = cur;
}
if (!Arrays.equals(child.getParentHash(), parent.getHash())) {
if (logger.isInfoEnabled()) logger.info(
"Peer {}: invalid response to {}, got parent hash {} for #{}, expected {}",
channel.getPeerIdShort(), request, toHexString(child.getParentHash()),
prev.getNumber(), toHexString(parent.getHash())
);
return false;
}
}
}
return true;
}
@Override
public synchronized void dropConnection() {
logger.info("Peer {}: is a bad one, drop", channel.getPeerIdShort());
disconnect(USELESS_PEER);
}
/*************************
* Logging *
*************************/
@Override
public String getSyncStats() {
int waitResp = lastReqSentTime > 0 ? (int) (System.currentTimeMillis() - lastReqSentTime) / 1000 : 0;
long lifeTime = System.currentTimeMillis() - connectedTime;
return String.format(
"Peer %s: [ %s, %18s, ping %6s ms, rep: %s, difficulty %s, best block %s%s]: (idle %s of %s) %s",
getVersion(),
channel.getPeerIdShort(),
peerState,
(int)channel.getPeerStats().getAvgLatency(),
channel.getNodeStatistics().getReputation(),
getTotalDifficulty(),
getBestKnownBlock().getNumber(),
waitResp > 5 ? ", wait " + waitResp + "s" : " ",
longToTimePeriod(lifeTime - processingTime),
longToTimePeriod(lifeTime),
channel.getNodeStatistics().getClientId());
}
protected enum EthState {
INIT,
STATUS_SENT,
HASH_CONSTRAINTS_CHECK,
STATUS_SUCCEEDED,
STATUS_FAILED
}
}