Java BlockStore类代码示例

import org.ethereum.db.BlockStore; //导入依赖的package包/类
public Web3RskImpl(Ethereum eth,
                   WorldManager worldManager,
                   RskSystemProperties properties,
                   MinerClient minerClient,
                   MinerServer minerServer,
                   PersonalModule personalModule,
                   EthModule ethModule,
                   ChannelManager channelManager,
                   Repository repository,
                   PeerScoringManager peerScoringManager,
                   NetworkStateExporter networkStateExporter,
                   BlockStore blockStore,
                   PeerServer peerServer) {
    super(eth, worldManager, properties, minerClient, minerServer, personalModule, ethModule, channelManager, repository, peerScoringManager, peerServer);
    this.networkStateExporter = networkStateExporter;
    this.blockStore = blockStore;
}
 

import org.ethereum.db.BlockStore; //导入依赖的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.db.BlockStore; //导入依赖的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.db.BlockStore; //导入依赖的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.db.BlockStore; //导入依赖的package包/类
public static Set<ByteArrayWrapper> getAncestors(BlockStore blockStore, long blockNumber, byte[] parentHash, int limitNum) {
    Set<ByteArrayWrapper> ret = new HashSet<>();

    if (blockStore == null) {
        return ret;
    }

    int limit = (int) max(0, blockNumber - limitNum);
    Block it = blockStore.getBlockByHash(parentHash);

    while(it != null && it.getNumber() >= limit) {
        ret.add(new ByteArrayWrapper(it.getHash()));
        it = blockStore.getBlockByHash(it.getParentHash());
    }

    return ret;
}
 

import org.ethereum.db.BlockStore; //导入依赖的package包/类
public static Set<ByteArrayWrapper> getUsedUncles(BlockStore blockStore, long blockNumber, byte[] parentHash, int limitNum) {
    Set<ByteArrayWrapper> ret = new HashSet<>();

    if (blockStore == null) {
        return ret;
    }

    long minNumber = max(0, blockNumber - limitNum);
    Block it = blockStore.getBlockByHash(parentHash);

    while(it != null && it.getNumber() >= minNumber) {
        for (BlockHeader uncle : it.getUncleList()) {
            ret.add(new ByteArrayWrapper(uncle.getHash()));
        }
        it = blockStore.getBlockByHash(it.getParentHash());
    }

    return ret;
}
 

import org.ethereum.db.BlockStore; //导入依赖的package包/类
public static TransactionExecutor executeTransaction(RskSystemProperties config,
                                                     Repository track,
                                                     BlockStore blockStore,
                                                     ReceiptStore receiptStore,
                                                     ProgramInvokeFactory programInvokeFactory,
                                                     Block executionBlock,
                                                     byte[] coinbase,
                                                     byte[] gasPrice,
                                                     byte[] gasLimit,
                                                     byte[] toAddress,
                                                     byte[] value,
                                                     byte[] data,
                                                     byte[] fromAddress) {
    Repository repository = track.getSnapshotTo(executionBlock.getStateRoot()).startTracking();

    byte[] nonce = repository.getNonce(fromAddress).toByteArray();
    UnsignedTransaction tx = new UnsignedTransaction(nonce, gasPrice, gasLimit, toAddress, value, data, fromAddress);

    ReversibleTransactionExecutor executor = new ReversibleTransactionExecutor(config, tx, coinbase, repository, blockStore, receiptStore, programInvokeFactory, executionBlock);
    return executor.executeTransaction();
}
 

import org.ethereum.db.BlockStore; //导入依赖的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.db.BlockStore; //导入依赖的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.db.BlockStore; //导入依赖的package包/类
@Test
public void web3_ext_dumpState() throws Exception {
    Rsk rsk = Mockito.mock(Rsk.class);
    WorldManager worldManager = Mockito.mock(WorldManager.class);
    Blockchain blockchain = Mockito.mock(Blockchain.class);

    NetworkStateExporter networkStateExporter = Mockito.mock(NetworkStateExporter.class);
    Mockito.when(networkStateExporter.exportStatus(Mockito.anyString())).thenReturn(true);

    Block block = Mockito.mock(Block.class);
    Mockito.when(block.getHash()).thenReturn(PegTestUtils.createHash3().getBytes());
    Mockito.when(block.getNumber()).thenReturn(1L);

    BlockStore blockStore = Mockito.mock(BlockStore.class);
    Mockito.when(blockStore.getBestBlock()).thenReturn(block);
    Mockito.when(networkStateExporter.exportStatus(Mockito.anyString())).thenReturn(true);

    Mockito.when(worldManager.getBlockchain()).thenReturn(blockchain);
    Mockito.when(blockchain.getBestBlock()).thenReturn(block);

    Wallet wallet = WalletFactory.createWallet();
    PersonalModule pm = new PersonalModuleWalletEnabled(ConfigHelper.CONFIG, rsk, wallet, null);
    EthModule em = new EthModule(ConfigHelper.CONFIG, rsk, new EthModuleSolidityDisabled(), new EthModuleWalletEnabled(ConfigHelper.CONFIG, rsk, wallet, null));
    Web3RskImpl web3 = new Web3RskImpl(rsk, worldManager, ConfigHelper.CONFIG, Web3Mocks.getMockMinerClient(), Web3Mocks.getMockMinerServer(), pm, em, Web3Mocks.getMockChannelManager(), Web3Mocks.getMockRepository(), null, networkStateExporter, blockStore, null);
    web3.ext_dumpState();
}
 

import org.ethereum.db.BlockStore; //导入依赖的package包/类
@Before
public void init() {
    blockStore = Mockito.mock(BlockStore.class);
    block = Mockito.mock(Block.class);
    blockHeader = Mockito.mock(BlockHeader.class);

    Mockito.when(block.getHeader()).thenReturn(blockHeader);
    Mockito.when(block.getHash()).thenReturn(FAKE_GENERIC_HASH);
    Mockito.when(blockHeader.getParentHash()).thenReturn(FAKE_GENERIC_HASH)
            .thenReturn(OHTER_FAKE_GENERIC_HASH)
            .thenReturn(FAKE_GENERIC_HASH)
            .thenReturn(null);

    Mockito.when(blockHeader.getHash()).thenReturn(FAKE_GENERIC_HASH);

    Mockito.when(blockStore.getBlockByHash(Mockito.any())).thenReturn(block)
            .thenReturn(block).thenReturn(block).thenReturn(null);

    Mockito.when(blockStore.getBestBlock()).thenReturn(block);
    Mockito.when(blockStore.getBlockByHash(Mockito.any())).thenReturn(block);
}
 

import org.ethereum.db.BlockStore; //导入依赖的package包/类
@Test
public void rejectBlockWithSiblingUncle() {
    Block genesis = BlockGenerator.getInstance().getGenesisBlock();

    Block block1 = BlockGenerator.getInstance().createChildBlock(genesis);
    Block uncle = BlockGenerator.getInstance().createChildBlock(block1);
    List<BlockHeader> uncles = new ArrayList<>();
    uncles.add(uncle.getHeader());

    Block block = BlockGenerator.getInstance().createChildBlock(block1, null, uncles, 1, null);

    BlockChainImpl blockChain = BlockChainImplTest.createBlockChain();
    BlockStore store = blockChain.getBlockStore();

    store.saveBlock(genesis, BigInteger.valueOf(1), true);
    store.saveBlock(block1, BigInteger.valueOf(2), true);

    BlockUnclesValidationRule rule = new BlockUnclesValidationRule(ConfigHelper.CONFIG, store, 10, 10, new BlockCompositeRule(), new BlockParentCompositeRule());

    Assert.assertFalse(rule.isValid(block));
}
 

import org.ethereum.db.BlockStore; //导入依赖的package包/类
@Test
public void rejectBlockWithUncleHavingHigherNumber() {
    Block genesis = BlockGenerator.getInstance().getGenesisBlock();

    Block block1 = BlockGenerator.getInstance().createChildBlock(genesis);
    Block uncle1 = BlockGenerator.getInstance().createChildBlock(block1);
    Block uncle2 = BlockGenerator.getInstance().createChildBlock(uncle1);
    List<BlockHeader> uncles = new ArrayList<>();
    uncles.add(uncle2.getHeader());

    Block block = BlockGenerator.getInstance().createChildBlock(block1, null, uncles, 1, null);

    BlockChainImpl blockChain = BlockChainImplTest.createBlockChain();
    BlockStore store = blockChain.getBlockStore();

    store.saveBlock(genesis, BigInteger.valueOf(1), true);
    store.saveBlock(block1, BigInteger.valueOf(2), true);

    BlockUnclesValidationRule rule = new BlockUnclesValidationRule(ConfigHelper.CONFIG, store, 10, 10, new BlockCompositeRule(), new BlockParentCompositeRule());

    Assert.assertFalse(rule.isValid(block));
}
 

import org.ethereum.db.BlockStore; //导入依赖的package包/类
@Test
public void calculateParentChild() {
    BlockStore store = createBlockStore();
    Block genesis = BlockGenerator.getInstance().getGenesisBlock();
    Block block = BlockGenerator.getInstance().createChildBlock(genesis);

    store.saveBlock(genesis, BigInteger.ONE, true);
    store.saveBlock(block, BigInteger.ONE, true);

    BlockFork fork = new BlockFork();

    fork.calculate(genesis, block, store);

    Assert.assertSame(genesis, fork.getCommonAncestor());
    Assert.assertTrue(fork.getOldBlocks().isEmpty());
    Assert.assertFalse(fork.getNewBlocks().isEmpty());
    Assert.assertEquals(1, fork.getNewBlocks().size());
    Assert.assertSame(block, fork.getNewBlocks().get(0));
}
 

import org.ethereum.db.BlockStore; //导入依赖的package包/类
@Test
public void processBlockWithInvalidPrevMGP() {
    BlockStore blockStore = Mockito.mock(org.ethereum.db.BlockStore.class);
    Repository repository = Mockito.mock(Repository.class);

    Mockito.when(repository.getSnapshotTo(Mockito.any())).thenReturn(repository);
    Mockito.when(repository.getNonce(Mockito.any())).thenReturn(BigInteger.ZERO);

    Block parent = new BlockBuilder().minGasPrice(BigInteger.ZERO)
            .parent(new BlockGenerator().getGenesisBlock()).build();

    Block block = new BlockBuilder().minGasPrice(BigInteger.TEN)
            .parent(parent).build();

    Mockito.when(blockStore.getBlockByHash(block.getParentHash())).thenReturn(parent);

    BlockValidatorImpl validator = new BlockValidatorBuilder()
            .addPrevMinGasPriceRule()
            .blockStore(blockStore)
            .build();

    Assert.assertFalse(validator.isValid(block));
}