Java EthereumListenerAdapter类代码示例

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
private org.ethereum.core.TransactionExecutor callConstantImpl(Transaction tx, Block block) {

        Repository repository = ((Repository) worldManager.getRepository())
                .getSnapshotTo(block.getStateRoot())
                .startTracking();

        try {
            org.ethereum.core.TransactionExecutor executor = new org.ethereum.core.TransactionExecutor
                    (tx, block.getCoinbase(), repository, worldManager.getBlockStore(),
                            programInvokeFactory, block, new EthereumListenerAdapter(), 0)
                    .withCommonConfig(commonConfig)
                    .setLocalCall(true);

            executor.init();
            executor.execute();
            executor.go();
            executor.finalization();

            return executor;
        } finally {
            repository.rollback();
        }
    }
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
private TransactionReceipt executeTx(Transaction tx) {

        logger.trace("Apply pending state tx: {}", Hex.toHexString(tx.getHash()));

        Block best = getBestBlock();

        TransactionExecutor executor = new TransactionExecutor(
                tx, best.getCoinbase(), getRepository(),
                blockStore, programInvokeFactory, createFakePendingBlock(), new EthereumListenerAdapter(), 0)
                .withCommonConfig(commonConfig);

        executor.init();
        executor.execute();
        executor.go();
        executor.finalization();

        return executor.getReceipt();
    }
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
@Test
public void test1() throws InterruptedException {

    setupPeers();

    // A == b10, B == genesis

    final CountDownLatch semaphore = new CountDownLatch(1);
    ethereumB.addListener(new EthereumListenerAdapter() {
        @Override
        public void onBlock(Block block, List<TransactionReceipt> receipts) {
            if (block.isEqual(b10)) {
                semaphore.countDown();
            }
        }
    });

    semaphore.await(40, SECONDS);

    // check if B == b10
    if(semaphore.getCount() > 0) {
        fail("PeerB bestBlock is incorrect");
    }
}
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
@Ignore
@Test
public void relaunchTest() throws InterruptedException {

    while (true) {
        Ethereum ethereum = EthereumFactory.createEthereum();
        Block bestBlock = ethereum.getBlockchain().getBestBlock();
        Assert.assertNotNull(bestBlock);
        final CountDownLatch latch = new CountDownLatch(1);
        ethereum.addListener(new EthereumListenerAdapter() {
            int counter = 0;
            @Override
            public void onBlock(Block block, List<TransactionReceipt> receipts) {
                counter++;
                if (counter > 1100) latch.countDown();
            }
        });
        System.out.println("### Waiting for some blocks to be imported...");
        latch.await();
        System.out.println("### Closing Ethereum instance");
        ethereum.close();
        Thread.sleep(5000);
        System.out.println("### Closed.");
    }
}
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
public TransactionReceipt createCallTxAndExecute(CallArguments args, Block block, Repository repository, BlockStore blockStore) throws Exception {
    BinaryCallArguments bca = new BinaryCallArguments();
    bca.setArguments(args);
    Transaction tx = CallTransaction.createRawTransaction(0,
            bca.gasPrice,
            bca.gasLimit,
            bca.toAddress,
            bca.value,
            bca.data);

    // put mock signature if not present
    if (tx.getSignature() == null) {
        tx.sign(ECKey.fromPrivate(new byte[32]));
    }

    try {
        TransactionExecutor executor = new TransactionExecutor
                (tx, block.getCoinbase(), repository, blockStore,
                        programInvokeFactory, block, new EthereumListenerAdapter(), 0)
                .withCommonConfig(commonConfig)
                .setLocalCall(true);

        executor.init();
        executor.execute();
        executor.go();
        executor.finalization();

        return executor.getReceipt();
    } finally {
        repository.rollback();
    }
}
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
@Autowired
public void setEthereumListener(CompositeEthereumListener listener) {
    if (!flushAfterSyncDone) return;
    listener.addListener(new EthereumListenerAdapter() {
        @Override
        public void onSyncDone(SyncState state) {
            if (state == SyncState.COMPLETE) {
                logger.info("DbFlushManager: long sync done, flushing each block now");
                syncDone = true;
            }
        }
    });
}
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
@Override
public BlockchainImpl getBlockchain() {
    if (blockchain == null) {
        blockchain = createBlockchain(genesis);
        blockchain.setMinerCoinbase(coinbase);
        addEthereumListener(new EthereumListenerAdapter() {
            @Override
            public void onBlock(BlockSummary blockSummary) {
                lastSummary = blockSummary;
            }
        });
    }
    return blockchain;
}
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
@Override
public void onSyncDone() {
    ethereum.addListener(new EthereumListenerAdapter() {
        // listening here when the PendingState is updated with new transactions
        @Override
        public void onPendingTransactionsReceived(List<Transaction> transactions) {
            for (Transaction tx : transactions) {
                PendingStateSample.this.onPendingTransactionReceived(tx);
            }
        }

        // when block arrives look for our included transactions
        @Override
        public void onBlock(Block block, List<TransactionReceipt> receipts) {
            PendingStateSample.this.onBlock(block, receipts);
        }
    });

    new Thread("PendingStateSampleThread") {
        @Override
        public void run() {
            try {
                sendTransactions();
            } catch (Exception e) {
                logger.error("Error while sending transactions", e);
            }
        }
    }.start();
}
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
@Override
public void onSyncDone() throws Exception {
    ethereum.addListener(new EthereumListenerAdapter() {
        // when block arrives look for our included transactions
        @Override
        public void onBlock(Block block, List<TransactionReceipt> receipts) {
            SendTransaction.this.onBlock(block, receipts);
        }
    });


    String toAddress = "";
    logger.info("Sending transaction to net and waiting for inclusion");
    sendTxAndWait(Hex.decode(toAddress), new byte[0]);
    logger.info("Transaction included!");}
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
public BlockchainImpl(final BlockStore blockStore, final Repository repository) {
    this.blockStore = blockStore;
    this.repository = repository;
    this.adminInfo = new AdminInfo();
    this.listener = new EthereumListenerAdapter();
    this.parentHeaderValidator = null;
    this.transactionStore = new TransactionStore(new HashMapDB());
    this.eventDispatchThread = EventDispatchThread.getDefault();
    this.programInvokeFactory = new ProgramInvokeFactoryImpl();
    initConst(SystemProperties.getDefault());
}
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
@PostConstruct
void init() {
    System.out.println("========= init");
    worldManager.addListener(new EthereumListenerAdapter() {
        @Override
        public void onHandShakePeer(Channel channel, HelloMessage helloMessage) {
            System.out.println("========= onHandShakePeer");
            if (!isAlive()) {
                start();
            }
        }
    });
}
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
@Test
public void test2() throws InterruptedException {

    SysPropConfigA.eth62 = new Eth62() {

        @Override
        protected void processGetBlockBodies(GetBlockBodiesMessage msg) {
            List<byte[]> bodies = Arrays.asList(
                    mainB1B10.get(0).getEncodedBody()
            );

            BlockBodiesMessage response = new BlockBodiesMessage(bodies);
            sendMessage(response);
        }
    };

    setupPeers();

    // A == b10, B == genesis

    final CountDownLatch semaphoreDisconnect = new CountDownLatch(1);
    ethereumA.addListener(new EthereumListenerAdapter() {
        @Override
        public void onRecvMessage(Channel channel, Message message) {
            if (message instanceof DisconnectMessage) {
                semaphoreDisconnect.countDown();
            }
        }
    });

    semaphoreDisconnect.await(10, SECONDS);

    // check if peer was dropped
    if(semaphoreDisconnect.getCount() > 0) {
        fail("PeerA is not dropped");
    }
}
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
private void setupPeers(Block best) throws InterruptedException {

        ethereumA = EthereumFactory.createEthereum(SysPropConfigA.class);

        Blockchain blockchainA = (Blockchain) ethereumA.getBlockchain();
        for (Block b : mainB1B10) {
            ImportResult result = blockchainA.tryToConnect(b);
            Assert.assertEquals(result, ImportResult.IMPORTED_BEST);
            if (b.equals(best)) break;
        }

        // A == best

        ethereumB = EthereumFactory.createEthereum(SysPropConfigB.props, SysPropConfigB.class);

        ethereumA.addListener(new EthereumListenerAdapter() {
            @Override
            public void onEthStatusUpdated(Channel channel, StatusMessage statusMessage) {
                ethA = (EthHandler) channel.getEthHandler();
            }
        });

        final CountDownLatch semaphore = new CountDownLatch(1);

        ethereumB.addListener(new EthereumListenerAdapter() {
            @Override
            public void onPeerAddedToSyncPool(Channel peer) {
                semaphore.countDown();
            }
        });

        ethereumB.connect(nodeA);

        semaphore.await(10, SECONDS);
        if(semaphore.getCount() > 0) {
            fail("Failed to set up peers");
        }
    }
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
@Test
public void test1() throws InterruptedException {

    setupPeers();

    // A == B == genesis

    Blockchain blockchainA = (Blockchain) ethereumA.getBlockchain();

    for (Block b : mainB1B10) {
        blockchainA.tryToConnect(b);
    }

    // A == b10, B == genesis

    final CountDownLatch semaphore = new CountDownLatch(1);
    ethereumB.addListener(new EthereumListenerAdapter() {
        @Override
        public void onBlock(Block block, List<TransactionReceipt> receipts) {
            if (block.isEqual(b10)) {
                semaphore.countDown();
            }
        }
    });

    ethA.sendNewBlock(b10);

    semaphore.await(10, SECONDS);

    // check if B == b10
    if(semaphore.getCount() > 0) {
        fail("PeerB bestBlock is incorrect");
    }
}
 

import org.ethereum.listener.EthereumListenerAdapter; //导入依赖的package包/类
@Test
public void test2() throws InterruptedException {

    setupPeers();

    // A == B == genesis

    Blockchain blockchainA = (Blockchain) ethereumA.getBlockchain();

    for (Block b : forkB1B5B8_) {
        blockchainA.tryToConnect(b);
    }

    // A == b8', B == genesis

    final CountDownLatch semaphore = new CountDownLatch(1);
    ethereumB.addListener(new EthereumListenerAdapter() {
        @Override
        public void onBlock(Block block, List<TransactionReceipt> receipts) {
            if (block.isEqual(b8_)) {
                semaphore.countDown();
            }
        }
    });

    ethA.sendNewBlock(b8_);

    semaphore.await(10, SECONDS);

    // check if B == b8'
    if(semaphore.getCount() > 0) {
        fail("PeerB bestBlock is incorrect");
    }
}