<dependency>

            <groupId>com.madgag.spongycastle</groupId>

            <artifactId>core</artifactId>

            <version>1.52.0.0</version>

</dependency>

<dependency>

            <groupId>com.google.guava</groupId>

            <artifactId>guava</artifactId>

            <version>25.0-jre</version>

</dependency>

public static final int TARGET_TIMESPAN = 14 * 24 * 60 * 60;  // 2 weeks per difficulty cycle, on average.

public static final int TARGET_SPACING = 10 * 60;  // 10 minutes per block.

public static final int INTERVAL = TARGET_TIMESPAN / TARGET_SPACING;   

/**

* The maximum number of coins to be generated

*/

public static final long MAX_COINS = 21000000;

public static final int REWARD_HALVING_INTERVAL = 210000;//奖励减半周期

    /** Height of the first block */

    public static final int BLOCK_HEIGHT_GENESIS = 0;//The genesis block has a height of zero.

/**

     * <p>A utility method that calculates how much new Bitcoin would be created by the block at the given height.

     * The inflation of Bitcoin is predictable and drops roughly every 4 years (210,000 blocks). At the dawn of

     * the system it was 50 coins per block, in late 2012 it went to 25 coins per block, and so on. The size of

     * a coinbase transaction is inflation plus fees.</p>

     *

     * <p>The half-life is controlled by {@link org.bitcoinj.core.NetworkParameters#getSubsidyDecreaseBlockCount()}.

     * </p>

     */

    public Coin getBlockInflation(int height) {

        return FIFTY_COINS.shiftRight(height / params.getSubsidyDecreaseBlockCount());

    }

    /**

     * Returns the work represented by this block.<p>

     *

     * Work is defined as the number of tries needed to solve a block in the

     * average case. Consider a difficulty target that covers 5% of all possible

     * hash values. Then the work of the block will be 20. As the target gets

     * lower, the amount of work goes up.

     */

    public BigInteger getWork() throws VerificationException {

        BigInteger target = getDifficultyTargetAsInteger();

        return LARGEST_HASH.divide(target.add(BigInteger.ONE));

    }

private boolean add(Block block, boolean tryConnecting,

                        @Nullable List<Sha256Hash> filteredTxHashList, @Nullable Map<Sha256Hash, Transaction> filteredTxn)

            throws BlockStoreException, VerificationException, PrunedException {

//......

// Try linking it to a place in the currently known blocks.

            if (storedPrev == null) {

                // We can't find the previous block. Probably we are still in the process of downloading the chain and a

                // block was solved whilst we were doing it. We put it to one side and try to connect it later when we

                // have more blocks.

                checkState(tryConnecting, "bug in tryConnectingOrphans");

                log.warn("Block does not connect: {} prev {}", block.getHashAsString(), block.getPrevBlockHash());

                orphanBlocks.put(block.getHash(), new OrphanBlock(block, filteredTxHashList, filteredTxn));

                return false;

            } else {

                checkState(lock.isHeldByCurrentThread());

                // It connects to somewhere on the chain. Not necessarily the top of the best known chain.

                params.checkDifficultyTransitions(storedPrev, block, blockStore);

                connectBlock(block, storedPrev, shouldVerifyTransactions(), filteredTxHashList, filteredTxn);

            }

//......

}