import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
@Nullable
public static Address getWalletAddressOfReceived(final Transaction tx, final Wallet wallet) {
    for (final TransactionOutput output : tx.getOutputs()) {
        try {
            if (output.isMine(wallet)) {
                final Script script = output.getScriptPubKey();
                return script.getToAddress(Constants.NETWORK_PARAMETERS, true);
            }
        } catch (final ScriptException x) {
            // swallow
        }
    }

    return null;
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
/**
 * Marks all keys used in the transaction output as used in the wallet.
 * See {@link org.bitcoinj.wallet.DeterministicKeyChain#markKeyAsUsed(DeterministicKey)} for more info on this.
 */
private void markKeysAsUsed(Transaction tx) {
    keyChainGroupLock.lock();
    try {
        for (TransactionOutput o : tx.getOutputs()) {
            try {
                Script script = o.getScriptPubKey();
                if (script.isSentToRawPubKey()) {
                    byte[] pubkey = script.getPubKey();
                    keyChainGroup.markPubKeyAsUsed(pubkey);
                } else if (script.isSentToAddress()) {
                    byte[] pubkeyHash = script.getPubKeyHash();
                    keyChainGroup.markPubKeyHashAsUsed(pubkeyHash);
                } else if (script.isPayToScriptHash()) {
                    Address a = Address.fromP2SHScript(tx.getParams(), script);
                    keyChainGroup.markP2SHAddressAsUsed(a);
                }
            } catch (ScriptException e) {
                // Just means we didn't understand the output of this transaction: ignore it.
                log.warn("Could not parse tx output script: {}", e.toString());
            }
        }
    } finally {
        keyChainGroupLock.unlock();
    }
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
/**
 * This method is used by a {@link Peer} to find out if a transaction that has been announced is interesting,
 * that is, whether we should bother downloading its dependencies and exploring the transaction to decide how
 * risky it is. If this method returns true then {@link Wallet#receivePending(Transaction, java.util.List)}
 * will soon be called with the transactions dependencies as well.
 */
public boolean isPendingTransactionRelevant(Transaction tx) throws ScriptException {
    lock.lock();
    try {
        // Ignore it if we already know about this transaction. Receiving a pending transaction never moves it
        // between pools.
        EnumSet<Pool> containingPools = getContainingPools(tx);
        if (!containingPools.equals(EnumSet.noneOf(Pool.class))) {
            log.debug("Received tx we already saw in a block or created ourselves: " + tx.getHashAsString());
            return false;
        }
        // We only care about transactions that:
        //   - Send us coins
        //   - Spend our coins
        //   - Double spend a tx in our wallet
        if (!isTransactionRelevant(tx)) {
            log.debug("Received tx that isn't relevant to this wallet, discarding.");
            return false;
        }
        return true;
    } finally {
        lock.unlock();
    }
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
/**
 * Returns all the outputs that match addresses or scripts added via {@link #addWatchedAddress(Address)} or
 * {@link #addWatchedScripts(java.util.List)}.
 * @param excludeImmatureCoinbases Whether to ignore outputs that are unspendable due to being immature.
 */
public List<TransactionOutput> getWatchedOutputs(boolean excludeImmatureCoinbases) {
    lock.lock();
    keyChainGroupLock.lock();
    try {
        LinkedList<TransactionOutput> candidates = Lists.newLinkedList();
        for (Transaction tx : Iterables.concat(unspent.values(), pending.values())) {
            if (excludeImmatureCoinbases && !tx.isMature()) continue;
            for (TransactionOutput output : tx.getOutputs()) {
                if (!output.isAvailableForSpending()) continue;
                try {
                    Script scriptPubKey = output.getScriptPubKey();
                    if (!watchedScripts.contains(scriptPubKey)) continue;
                    candidates.add(output);
                } catch (ScriptException e) {
                    // Ignore
                }
            }
        }
        return candidates;
    } finally {
        keyChainGroupLock.unlock();
        lock.unlock();
    }
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
private void calcBloomOutPointsLocked() {
    // TODO: This could be done once and then kept up to date.
    bloomOutPoints.clear();
    Set<Transaction> all = new HashSet<Transaction>();
    all.addAll(unspent.values());
    all.addAll(spent.values());
    all.addAll(pending.values());
    for (Transaction tx : all) {
        for (TransactionOutput out : tx.getOutputs()) {
            try {
                if (isTxOutputBloomFilterable(out))
                    bloomOutPoints.add(out.getOutPointFor());
            } catch (ScriptException e) {
                // If it is ours, we parsed the script correctly, so this shouldn't happen.
                throw new RuntimeException(e);
            }
        }
    }
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
private int estimateBytesForSigning(CoinSelection selection) {
    int size = 0;
    for (TransactionOutput output : selection.gathered) {
        try {
            Script script = output.getScriptPubKey();
            ECKey key = null;
            Script redeemScript = null;
            if (script.isSentToAddress()) {
                key = findKeyFromPubHash(script.getPubKeyHash());
                checkNotNull(key, "Coin selection includes unspendable outputs");
            } else if (script.isPayToScriptHash()) {
                redeemScript = findRedeemDataFromScriptHash(script.getPubKeyHash()).redeemScript;
                checkNotNull(redeemScript, "Coin selection includes unspendable outputs");
            }
            size += script.getNumberOfBytesRequiredToSpend(key, redeemScript);
        } catch (ScriptException e) {
            // If this happens it means an output script in a wallet tx could not be understood. That should never
            // happen, if it does it means the wallet has got into an inconsistent state.
            throw new IllegalStateException(e);
        }
    }
    return size;
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
private boolean isInputMine(TransactionInput input) {
    lock.lock();
    try {
        try {
            Script script = input.getScriptSig();
            // TODO check multi sig scripts
            return isPubKeyMine(script.getPubKey());
        } catch (ScriptException e) {
            // We didn't understand this input ScriptSig: ignore it.
            log.debug("Could not parse tx input script: {}", e.toString());
            return false;
        }
    }
    finally {
        lock.unlock();
    }
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
@Nullable
public static Address getToAddressOfSent(final Transaction tx, final Wallet wallet)
{
    for (final TransactionOutput output : tx.getOutputs())
    {
        try
        {
            if (!output.isMine(wallet))
            {
                final Script script = output.getScriptPubKey();
                return script.getToAddress(Constants.NETWORK_PARAMETERS, true);
            }
        }
        catch (final ScriptException x)
        {
            // swallow
        }
    }

    return null;
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
@Nullable
public static Address getWalletAddressOfReceived(final Transaction tx, final Wallet wallet)
{
    for (final TransactionOutput output : tx.getOutputs())
    {
        try
        {
            if (output.isMine(wallet))
            {
                final Script script = output.getScriptPubKey();
                return script.getToAddress(Constants.NETWORK_PARAMETERS, true);
            }
        }
        catch (final ScriptException x)
        {
            // swallow
        }
    }

    return null;
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
@Test
public void pshTx() {

    final List<TransactionInput> inputs = tx1.getInputs();
    for (TransactionInput input : inputs) {
        try {
            Address current = input.getScriptSig().getFromAddress(MainNetParams.get());
            System.out.println(current.toString());
        } catch (ScriptException e) {
            System.out.println("exception");
        }

    }

}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
private Transaction signStandardTx(Transaction tx, Map<String,ECKey> keys){
	// sign
	for(int index=0;index < tx.getInputs().size(); index++){
		TransactionInput in = tx.getInput(index);
		TransactionOutput connectedOutput = in.getConnectedOutput();
		String addFrom = connectedOutput.getScriptPubKey().getToAddress(getNetworkParams()).toString();
		TransactionSignature sig = tx.calculateSignature(index, keys.get(addFrom), 
				connectedOutput.getScriptPubKey(), 
				Transaction.SigHash.ALL, 
				false);
		Script inputScript = ScriptBuilder.createInputScript(sig, keys.get(addFrom));
		in.setScriptSig(inputScript);
		
		try {
			in.getScriptSig().correctlySpends(tx, (long)index, connectedOutput.getScriptPubKey());
		} catch (ScriptException e) {
            return null;
        }
	}
	
	return tx;
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
public ArrayList<TransactionOutput> getUnspentOutputsForAccount(int accountIndex) throws ScriptException, CannotGetAddressException{
	ArrayList<TransactionOutput> ret = new ArrayList<TransactionOutput>();
	List<TransactionOutput> all = mWalletWrapper.getWatchedOutputs();
	for(TransactionOutput unspentOut:all){
		ATAddress add = findAddressInAccounts(unspentOut.getScriptPubKey().getToAddress(getNetworkParams()).toString());
		/*
		 * could happen if an unspent address belongs to a deleted account, it will not find it
		 */
		if(add == null)
			continue;
		
		if(add.getAccountIndex() == accountIndex)
			ret.add(unspentOut);
	}
	return ret;
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
@Nullable
public static Address getToAddressOfSent(final Transaction tx, final Wallet wallet) {
    for (final TransactionOutput output : tx.getOutputs()) {
        try {
            if (!output.isMine(wallet)) {
                final Script script = output.getScriptPubKey();
                return script.getToAddress(Constants.NETWORK_PARAMETERS, true);
            }
        } catch (final ScriptException x) {
            // swallow
        }
    }

    return null;
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
public static Output valueOf(final PaymentProtocol.Output output)
        throws PaymentProtocolException.InvalidOutputs {
    try {
        final Script script = new Script(output.scriptData);
        return new PaymentIntent.Output(output.amount, script);
    } catch (final ScriptException x) {
        throw new PaymentProtocolException.InvalidOutputs(
                "unparseable script in output: " + Constants.HEX.encode(output.scriptData));
    }
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
/**
 * <p>Returns true if the given transaction sends coins to any of our keys, or has inputs spending any of our outputs,
 * and also returns true if tx has inputs that are spending outputs which are
 * not ours but which are spent by pending transactions.</p>
 *
 * <p>Note that if the tx has inputs containing one of our keys, but the connected transaction is not in the wallet,
 * it will not be considered relevant.</p>
 */
public boolean isTransactionRelevant(Transaction tx) throws ScriptException {
    lock.lock();
    try {
        return tx.getValueSentFromMe(this).signum() > 0 ||
               tx.getValueSentToMe(this).signum() > 0 ||
               !findDoubleSpendsAgainst(tx, transactions).isEmpty();
    } finally {
        lock.unlock();
    }
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
private void toStringHelper(StringBuilder builder, Map<Sha256Hash, Transaction> transactionMap,
                            @Nullable AbstractBlockChain chain, @Nullable Comparator<Transaction> sortOrder) {
    checkState(lock.isHeldByCurrentThread());

    final Collection<Transaction> txns;
    if (sortOrder != null) {
        txns = new TreeSet<Transaction>(sortOrder);
        txns.addAll(transactionMap.values());
    } else {
        txns = transactionMap.values();
    }

    for (Transaction tx : txns) {
        try {
            builder.append(tx.getValue(this).toFriendlyString());
            builder.append(" total value (sends ");
            builder.append(tx.getValueSentFromMe(this).toFriendlyString());
            builder.append(" and receives ");
            builder.append(tx.getValueSentToMe(this).toFriendlyString());
            builder.append(")\n");
        } catch (ScriptException e) {
            // Ignore and don't print this line.
        }
        if (tx.hasConfidence())
            builder.append("  confidence: ").append(tx.getConfidence()).append('\n');
        builder.append(tx.toString(chain));
    }
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
private int estimateBytesForSigning(CoinSelection selection) {
        int size = 0;
        for (OutPointOutput utxo : selection.gathered) {
            try {
                TransactionOutput output = utxo.getOutput();
                Script script = output.getScriptPubKey();
                ECKey key = null;
                Script redeemScript = null;
                if (script.isSentToAddress()) {
                    key = account.findKeyFromPubHash(script.getPubKeyHash());
                    if (key == null) {
                        log.error("output.getIndex {}", output.getIndex());
                        log.error("output.getAddressFromP2SH {}", output.getAddressFromP2SH(coinType));
                        log.error("output.getAddressFromP2PKHScript {}", output.getAddressFromP2PKHScript(coinType));
                        log.error("output.getParentTransaction().getHash() {}", output.getParentTransaction().getHash());
                    }
                    Preconditions.checkNotNull(key, "Coin selection includes unspendable outputs");
                } else if (script.isPayToScriptHash()) {
                    throw new ScriptException("Wallet does not currently support PayToScriptHash");
//                    redeemScript = keychain.findRedeemScriptFromPubHash(script.getPubKeyHash());
//                    checkNotNull(redeemScript, "Coin selection includes unspendable outputs");
                }
                size += script.getNumberOfBytesRequiredToSpend(key, redeemScript);
            } catch (ScriptException e) {
                // If this happens it means an output script in a wallet tx could not be understood. That should never
                // happen, if it does it means the wallet has got into an inconsistent state.
                throw new IllegalStateException(e);
            }
        }
        return size;
    }
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
public static Output valueOf(final PaymentProtocol.Output output) throws PaymentProtocolException.InvalidOutputs
{
    try
    {
        final Script script = new Script(output.scriptData);
        return new PaymentIntent.Output(output.amount, script);
    }
    catch (final ScriptException x)
    {
        throw new PaymentProtocolException.InvalidOutputs("unparseable script in output: " + Constants.HEX.encode(output.scriptData));
    }
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
@Override
public void receiveFromBlock(Transaction tx, StoredBlock block, AbstractBlockChain.NewBlockType blockType, int relativityOffset) throws VerificationException {
    // TODO: use BIP 113 timestamps
    if ( (new Date().getTime() / 1000 ) - block.getHeader().getTimeSeconds() > 366 * 24 * 60 * 60) {
        log.debug("NameDB skipping new transaction at height " + block.getHeight() + " due to timestamp " + block.getHeader().getTimeSeconds());
        return;
    }
    
    for (TransactionOutput output : tx.getOutputs()) {
        try {
            Script scriptPubKey = output.getScriptPubKey();
            NameScript ns = new NameScript(scriptPubKey);
            // Always save the coinbase, because it lets us identify that we've received the contents of the block, even if it has no name_anyupdate operations.
            // TODO: maybe save a null reference instead of the actual coinbase tx, since this would cut down on memory usage very slightly.
            if(tx.isCoinBase() || ( ns.isNameOp() && ns.isAnyUpdate() ) ) {
                log.debug("NameDB temporarily storing name transaction until it gets more confirmations.");
                pendingBlockTransactions.put(block.getHeader().getHash(), tx);
            }
        } catch (ScriptException e) {
            // Our threat model is lightweight SPV, which means we
            // don't attempt to reject a blockchain due to a single
            // invalid transaction.  As such, if we see a
            // ScriptException, we just discard the transaction
            // (and log a warning) rather than rejecting the block.
            log.warn("Error checking TransactionOutput for name_anyupdate script!", e);
            continue;
        }
    }
}
 

import org.bitcoinj.core.ScriptException; //导入依赖的package包/类
public boolean isNameOp() {
    switch(op) {
        case OP_NAME_NEW:
        case OP_NAME_FIRSTUPDATE:
        case OP_NAME_UPDATE:
            return true;
        
        case OP_NOP:
            return false;
        
        default:
            throw new ScriptException("Invalid name op");
    }
}