Java BlockStoreException类代码示例

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
private synchronized void refreshUI(){
    getActivity().runOnUiThread(new Runnable() {
        @Override
        public void run() {
            try {
                if(peerGroup==null || blockStore==null){
                    tvStatus.setText("0 "+ getResources().getString(R.string.current_height));
                }else {
                    Integer maxHeight = peerGroup.getMostCommonChainHeight();
                    Integer curHeight = 0;
                    if(blockStore.getChainHead()!=null) {
                        curHeight = blockStore.getChainHead().getHeight();
                    }

                    tvStatus.setText(curHeight + "/" + maxHeight + " " + getResources().getString(R.string.current_height));
                    mAdapter.notifyDataSetChanged();
                }
            } catch (BlockStoreException e) {
                e.printStackTrace();
            }
        }
    });
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
public SQLiteBlockStore(NetworkParameters params, Context context) throws BlockStoreException {
    this.params = params;
    blocksDataSource = new BlocksDataSource(context);

    blocksDataSource.open();
    if (blocksDataSource.count()==0){
        createNewBlockStore(params);
    } else{
        try {
            DBBlock block = blocksDataSource.getLast();
            Block b = new Block(params, block.getHeader());
            StoredBlock s = build(b);
            this.chainHead = s.getHeader().getHash();
        } catch (Exception e) {
            throw new BlockStoreException("Invalid BlockStore chainHead");
        }
    }
    blocksDataSource.close();
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
@Override
public synchronized void put(StoredBlock block) throws BlockStoreException {

    blocksDataSource.open();
    Sha256Hash hash = block.getHeader().getHash();
    try {
        blocksDataSource.getHash(hash.toString());
    } catch (Exception e) {
        DBBlock dbBlock = new DBBlock();
        dbBlock.setHash(hash.toString());
        dbBlock.setHeight(block.getHeight());
        dbBlock.setHeader(block.getHeader().bitcoinSerialize());
        dbBlock.setChainWork(block.getChainWork());
        blocksDataSource.insert(dbBlock);
    }
    blocksDataSource.close();
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
@Override
public synchronized StoredBlock get(Sha256Hash hash) throws BlockStoreException {

    if(hash==null)
        throw new BlockStoreException("Invalid hash");

    blocksDataSource.open();
    DBBlock block = null;
    try {
        block = blocksDataSource.getHash(hash.toString());
    } catch (Exception e) {
        blocksDataSource.close();
        return null;
    }

    Block b = new Block(params, block.getHeader());
    StoredBlock s = build(b);

    blocksDataSource.close();
    return s;
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
private void lock() throws IOException, BlockStoreException {
    if (!semaphores.tryAcquire()) {
        throw new BlockStoreException("File in use");
    }
    try {
        lock = file.getChannel().tryLock();
    } catch (OverlappingFileLockException e) {
        semaphores.release();
        lock = null;
    }
    if (lock == null) {
        try {
            this.file.close();
        } finally {
            this.file = null;
        }
        throw new BlockStoreException("Could not lock file");
    }
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
public static long currentBitcoinBIP113Time(BlockChain bc) {
	StoredBlock headBlock = bc.getChainHead();
	StoredBlock iteratingBlock = headBlock;
	long[] blockTimeStamps = new long[11];
	for(int i=0; i < 11; i++) {
		blockTimeStamps[i] = iteratingBlock.getHeader().getTimeSeconds();
		try {
			iteratingBlock = iteratingBlock.getPrev(bc.getBlockStore());
		} catch (BlockStoreException e) {
			e.printStackTrace();
		}
	}
	Arrays.sort(blockTimeStamps);
	System.out.println("current bitcoinbip113time yielded " + new Date(blockTimeStamps[5]*1000));
	return blockTimeStamps[5];
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
/**
 * Initialize the version tally from the block store. Note this does not
 * search backwards past the start of the block store, so if starting from
 * a checkpoint this may not fill the window.
 *
 * @param blockStore block store to load blocks from.
 * @param chainHead current chain tip.
 */
public void initialize(final BlockStore blockStore, final StoredBlock chainHead)
    throws BlockStoreException {
    StoredBlock versionBlock = chainHead;
    final Stack<Long> versions = new Stack<>();

    // We don't know how many blocks back we can go, so load what we can first
    versions.push(versionBlock.getHeader().getVersion());
    for (int headOffset = 0; headOffset < versionWindow.length; headOffset++) {
        versionBlock = versionBlock.getPrev(blockStore);
        if (null == versionBlock) {
            break;
        }
        versions.push(versionBlock.getHeader().getVersion());
    }

    // Replay the versions into the tally
    while (!versions.isEmpty()) {
        add(versions.pop());
    }
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
@Override
protected void rollbackBlockStore(int height) throws BlockStoreException {
    lock.lock();
    try {
        int currentHeight = getBestChainHeight();
        checkArgument(height >= 0 && height <= currentHeight, "Bad height: %s", height);
        if (height == currentHeight)
            return; // nothing to do

        // Look for the block we want to be the new chain head
        StoredBlock newChainHead = blockStore.getChainHead();
        while (newChainHead.getHeight() > height) {
            newChainHead = newChainHead.getPrev(blockStore);
            if (newChainHead == null)
                throw new BlockStoreException("Unreachable height");
        }

        // Modify store directly
        blockStore.put(newChainHead);
        this.setChainHead(newChainHead);
    } finally {
        lock.unlock();
    }
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
@Override
public List<StoredBlock> getRecentBlocks(final int maxBlocks) {
    final List<StoredBlock> blocks = new ArrayList<StoredBlock>(maxBlocks);

    try {
        StoredBlock block = blockChain.getChainHead();

        while (block != null) {
            blocks.add(block);

            if (blocks.size() >= maxBlocks)
                break;

            block = block.getPrev(blockStore);
        }
    } catch (final BlockStoreException x) {
        // swallow
    }

    return blocks;
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
/**
 * Initialize the version tally from the block store. Note this does not
 * search backwards past the start of the block store, so if starting from
 * a checkpoint this may not fill the window.
 *
 * @param blockStore block store to load blocks from.
 * @param chainHead current chain tip.
 */
public void initialize(final BlockStore blockStore, final StoredBlock chainHead)
    throws BlockStoreException {
    StoredBlock versionBlock = chainHead;
    final Stack<Long> versions = new Stack<Long>();

    // We don't know how many blocks back we can go, so load what we can first
    versions.push(versionBlock.getHeader().getVersion());
    for (int headOffset = 0; headOffset < versionWindow.length; headOffset++) {
        versionBlock = versionBlock.getPrev(blockStore);
        if (null == versionBlock) {
            break;
        }
        versions.push(versionBlock.getHeader().getVersion());
    }

    // Replay the versions into the tally
    while (!versions.isEmpty()) {
        add(versions.pop());
    }
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
@Test
public void testInitialize() throws BlockStoreException {
    final BlockStore blockStore = new MemoryBlockStore(PARAMS);
    final BlockChain chain = new BlockChain(PARAMS, blockStore);

    // Build a historical chain of version 2 blocks
    long timeSeconds = 1231006505;
    StoredBlock chainHead = null;
    for (int height = 0; height < PARAMS.getMajorityWindow(); height++) {
        chainHead = FakeTxBuilder.createFakeBlock(blockStore, 2, timeSeconds, height).storedBlock;
        assertEquals(2, chainHead.getHeader().getVersion());
        timeSeconds += 60;
    }

    VersionTally instance = new VersionTally(PARAMS);
    instance.initialize(blockStore, chainHead);
    assertEquals(PARAMS.getMajorityWindow(), instance.getCountAtOrAbove(2).intValue());
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
@Nullable
private static StoredTransactionOutput retrieveFromUtxo(AbstractBlockChain blockChain, TransactionOutPoint txInOutpoint) {
    final BlockStore bs = blockChain.getBlockStore();
    if (bs instanceof FullPrunedBlockStore) {
        FullPrunedBlockStore blockStore = (FullPrunedBlockStore) bs;
        try {
            return blockStore.getTransactionOutput(txInOutpoint.getHash(), txInOutpoint.getIndex());
        } catch (BlockStoreException e) {
            logger.error("blockStore.getTransactionOutput(Sha256Hash, long) lookup exception", e);
        }
    } else {
        logger.warn("Masternode code active despite that BlockStore is not an instance of FullPrunedBlockStore");
    }

    return null;
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
private void createMarriedWallet(int threshold, int numKeys, boolean addSigners) throws BlockStoreException {
    wallet = new Wallet(params);
    blockStore = new MemoryBlockStore(params);
    chain = new BlockChain(params, wallet, blockStore);

    List<DeterministicKey> followingKeys = Lists.newArrayList();
    for (int i = 0; i < numKeys - 1; i++) {
        final DeterministicKeyChain keyChain = new DeterministicKeyChain(new SecureRandom());
        DeterministicKey partnerKey = DeterministicKey.deserializeB58(null, keyChain.getWatchingKey().serializePubB58());
        followingKeys.add(partnerKey);
        if (addSigners && i < threshold - 1)
            wallet.addTransactionSigner(new KeyChainTransactionSigner(keyChain));
    }

    wallet.addFollowingAccountKeys(followingKeys, threshold);
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
@Override
protected void shutDown() throws Exception {
    // Runs in a separate thread.
    try {
        vPeerGroup.stopAsync();
        vPeerGroup.awaitTerminated();
        vWallet.saveToFile(vWalletFile);
        vStore.close();

        vPeerGroup = null;
        vWallet = null;
        vStore = null;
        vChain = null;
    } catch (BlockStoreException e) {
        throw new IOException(e);
    }
}
 

import org.bitcoinj.store.BlockStoreException; //导入依赖的package包/类
private void checkTestnetDifficulty(StoredBlock storedPrev, Block prev, Block next) throws VerificationException, BlockStoreException {
    checkState(lock.isHeldByCurrentThread());
    // After 15th February 2012 the rules on the testnet change to avoid people running up the difficulty
    // and then leaving, making it too hard to mine a block. On non-difficulty transition points, easy
    // blocks are allowed if there has been a span of 20 minutes without one.
    final long timeDelta = next.getTimeSeconds() - prev.getTimeSeconds();
    // There is an integer underflow bug in bitcoin-qt that means mindiff blocks are accepted when time
    // goes backwards.
    if (timeDelta >= 0 && timeDelta <= NetworkParameters.TARGET_SPACING * 2) {
        // Walk backwards until we find a block that doesn't have the easiest proof of work, then check
        // that difficulty is equal to that one.
        StoredBlock cursor = storedPrev;
        while (!cursor.getHeader().equals(params.getGenesisBlock()) &&
               cursor.getHeight() % params.getInterval() != 0 &&
               cursor.getHeader().getDifficultyTargetAsInteger().equals(params.getMaxTarget()))
            cursor = cursor.getPrev(blockStore);
        BigInteger cursorTarget = cursor.getHeader().getDifficultyTargetAsInteger();
        BigInteger newTarget = next.getDifficultyTargetAsInteger();
        if (!cursorTarget.equals(newTarget))
            throw new VerificationException("Testnet block transition that is not allowed: " +
                Long.toHexString(cursor.getHeader().getDifficultyTarget()) + " vs " +
                Long.toHexString(next.getDifficultyTarget()));
    }
}