Java BlockChain类代码示例

import org.bitcoinj.core.BlockChain; //导入依赖的package包/类
public boolean isNymNotSpend(BlockChain bc) {
	//check locktime and compare to current bip113 time
	//we only accept p2sh
	if(!getLastTransactionOutput().getScriptPubKey().isPayToScriptHash()) {
		System.out.println("the psynym is not a p2sh");
		return false;
	}
	
	//check that redeem script matches the p2sh output hash
	if(!ScriptBuilder.createP2SHOutputScript(sp.getRedeemScript()).equals(getLastTransactionOutput().getScriptPubKey())) {
		System.out.println("the redeem script doesn't match the p2sh output hash");
		return false;
	}
	
	//check that the redeem script is the one we specified and check that it is still locked
	if(!sp.isRedeemScriptRightFormat() || !sp.isLocked(bc)) {
		System.out.println("redeem script is either not in right format or transaction is not locked, might be not spend, but we can't know without utxo set");
		return false;
	}
	return true;
}
 

import org.bitcoinj.core.BlockChain; //导入依赖的package包/类
public boolean isValidProof(BlockChain bc, PeerGroup pg, NetworkParameters params) {
	if(!isValidPath()) {
		System.out.println("path is not valid, thus proof not valid, abort");
		return false;
	}
	if(!isValidGPTx()) {
		System.out.println("gptx is not valid, abort");
		return false;
	}
	if(!isNymNotSpend(bc)) {
		System.out.println("nym is not locked anymore, consider spent, abort");
		return false;
	}
	if(!isNymTxInBlockChain(params, bc, pg)) {
		System.out.println("nymtx is not in blockchain, consider proof invalid, abort");
		return false;
	}
	System.out.println("proof seems valid");
	return true;
}
 

import org.bitcoinj.core.BlockChain; //导入依赖的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.BlockChain; //导入依赖的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.BlockChain; //导入依赖的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.BlockChain; //导入依赖的package包/类
@Test
public void isConsistent_duplicates() throws Exception {
    // This test ensures that isConsistent catches duplicate transactions, eg, because we submitted the same block
    // twice (this is not allowed).
    Transaction tx = createFakeTx(PARAMS, COIN, myAddress);
    TransactionOutput output = new TransactionOutput(PARAMS, tx, valueOf(0, 5), OTHER_ADDRESS);
    tx.addOutput(output);
    wallet.receiveFromBlock(tx, null, BlockChain.NewBlockType.BEST_CHAIN, 0);

    assertTrue(wallet.isConsistent());

    Transaction txClone = PARAMS.getDefaultSerializer().makeTransaction(tx.bitcoinSerialize());
    try {
        wallet.receiveFromBlock(txClone, null, BlockChain.NewBlockType.BEST_CHAIN, 0);
        fail("Illegal argument not thrown when it should have been.");
    } catch (IllegalStateException ex) {
        // expected
    }
}
 

import org.bitcoinj.core.BlockChain; //导入依赖的package包/类
@Test
public void watchingScriptsBloomFilter() throws Exception {
    assertFalse(wallet.isRequiringUpdateAllBloomFilter());

    Address watchedAddress = new ECKey().toAddress(PARAMS);
    Transaction t1 = createFakeTx(PARAMS, CENT, watchedAddress);
    TransactionOutPoint outPoint = new TransactionOutPoint(PARAMS, 0, t1);
    wallet.addWatchedAddress(watchedAddress);

    assertTrue(wallet.isRequiringUpdateAllBloomFilter());
    // Note that this has a 1e-12 chance of failing this unit test due to a false positive
    assertFalse(wallet.getBloomFilter(1e-12).contains(outPoint.unsafeBitcoinSerialize()));

    sendMoneyToWallet(BlockChain.NewBlockType.BEST_CHAIN, t1);
    assertTrue(wallet.getBloomFilter(1e-12).contains(outPoint.unsafeBitcoinSerialize()));
}
 

import org.bitcoinj.core.BlockChain; //导入依赖的package包/类
@Test
public void removeScriptsBloomFilter() throws Exception {
    List<Address> addressesForRemoval = new ArrayList<Address>();
    for (int i = 0; i < 10; i++) {
        Address watchedAddress = new ECKey().toAddress(PARAMS);
        addressesForRemoval.add(watchedAddress);
        wallet.addWatchedAddress(watchedAddress);
    }

    wallet.removeWatchedAddresses(addressesForRemoval);

    for (Address addr : addressesForRemoval) {
        Transaction t1 = createFakeTx(PARAMS, CENT, addr);
        TransactionOutPoint outPoint = new TransactionOutPoint(PARAMS, 0, t1);

        // Note that this has a 1e-12 chance of failing this unit test due to a false positive
        assertFalse(wallet.getBloomFilter(1e-12).contains(outPoint.unsafeBitcoinSerialize()));

        sendMoneyToWallet(BlockChain.NewBlockType.BEST_CHAIN, t1);
        assertFalse(wallet.getBloomFilter(1e-12).contains(outPoint.unsafeBitcoinSerialize()));
    }
}
 

import org.bitcoinj.core.BlockChain; //导入依赖的package包/类
@Bean
public BlockChainService getBlockchainService(final NetworkParameters params,
                                              final BlockChain blockChain,
                                              final PeerGroup peerGroup,
                                              final TransactionStateService transactionService,
                                              final WalletDbService walletService,
                                              final AccountDbService accountService,
                                              final BlockchainSettings settings
                                              ){

    final BitcoinjBlockchainServiceImpl blockChainService =
            new BitcoinjBlockchainServiceImpl(params, blockChain, peerGroup, transactionService, walletService, accountService, settings);

    blockChainService.init();
    return blockChainService;
}
 

import org.bitcoinj.core.BlockChain; //导入依赖的package包/类
public NameLookupLatestLevelDBTransactionCache (Context context, File directory, DBFactory dbFactory, BlockChain chain, BlockStore store, PeerGroup peerGroup) throws IOException {
    this.chain = chain;
    this.store = store;
    this.peerGroup = peerGroup;
    
    this.context = context;
    this.params = context.getParams();
    
    this.path = directory;
    Options options = new Options();
    options.createIfMissing();
    
    try {
        tryOpen(directory, dbFactory, options);
    } catch (IOException e) {
        dbFactory.repair(directory, options);
        tryOpen(directory, dbFactory, options);
    }
    
    chain.addNewBestBlockListener(Threading.SAME_THREAD, this);
    chain.addReorganizeListener(Threading.SAME_THREAD, this);
    chain.addTransactionReceivedListener(Threading.SAME_THREAD, this);
}
 

import org.bitcoinj.core.BlockChain; //导入依赖的package包/类
private void createMultiSigWallet(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));
        }

//        MarriedKeyChain chain = MarriedKeyChain.builder()
//                .random(new SecureRandom())
//                .followingKeys(followingKeys)
//                .threshold(threshold).build();
//        wallet.addAndActivateHDChain(chain);
    }
 

import org.bitcoinj.core.BlockChain; //导入依赖的package包/类
@Test
public void removeScriptsBloomFilter() throws Exception {
    List<Address> addressesForRemoval = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        Address watchedAddress = new ECKey().toAddress(PARAMS);
        addressesForRemoval.add(watchedAddress);
        wallet.addWatchedAddress(watchedAddress);
    }

    wallet.removeWatchedAddresses(addressesForRemoval);

    for (Address addr : addressesForRemoval) {
        Transaction t1 = createFakeTx(PARAMS, CENT, addr);
        TransactionOutPoint outPoint = new TransactionOutPoint(PARAMS, 0, t1);

        // Note that this has a 1e-12 chance of failing this unit test due to a false positive
        assertFalse(wallet.getBloomFilter(1e-12).contains(outPoint.unsafeBitcoinSerialize()));

        sendMoneyToWallet(BlockChain.NewBlockType.BEST_CHAIN, t1);
        assertFalse(wallet.getBloomFilter(1e-12).contains(outPoint.unsafeBitcoinSerialize()));
    }
}
 

import org.bitcoinj.core.BlockChain; //导入依赖的package包/类
public TransactionGenerator(NetworkParameters params, PeerGroup pg, Wallet w, BlockChain bc) {
	this.params = params;
	this.pg = pg;
	this.w = w;
	this.bc = bc;
	
}
 

import org.bitcoinj.core.BlockChain; //导入依赖的package包/类
private Sha256Hash getBlockHashByHeight(BlockChain bc, int appearedInChainheight2) {
	int bestchainheight = bc.getBestChainHeight();
	StoredBlock block = bc.getChainHead();
	assert(block != null);
	for(int i=0; i < bestchainheight-appearedInChainheight2; i++) {
		try {
			System.out.println("iteration: " + i);
			assert(block != null);
			block = block.getPrev(bc.getBlockStore());
		} catch (BlockStoreException e) {
			e.printStackTrace();
		}
	}
	return block.getHeader().getHash();
}
 

import org.bitcoinj.core.BlockChain; //导入依赖的package包/类
public Mixer(PTP ptp, BroadcastAnnouncement bca, ProofMessage pm, Wallet w, NetworkParameters params, PeerGroup pg, BlockChain bc) {
	this.ptp = ptp;
	this.bca = bca;
	this.mixPartnerAdress = new Identifier(bca.getOnionAdress() + ".onion");
	this.ownProof = pm;
	this.w = w;
	this.params = params;
	this.pg = pg;
	this.bc = bc;
	this.mfListeners = new ArrayList<MixFinishedEventListener>();
	this.lockTime = 0; 
}