Java EthereumListener类代码示例

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
public BlockChainImpl(RskSystemProperties config,
                      Repository repository,
                      BlockStore blockStore,
                      ReceiptStore receiptStore,
                      PendingState pendingState,
                      EthereumListener listener,
                      AdminInfo adminInfo,
                      BlockValidator blockValidator) {
    this.config = config;
    this.repository = repository;
    this.blockStore = blockStore;
    this.receiptStore = receiptStore;
    this.listener = listener;
    this.adminInfo = adminInfo;
    this.blockValidator = blockValidator;
    this.blockExecutor = new BlockExecutor(config, repository, this, blockStore, listener);

    setPendingState(pendingState);
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
public PendingStateImpl(RskSystemProperties config,
                        Blockchain blockChain,
                        Repository repository,
                        BlockStore blockStore,
                        ProgramInvokeFactory programInvokeFactory,
                        EthereumListener listener,
                        int outdatedThreshold,
                        int outdatedTimeout) {
    this.config = config;
    this.blockChain = blockChain;
    this.blockStore = blockStore;
    this.repository = repository;
    this.programInvokeFactory = programInvokeFactory;
    this.listener = listener;
    this.outdatedThreshold = outdatedThreshold;
    this.outdatedTimeout = outdatedTimeout;

    this.pendingStateRepository = repository.startTracking();
    this.bestBlock = blockChain.getBestBlock();

    if (this.outdatedTimeout > 0) {
        this.cleanerTimer = Executors.newSingleThreadScheduledExecutor(r -> new Thread(r, "PendingStateCleanerTimer"));
    }
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
@Bean
public BlockChainImpl getBlockchain(org.ethereum.core.Repository repository,
                                    org.ethereum.db.BlockStore blockStore,
                                    ReceiptStore receiptStore,
                                    EthereumListener listener,
                                    AdminInfo adminInfo,
                                    BlockValidator blockValidator,
                                    RskSystemProperties config) {
    return new BlockChainImpl(
            config,
            repository,
            blockStore,
            receiptStore,
            null, // circular dependency
            listener,
            adminInfo,
            blockValidator
    );
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
@Bean
public PendingState getPendingState(BlockChainImpl blockchain,
                                    org.ethereum.db.BlockStore blockStore,
                                    org.ethereum.core.Repository repository,
                                    RskSystemProperties config,
                                    ProgramInvokeFactory programInvokeFactory,
                                    EthereumListener listener) {
    PendingStateImpl pendingState = new PendingStateImpl(
            blockchain,
            blockStore,
            listener,
            programInvokeFactory,
            repository,
            config
    );
    // circular dependency
    blockchain.setPendingState(pendingState);
    return pendingState;
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
@Bean
public EthereumChannelInitializer.ChannelFactory getChannelFactory(RskSystemProperties config,
                                                                   EthereumListener ethereumListener,
                                                                   ConfigCapabilities configCapabilities,
                                                                   NodeManager nodeManager,
                                                                   EthHandlerFactory ethHandlerFactory,
                                                                   StaticMessages staticMessages,
                                                                   PeerScoringManager peerScoringManager) {
    return () -> {
        HandshakeHandler handshakeHandler = new HandshakeHandler(config, peerScoringManager);
        MessageQueue messageQueue = new MessageQueue();
        P2pHandler p2pHandler = new P2pHandler(config, ethereumListener, configCapabilities);
        MessageCodec messageCodec = new MessageCodec(ethereumListener, config);
        return new Channel(config, messageQueue, p2pHandler, messageCodec, handshakeHandler, nodeManager, ethHandlerFactory, staticMessages);
    };
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
@Autowired
public WorldManagerImpl(RskSystemProperties config,
                        Blockchain blockchain,
                        BlockStore blockStore,
                        PendingState pendingState,
                        Repository repository,
                        NetworkStateExporter networkStateExporter,
                        HashRateCalculator hashRateCalculator,
                        ConfigCapabilities configCapabilities,
                        ChannelManager channelManager,
                        EthereumListener listener,
                        BlockProcessor nodeBlockProcessor) {
    this.blockchain = blockchain;
    this.blockStore = blockStore;
    this.pendingState = pendingState;
    this.repository = repository;
    this.hashRateCalculator = hashRateCalculator;
    this.configCapabilities = configCapabilities;
    this.listener = listener;
    this.nodeBlockProcessor = nodeBlockProcessor;

    BlockChainLoader loader = new BlockChainLoader(config, this.blockchain, this.blockStore, this.repository, this.listener);
    loader.loadBlockchain();
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
public TransactionExecutor(RskSystemProperties config, Transaction tx, int txindex, byte[] coinbase, Repository track, BlockStore blockStore, ReceiptStore receiptStore,
                           ProgramInvokeFactory programInvokeFactory, Block executionBlock,
                           EthereumListener listener, long gasUsedInTheBlock) {
    this.config = config;
    this.tx = tx;
    this.txindex = txindex;
    this.coinbase = coinbase;
    this.track = track;
    this.cacheTrack = track.startTracking();
    this.blockStore = blockStore;
    this.receiptStore = receiptStore;
    this.programInvokeFactory = programInvokeFactory;
    this.executionBlock = executionBlock;
    this.listener = listener;
    this.gasUsedInTheBlock = gasUsedInTheBlock;
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
public void fastSyncCleanUp() {
    byte[] fastsyncStageBytes = blockchainDB().get(FastSyncManager.FASTSYNC_DB_KEY_SYNC_STAGE);
    if (fastsyncStageBytes == null) return; // no uncompleted fast sync

    EthereumListener.SyncState syncStage = EthereumListener.SyncState.values()[fastsyncStageBytes[0]];

    if (!systemProperties().isFastSyncEnabled() || syncStage == EthereumListener.SyncState.UNSECURE) {
        // we need to cleanup state/blocks/tranasaction DBs when previous fast sync was not complete:
        // - if we now want to do regular sync
        // - if the first fastsync stage was not complete (thus DBs are not in consistent state)

        logger.warn("Last fastsync was interrupted. Removing inconsistent DBs...");

        DbSource bcSource = blockchainDB();
        resetDataSource(bcSource);
    }
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
private void syncSecure() {
    pivot = new BlockHeader(blockchainDB.get(FASTSYNC_DB_KEY_PIVOT));

    logger.info("FastSync: downloading headers from pivot down to genesis block for ensure pivot block (" + pivot.getShortDescr() + ") is secure...");
    headersDownloader = applicationContext.getBean(HeadersDownloader.class);
    headersDownloader.init(pivot.getHash());
    setSyncStage(EthereumListener.SyncState.SECURE);
    headersDownloader.waitForStop();
    if (!FastByteComparisons.equal(headersDownloader.getGenesisHash(), config.getGenesis().getHash())) {
        logger.error("FASTSYNC FATAL ERROR: after downloading header chain starting from the pivot block (" +
                pivot.getShortDescr() + ") obtained genesis block doesn't match ours: " + Hex.toHexString(headersDownloader.getGenesisHash()));
        logger.error("Can't recover and exiting now. You need to restart from scratch (all DBs will be reset)");
        System.exit(-666);
    }
    dbFlushManager.commit();
    dbFlushManager.flush();
    logger.info("FastSync: all headers downloaded. The state is SECURE now.");
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
void initRegularSync(EthereumListener.SyncState syncDoneType) {
    logger.info("Initializing SyncManager regular sync.");
    this.syncDoneType = syncDoneType;

    syncQueue = new SyncQueueImpl(blockchain);
    super.init(syncQueue, pool);

    Runnable queueProducer = new Runnable(){

        @Override
        public void run() {
            produceQueue();
        }
    };

    syncQueueThread = new Thread (queueProducer, "SyncQueueThread");
    syncQueueThread.start();
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
public TransactionExecutor(Transaction tx, byte[] coinbase, Repository track, BlockStore blockStore,
                           ProgramInvokeFactory programInvokeFactory, Block currentBlock,
                           EthereumListener listener, long gasUsedInTheBlock) {

    this.tx = tx;
    this.coinbase = coinbase;
    this.track = track;
    this.cacheTrack = track.startTracking();
    this.blockStore = blockStore;
    this.programInvokeFactory = programInvokeFactory;
    this.currentBlock = currentBlock;
    this.listener = listener;
    this.gasUsedInTheBlock = gasUsedInTheBlock;
    this.m_endGas = toBI(tx.getGasLimit());
    withCommonConfig(CommonConfig.getDefault());
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
private void onPendingTransactionUpdate(TransactionReceipt txReceipt, EthereumListener.PendingTransactionState state, Block block) {
    byte[] txHash = txReceipt.getTransaction().getHash();
    Pair<Long, TransactionResultDTO> removed = remoteTxs.remove(txHash);
    if (state == EthereumListener.PendingTransactionState.DROPPED) {
        if (localTxs.remove(txHash) != null) {
            System.out.println("Dropped due to timeout (matchned: " + (removed != null) + "): " + Hex.toHexString(txHash));
        } else {
            if (remoteTxs.containsKey(txHash)) {
                System.err.println("Dropped but matching: "  + Hex.toHexString(txHash) + ": \n" + txReceipt);
            }
        }
    } else if (state == EthereumListener.PendingTransactionState.NEW_PENDING) {
        System.out.println("Local: " + Hex.toHexString(txHash));
        if (removed == null) {
            localTxs.put(txHash, Triple.of(System.currentTimeMillis(), txReceipt, state));
        } else {
            System.out.println("Tx matched: " + Hex.toHexString(txHash));
        }
    }
    checkUnmatched();
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
@Test
public void testBlockOnlyIncluded() throws InterruptedException {
    StandaloneBlockchain bc = new StandaloneBlockchain();
    PendingListener l = new PendingListener();
    bc.addEthereumListener(l);
    Triple<TransactionReceipt, EthereumListener.PendingTransactionState, Block> txUpd = null;
    PendingStateImpl pendingState = (PendingStateImpl) bc.getBlockchain().getPendingState();

    ECKey alice = new ECKey();
    ECKey bob = new ECKey();

    bc.sendEther(bob.getAddress(), convert(100, ETHER));

    Block b1 = bc.createBlock();

    Transaction tx1 = bc.createTransaction(bob, 0, alice.getAddress(), BigInteger.valueOf(1000000), new byte[0]);
    bc.submitTransaction(tx1);
    Block b2 = bc.createBlock();

    Block b2_ = bc.createForkBlock(b1);
    Assert.assertTrue(l.getQueueFor(tx1).isEmpty());
    Block b3_ = bc.createForkBlock(b2_);
    txUpd = l.pollTxUpdate(tx1);
    Assert.assertEquals(txUpd.getMiddle(), PENDING);
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
@Override
public PeerInfo findOnlinePeer(Set<PeerInfo> excludePeers)  {
    logger.info("Looking for online peers...");

    final EthereumListener listener = WorldManager.getInstance().getListener();
    if (listener != null) {
        listener.trace("Looking for online peer");
    }

    WorldManager.getInstance().startPeerDiscovery();

    final Set<PeerInfo> peers = WorldManager.getInstance().getPeerDiscovery().getPeers();
    synchronized (peers) {
        for (PeerInfo peer : peers) { // it blocks until a peer is available.
if (peer.isOnline() && !excludePeers.contains(peer)) {
                logger.info("Found peer: {}", peer.toString());
                if (listener != null)
                    listener.trace(String.format("Found online peer: [ %s ]", peer.toString()));
                return peer;
            }
        }
    }
    return null;
}
 

import org.ethereum.listener.EthereumListener; //导入依赖的package包/类
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {

	if (!isValidEthereumPacket(in)) {
		return;
	}

	byte[] encoded = new byte[in.readInt()];
	in.readBytes(encoded);

	if (loggerWire.isDebugEnabled())
		loggerWire.debug("Encoded: [{}]", Hex.toHexString(encoded));

	Message msg = MessageFactory.createMessage(encoded);

	if (loggerNet.isInfoEnabled())
           loggerNet.info("From: \t{} \tRecv: \t{}", ctx.channel().remoteAddress(), msg);

	out.add(msg);
       in.markReaderIndex();

       EthereumListener ethereumListener = WorldManager.getInstance().getListener();
       if (ethereumListener != null) {
           ethereumListener.onRecvMessage(msg);
       }
   }