import org.bitcoinj.wallet.DefaultRiskAnalysis; //导入依赖的package包/类
@Test
public void nonStandardDust() {
    Transaction standardTx = new Transaction(params);
    standardTx.addInput(params.getGenesisBlock().getTransactions().get(0).getOutput(0));
    standardTx.addOutput(COIN, key1);
    assertEquals(RiskAnalysis.Result.OK, DefaultRiskAnalysis.FACTORY.create(wallet, standardTx, NO_DEPS).analyze());

    Transaction dustTx = new Transaction(params);
    dustTx.addInput(params.getGenesisBlock().getTransactions().get(0).getOutput(0));
    dustTx.addOutput(Coin.SATOSHI, key1); // 1 Satoshi
    assertEquals(RiskAnalysis.Result.NON_STANDARD, DefaultRiskAnalysis.FACTORY.create(wallet, dustTx, NO_DEPS).analyze());

    Transaction edgeCaseTx = new Transaction(params);
    edgeCaseTx.addInput(params.getGenesisBlock().getTransactions().get(0).getOutput(0));
    edgeCaseTx.addOutput(DefaultRiskAnalysis.MIN_ANALYSIS_NONDUST_OUTPUT, key1); // Dust threshold
    assertEquals(RiskAnalysis.Result.OK, DefaultRiskAnalysis.FACTORY.create(wallet, edgeCaseTx, NO_DEPS).analyze());
}
 

import org.bitcoinj.wallet.DefaultRiskAnalysis; //导入依赖的package包/类
@Test
public void standardOutputs() throws Exception {
    Transaction tx = new Transaction(params);
    tx.addInput(params.getGenesisBlock().getTransactions().get(0).getOutput(0));
    // A pay to address output
    tx.addOutput(Coin.CENT, ScriptBuilder.createOutputScript(key1.toAddress(params)));
    // A pay to pubkey output
    tx.addOutput(Coin.CENT, ScriptBuilder.createOutputScript(key1));
    tx.addOutput(Coin.CENT, ScriptBuilder.createOutputScript(key1));
    // 1-of-2 multisig output.
    ImmutableList<ECKey> keys = ImmutableList.of(key1, new ECKey());
    tx.addOutput(Coin.CENT, ScriptBuilder.createMultiSigOutputScript(1, keys));
    // 2-of-2 multisig output.
    tx.addOutput(Coin.CENT, ScriptBuilder.createMultiSigOutputScript(2, keys));
    // P2SH
    tx.addOutput(Coin.CENT, ScriptBuilder.createP2SHOutputScript(1, keys));
    // OP_RETURN
    tx.addOutput(Coin.CENT, ScriptBuilder.createOpReturnScript("hi there".getBytes()));
    assertEquals(RiskAnalysis.Result.OK, DefaultRiskAnalysis.FACTORY.create(wallet, tx, NO_DEPS).analyze());
}
 

import org.bitcoinj.wallet.DefaultRiskAnalysis; //导入依赖的package包/类
public static void main(String[] args) throws InterruptedException {
    BriefLogFormatter.init();
    PeerGroup peerGroup = new PeerGroup(PARAMS);
    peerGroup.setMaxConnections(32);
    peerGroup.addPeerDiscovery(new DnsDiscovery(PARAMS));
    peerGroup.addOnTransactionBroadcastListener(new OnTransactionBroadcastListener() {
        @Override
        public void onTransaction(Peer peer, Transaction tx) {
            Result result = DefaultRiskAnalysis.FACTORY.create(null, tx, NO_DEPS).analyze();
            incrementCounter(TOTAL_KEY);
            log.info("tx {} result {}", tx.getHash(), result);
            incrementCounter(result.name());
            if (result == Result.NON_STANDARD)
                incrementCounter(Result.NON_STANDARD + "-" + DefaultRiskAnalysis.isStandard(tx));
        }
    });
    peerGroup.start();

    while (true) {
        Thread.sleep(STATISTICS_FREQUENCY_MS);
        printCounters();
    }
}
 

import org.bitcoinj.wallet.DefaultRiskAnalysis; //导入依赖的package包/类
@Test
public void nonFinalDependency() {
    // Final tx has a dependency that is non-final.
    Transaction tx1 = new Transaction(params);
    tx1.addInput(params.getGenesisBlock().getTransactions().get(0).getOutput(0)).setSequenceNumber(1);
    TransactionOutput output = tx1.addOutput(COIN, key1);
    tx1.setLockTime(TIMESTAMP + 86400);
    Transaction tx2 = new Transaction(params);
    tx2.addInput(output);
    tx2.addOutput(COIN, new ECKey());

    DefaultRiskAnalysis analysis = DefaultRiskAnalysis.FACTORY.create(wallet, tx2, ImmutableList.of(tx1));
    assertEquals(RiskAnalysis.Result.NON_FINAL, analysis.analyze());
    assertEquals(tx1, analysis.getNonFinal());
}
 

import org.bitcoinj.wallet.DefaultRiskAnalysis; //导入依赖的package包/类
@Test
public void nonShortestPossiblePushData() {
    ScriptChunk nonStandardChunk = new ScriptChunk(OP_PUSHDATA1, new byte[75]);
    byte[] nonStandardScript = new ScriptBuilder().addChunk(nonStandardChunk).build().getProgram();
    // Test non-standard script as an input.
    Transaction tx = new Transaction(params);
    assertEquals(DefaultRiskAnalysis.RuleViolation.NONE, DefaultRiskAnalysis.isStandard(tx));
    tx.addInput(new TransactionInput(params, null, nonStandardScript));
    assertEquals(DefaultRiskAnalysis.RuleViolation.SHORTEST_POSSIBLE_PUSHDATA, DefaultRiskAnalysis.isStandard(tx));
    // Test non-standard script as an output.
    tx.clearInputs();
    assertEquals(DefaultRiskAnalysis.RuleViolation.NONE, DefaultRiskAnalysis.isStandard(tx));
    tx.addOutput(new TransactionOutput(params, null, COIN, nonStandardScript));
    assertEquals(DefaultRiskAnalysis.RuleViolation.SHORTEST_POSSIBLE_PUSHDATA, DefaultRiskAnalysis.isStandard(tx));
}
 

import org.bitcoinj.wallet.DefaultRiskAnalysis; //导入依赖的package包/类
/**
 * <p>Returns either RuleViolation.NONE if the input is standard, or which rule makes it non-standard if so.
 * The "IsStandard" rules control whether the default Bitcoin Core client blocks relay of a tx / refuses to mine it,
 * however, non-standard transactions can still be included in blocks and will be accepted as valid if so.</p>
 *
 * <p>This method simply calls <tt>DefaultRiskAnalysis.isInputStandard(this)</tt>.</p>
 */
public DefaultRiskAnalysis.RuleViolation isStandard() {
    return DefaultRiskAnalysis.isInputStandard(this);
}