Java StoredBlock类代码示例

import org.bitcoinj.core.StoredBlock; //导入依赖的package包/类
@Override
public void receiveFromBlock(Transaction tx, StoredBlock block, AbstractBlockChain.NewBlockType blockType, int relativityOffset) throws VerificationException {
    //Log.d("TransactionIsInBlock",block.toString());

    synchronized (transactions) {
        countTransactions++;
        transactions.add(tx);
        if (transactions.size() >= 30) {
            transactions.remove(10);
        }
    }

    if(System.currentTimeMillis()-lastTimestamp>1000) {
        refreshUI();
        lastTimestamp = System.currentTimeMillis();
    }
}
 

import org.bitcoinj.core.StoredBlock; //导入依赖的package包/类
private void refresh(final StoredBlock storedBlock){
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            // Update info
            mDataset.clear();
            if(storedBlock!=null){
                mDataset.put("Hash",storedBlock.getHeader().getHashAsString());
                mDataset.put("Height",String.valueOf(storedBlock.getHeight()));
                //mDataset.put("Prev",storedBlock.getPrev(blockStore).getHeader().getHashAsString());
                mDataset.put("MerkleRoot",storedBlock.getHeader().getMerkleRoot().toString());
                mDataset.put("DifficultyTarget",String.valueOf(storedBlock.getHeader().getDifficultyTarget()));
                mDataset.put("Nonce",String.valueOf(storedBlock.getHeader().getNonce()));
                mDataset.put("Date",storedBlock.getHeader().getTime().toLocaleString());
                mDataset.put("Version",String.valueOf(storedBlock.getHeader().getVersion()));
                mDataset.put("Work",String.valueOf(storedBlock.getHeader().getWork()));
                //mDataset.put("Transactions",String.valueOf(storedBlock.getHeader().getTransactions().size()));
                mAdapter.notifyDataSetChanged();
        }
    }
});
}
 

import org.bitcoinj.core.StoredBlock; //导入依赖的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.core.StoredBlock; //导入依赖的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.core.StoredBlock; //导入依赖的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.core.StoredBlock; //导入依赖的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.core.StoredBlock; //导入依赖的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.core.StoredBlock; //导入依赖的package包/类
/**
 * Called by the {@link BlockChain} when we receive a new filtered block that contains a transactions previously
 * received by a call to {@link #receivePending}.<p>
 *
 * This is necessary for the internal book-keeping Wallet does. When a transaction is received that sends us
 * coins it is added to a pool so we can use it later to create spends. When a transaction is received that
 * consumes outputs they are marked as spent so they won't be used in future.<p>
 *
 * A transaction that spends our own coins can be received either because a spend we created was accepted by the
 * network and thus made it into a block, or because our keys are being shared between multiple instances and
 * some other node spent the coins instead. We still have to know about that to avoid accidentally trying to
 * double spend.<p>
 *
 * A transaction may be received multiple times if is included into blocks in parallel chains. The blockType
 * parameter describes whether the containing block is on the main/best chain or whether it's on a presently
 * inactive side chain. We must still record these transactions and the blocks they appear in because a future
 * block might change which chain is best causing a reorganize. A re-org can totally change our balance!
 */
@Override
public boolean notifyTransactionIsInBlock(Sha256Hash txHash, StoredBlock block,
                                          BlockChain.NewBlockType blockType,
                                          int relativityOffset) throws VerificationException {
    lock.lock();
    try {
        Transaction tx = transactions.get(txHash);
        if (tx == null) {
            tx = riskDropped.get(txHash);
            if (tx != null) {
                // If this happens our risk analysis is probably wrong and should be improved.
                log.info("Risk analysis dropped tx {} but was included in block anyway", tx.getHash());
            } else {
                // False positive that was broadcast to us and ignored by us because it was irrelevant to our keys.
                return false;
            }
        }
        receive(tx, block, blockType, relativityOffset);
        return true;
    } finally {
        lock.unlock();
    }
}
 

import org.bitcoinj.core.StoredBlock; //导入依赖的package包/类
private void createNewStore(NetworkParameters params) throws BlockStoreException {
    try {
        // Set up the genesis block. When we start out fresh, it is by
        // definition the top of the chain.
        StoredBlock storedGenesisHeader = new StoredBlock(params.getGenesisBlock().cloneAsHeader(),
                params.getGenesisBlock().getWork(), 0);
        // The coinbase in the genesis block is not spendable. This is
        // because of how the reference client inits
        // its database - the genesis transaction isn't actually in the db
        // so its spent flags can never be updated.
        List<Transaction> genesisTransactions = Lists.newLinkedList();
        StoredUndoableBlock storedGenesis = new StoredUndoableBlock(params.getGenesisBlock().getHash(),
                genesisTransactions);
        beginDatabaseBatchWrite();
        put(storedGenesisHeader, storedGenesis);
        setChainHead(storedGenesisHeader);
        setVerifiedChainHead(storedGenesisHeader);
        batchPut(getKey(KeyType.CREATED), bytes("done"));
        commitDatabaseBatchWrite();
    } catch (VerificationException e) {
        throw new RuntimeException(e); // Cannot happen.
    }
}
 

import org.bitcoinj.core.StoredBlock; //导入依赖的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.core.StoredBlock; //导入依赖的package包/类
@Override
public void onBlockMenuClick(final View view, final StoredBlock block) {
    final PopupMenu popupMenu = new PopupMenu(activity, view);
    popupMenu.inflate(R.menu.blocks_context);
    popupMenu.getMenu().findItem(R.id.blocks_context_browse).setVisible(Constants.ENABLE_BROWSE);
    popupMenu.setOnMenuItemClickListener(new OnMenuItemClickListener() {
        @Override
        public boolean onMenuItemClick(final MenuItem item) {
            switch (item.getItemId()) {
            case R.id.blocks_context_browse:
                final String blockHash = block.getHeader().getHashAsString();
                final Uri blockExplorerUri = config.getBlockExplorer();
                log.info("Viewing block {} on {}", blockHash, blockExplorerUri);
                startActivity(new Intent(Intent.ACTION_VIEW,
                        Uri.withAppendedPath(blockExplorerUri, "block/" + blockHash)));
                return true;
            }
            return false;
        }
    });
    popupMenu.show();
}
 

import org.bitcoinj.core.StoredBlock; //导入依赖的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.core.StoredBlock; //导入依赖的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.core.StoredBlock; //导入依赖的package包/类
@Test
public void testCategory2WithChange() throws Exception {
    // Specifically target case 2 with significant change

    // Generate a ton of small outputs
    StoredBlock block = new StoredBlock(makeSolvedTestBlock(blockStore, OTHER_ADDRESS), BigInteger.ONE, 1);
    int i = 0;
    while (i <= CENT.divide(Transaction.REFERENCE_DEFAULT_MIN_TX_FEE.multiply(10))) {
        Transaction tx = createFakeTxWithChangeAddress(PARAMS, Transaction.REFERENCE_DEFAULT_MIN_TX_FEE.multiply(10), myAddress, OTHER_ADDRESS);
        tx.getInput(0).setSequenceNumber(i++); // Keep every transaction unique
        wallet.receiveFromBlock(tx, block, AbstractBlockChain.NewBlockType.BEST_CHAIN, i);
    }

    // The selector will choose 2 with MIN_TX_FEE fee
    SendRequest request1 = SendRequest.to(OTHER_ADDRESS, CENT.add(SATOSHI));
    request1.ensureMinRequiredFee = true;
    wallet.completeTx(request1);
    assertEquals(Transaction.REFERENCE_DEFAULT_MIN_TX_FEE, request1.tx.getFee());
    assertEquals(request1.tx.getInputs().size(), i); // We should have spent all inputs
    assertEquals(2, request1.tx.getOutputs().size()); // and gotten change back
}
 

import org.bitcoinj.core.StoredBlock; //导入依赖的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;
}