import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
private Result analyzeIsStandard() {
    if (!wallet.getNetworkParameters().getId().equals(NetworkParameters.ID_MAINNET))
        return Result.OK;

    nonStandard = isStandard(tx);
    if (nonStandard != null)
        return Result.NON_STANDARD;

    for (Transaction dep : dependencies) {
        nonStandard = isStandard(dep);
        if (nonStandard != null)
            return Result.NON_STANDARD;
    }

    return Result.OK;
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
public OpenTx(LotteryTx commitTx, ECKey sk, List<byte[]> pks, Address address, 
		byte[] secret, BigInteger fee, boolean testnet) throws VerificationException {
	NetworkParameters params = getNetworkParameters(testnet);
	int noPlayers = commitTx.getOutputs().size();
	tx = new Transaction(params);
	BigInteger value = BigInteger.ZERO;
	for (TransactionOutput out : commitTx.getOutputs()) {
		tx.addInput(out);
		value = value.add(out.getValue());
	}
	tx.addOutput(value.subtract(fee), address);
	for (int k = 0; k < noPlayers; ++k) {
		byte[] sig = sign(k, sk).encodeToBitcoin();
		tx.getInput(k).setScriptSig(new ScriptBuilder()
											.data(sig)
											.data(sk.getPubKey())
											.data(sig) // wrong signature in a good format
											.data(pks.get(k))
											.data(secret)
											.build());
		tx.getInput(k).verify();
	}
	tx.verify();
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
private static String buildRawTx() {
	ScriptBuilder builder = new ScriptBuilder();
	builder.op(OP_DEPTH).op(OP_1).op(OP_NUMEQUAL).op(OP_IF)
			.data("name of nakakamoto".getBytes()).op(OP_DROP)
			.op(OP_RIPEMD160).op(OP_RIPEMD160)
			.data(doublehash160("satoshi".getBytes())).op(OP_EQUAL)
			.op(OP_ELSE).op(OP_DUP).op(OP_HASH160)
			.data(doublehash160("Haha".getBytes())).op(OP_EQUALVERIFY)
			.op(OP_CHECKSIG).op(OP_ENDIF);

	Script outputScript = builder.build();
	Transaction tx1 = new Transaction(MainNetParams.get());
	tx1.addInput(new TransactionInput(MainNetParams.get(), tx1,
			new byte[] {}));
	ECKey key = new ECKey();
	tx1.addOutput(Bitcoins.toSatoshiEndBully(), key);
	Transaction tx2 = new Transaction(MainNetParams.get());

	tx2.addInput(tx1.getOutput(0));
	tx2.addOutput(Bitcoins.toSatoshiEndBully(), outputScript);
	tx2.addOutput(Bitcoins.toSatoshiEndBully(), key);
	System.out.println(tx2);
	String rawTx = BaseEncoding.base16().encode(
			tx2.unsafeBitcoinSerialize());
	return rawTx;
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
public static void invokeOnCoinsSent(final Transaction tx, final long result) {
	new Thread(new Runnable() {
		@Override
		public void run() {
			synchronized (listeners) {
				for (final ListenerWeakContainer listener : listeners) {
					if (listener.get() == null)
						return;

					handler.post(new Runnable() {
						@Override
						public void run() {
							EventListener _listener = listener.get();
							if (_listener != null) {
								_listener.onCoinsSent(tx, result);
							}
						}
					});
				}
			}	
		}
	}).start();
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
private Result analyzeIsFinal() {
    // Transactions we create ourselves are, by definition, not at risk of double spending against us.
    if (tx.getConfidence().getSource() == TransactionConfidence.Source.SELF)
        return Result.OK;

    final int height = wallet.getLastBlockSeenHeight();
    final long time = wallet.getLastBlockSeenTimeSecs();
    // If the transaction has a lock time specified in blocks, we consider that if the tx would become final in the
    // next block it is not risky (as it would confirm normally).
    final int adjustedHeight = height + 1;

    if (!tx.isFinal(adjustedHeight, time)) {
        nonFinal = tx;
        return Result.NON_FINAL;
    }
    for (Transaction dep : dependencies) {
        if (!dep.isFinal(adjustedHeight, time)) {
            nonFinal = dep;
            return Result.NON_FINAL;
        }
    }
    return Result.OK;
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
public void importBlock(Block block, Integer blockHeight) {
	statusMessage = "Importing block "+blockHeight;
	logger.info(statusMessage);
	Database db = Database.getInstance();
	ResultSet rs = db.executeQuery("select * from blocks where block_hash='"+block.getHashAsString()+"';");
	try {
		if (!rs.next()) {
			db.executeUpdate("INSERT INTO blocks(block_index,block_hash,block_time,block_nonce) VALUES('"+blockHeight.toString()+"','"+block.getHashAsString()+"','"+block.getTimeSeconds()+"','"+block.getNonce()+"')");
		}
		Integer txSnInBlock=0;
		for (Transaction tx : block.getTransactions()) {
			importTransaction(tx,txSnInBlock, block, blockHeight);
			txSnInBlock++;
		}
		//Bet.resolve(blockHeight);  //pengding test
		//BetWorldCup.resolve(blockHeight,new Long(block.getTimeSeconds()).intValue());
		//Order.expire();
	} catch (SQLException e) {
	}
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
@CheckForNull
public static Address getFirstToAddress(@Nonnull final Transaction tx)
{
	try
	{
		for (final TransactionOutput output : tx.getOutputs())
		{
			return output.getScriptPubKey().getToAddress(Constants.NETWORK_PARAMETERS);
		}

		throw new IllegalStateException();
	}
	catch (final ScriptException x)
	{
		return null;
	}
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
public PayDepositTx(byte[] rawTx, TransactionOutput out, ECKey sk, boolean testnet) throws VerificationException {
	tx = new Transaction(getNetworkParameters(testnet), rawTx);
	validateIsIncopletePayDeposit(sk);
	tx.getInput(0).connect(out);
	computeInScript(sk);
	tx.verify();
	tx.getInput(0).verify();
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
/**
 * Returns true if the given signature is has canonical encoding, and will thus be accepted as standard by
 * the reference client. DER and the SIGHASH encoding allow for quite some flexibility in how the same structures
 * are encoded, and this can open up novel attacks in which a man in the middle takes a transaction and then
 * changes its signature such that the transaction hash is different but it's still valid. This can confuse wallets
 * and generally violates people's mental model of how Bitcoin should work, thus, non-canonical signatures are now
 * not relayed by default.
 */
public static boolean isEncodingCanonical(byte[] signature) {
    // See reference client's IsCanonicalSignature, https://bitcointalk.org/index.php?topic=8392.msg127623#msg127623
    // A canonical signature exists of: <30> <total len> <02> <len R> <R> <02> <len S> <S> <hashtype>
    // Where R and S are not negative (their first byte has its highest bit not set), and not
    // excessively padded (do not start with a 0 byte, unless an otherwise negative number follows,
    // in which case a single 0 byte is necessary and even required).
    if (signature.length < 9 || signature.length > 73)
        return false;

    int hashType = signature[signature.length-1] & ((int)(~Transaction.SIGHASH_ANYONECANPAY_VALUE));
    if (hashType < (Transaction.SigHash.ALL.ordinal() + 1) || hashType > (Transaction.SigHash.SINGLE.ordinal() + 1))
        return false;

    //                   "wrong type"                  "wrong length marker"
    if ((signature[0] & 0xff) != 0x30 || (signature[1] & 0xff) != signature.length-3)
        return false;

    int lenR = signature[3] & 0xff;
    if (5 + lenR >= signature.length || lenR == 0)
        return false;
    int lenS = signature[5+lenR] & 0xff;
    if (lenR + lenS + 7 != signature.length || lenS == 0)
        return false;

    //    R value type mismatch          R value negative
    if (signature[4-2] != 0x02 || (signature[4] & 0x80) == 0x80)
        return false;
    if (lenR > 1 && signature[4] == 0x00 && (signature[4+1] & 0x80) != 0x80)
        return false; // R value excessively padded

    //       S value type mismatch                    S value negative
    if (signature[6 + lenR - 2] != 0x02 || (signature[6 + lenR] & 0x80) == 0x80)
        return false;
    if (lenS > 1 && signature[6 + lenR] == 0x00 && (signature[6 + lenR + 1] & 0x80) != 0x80)
        return false; // S value excessively padded

    return true;
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
public Transaction.SigHash sigHashMode() {
    final int mode = sighashFlags & 0x1f;
    if (mode == Transaction.SigHash.NONE.ordinal() + 1)
        return Transaction.SigHash.NONE;
    else if (mode == Transaction.SigHash.SINGLE.ordinal() + 1)
        return Transaction.SigHash.SINGLE;
    else
        return Transaction.SigHash.ALL;
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
private void handlePasteClipboard()
{
	if (clipboardManager.hasText())
	{
		final String input = clipboardManager.getText().toString().trim();

		new StringInputParser(input)
		{
			@Override
			protected void bitcoinRequest(final Address address, final String addressLabel, final BigInteger amount, final String bluetoothMac)
			{
				EditAddressBookEntryFragment.edit(getFragmentManager(), address.toString());
			}

			@Override
			protected void directTransaction(final Transaction transaction)
			{
				cannotClassify(input);
			}

			@Override
			protected void error(final int messageResId, final Object... messageArgs)
			{
				dialog(activity, null, R.string.address_book_options_paste_from_clipboard_title, messageResId, messageArgs);
			}
		}.parse();
	}
	else
	{
		activity.toast(R.string.address_book_options_copy_from_clipboard_msg_empty);
	}
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
@Override
public void onCoinsSent(final Transaction tx, final long result) {
	btSend.setVisibility(View.GONE);
       summary3.setVisibility(View.VISIBLE);
       tvSentPrompt.setVisibility(View.VISIBLE);

       if(sendingProgressDialog != null) {
        sendingProgressDialog.dismiss();
       }

       clearSend();
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
@Override
public void onTransactionConfidenceChanged(Wallet wallet, Transaction transaction) {
    if (controller.getCurrentView() == View.TRANSACTIONS_VIEW) {
        ShowTransactionsPanel.updateTransactions(); 
    } else if (controller.getCurrentView() == View.SEND_BITCOIN_VIEW) {
        final int numberOfPeers = (transaction == null || transaction.getConfidence() == null) ? 0 : transaction.getConfidence().getBroadcastByCount();
        //log.debug("numberOfPeers = " + numberOfPeers);
        final Sha256Hash transactionHash = (transaction == null) ? null : transaction.getHash();
        //log.debug((transaction != null && transaction.getConfidence() != null) ? transaction.getConfidence().toString() : "No transaction confidence for tx");
        SendBitcoinConfirmPanel.updatePanelDueToTransactionConfidenceChange(transactionHash, numberOfPeers); 
    }
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
public static boolean isSelectable(Transaction tx, int requiredNumBroadcastPeers) {
    // Only pick chain-included transactions, or transactions that are ours and pending.
    TransactionConfidence confidence = tx.getConfidence();
    TransactionConfidence.ConfidenceType type = confidence.getConfidenceType();
    return type.equals(TransactionConfidence.ConfidenceType.BUILDING) ||

           type.equals(TransactionConfidence.ConfidenceType.PENDING) &&
           confidence.getSource().equals(TransactionConfidence.Source.SELF) &&
           // In regtest mode we expect to have only one peer, so we won't see transactions propagate.
           // TODO: The value 1 below dates from a time when transactions we broadcast *to* were counted, set to 0
           (confidence.numBroadcastPeers() >= requiredNumBroadcastPeers || tx.getParams() == RegTestParams.get());
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
@Override
public void onLoadFinished(final Loader<List<StoredBlock>> loader, final List<StoredBlock> blocks)
{
	adapter.replace(blocks);

	final Loader<Set<Transaction>> transactionLoader = loaderManager.getLoader(ID_TRANSACTION_LOADER);
	if (transactionLoader != null && transactionLoader.isStarted())
		transactionLoader.forceLoad();
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
private void createPayment(HttpServletRequest req, HttpServletResponse resp) throws IOException, BillingExceptionBase, ExecutionException, InterruptedException {
    final Protos.Payment payment = Protos.Payment.parseFrom(req.getInputStream());
    final UUID contractId = UUID.fromString(new String(payment.getMerchantData().toByteArray()));
    // TODO for now just accept one transaction per payment
    Preconditions.checkState(payment.getTransactionsCount() == 1, "Single output transactions for now");

    final List<PendingPayment> pendingPayments = paymentDao.getByBtcContractId(contractId);
    // For now, we take the first one
    final PendingPayment pendingPayment = pendingPayments.size() > 0 ? pendingPayments.get(0) : null;
    if (pendingPayment == null) {
        // Nothing to pay
        resp.setStatus(HttpServletResponse.SC_GONE);
        return;
    }

    transactionLogDao.insertTransactionLog(new TransactionLog(new DateTime(DateTimeZone.UTC), "createPayment", pendingPayment.getAccountId(), null, contractId));
    final List<ByteString> transactionList = payment.getTransactionsList();
    //Collection<TransactionOutput> outputs = bitcoinManager.isMine(transactionList.get(0));
    //Preconditions.checkState(outputs.size() == 1, "Expecting one");

    final Transaction broadcastedTransaction = bitcoinManager.broadcastTransaction(transactionList.get(0));

    bitcoinManager.commitTransaction(broadcastedTransaction);

    // PIERRE TODO We cannot solely rely on transactionId because of Malleability issues -- https://en.bitcoin.it/wiki/Transaction_Malleability
    // We should really track transaction with inputs, outputs -- which contain the address
    paymentDao.update(pendingPayment.getRecordId(), broadcastedTransaction.getHash().toString());

    final Protos.PaymentACK paymentAck = Protos.PaymentACK.newBuilder()
                                                          .setPayment(payment)
                                                          .setMemo("Kill Bill payment id " + pendingPayment.getPaymentId())
                                                          .build();
    paymentAck.writeTo(resp.getOutputStream());
    resp.setContentType("application/bitcoin-paymentack");
    resp.setStatus(HttpServletResponse.SC_OK);
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
@Override
public void onCoinsReceived(final Transaction tx, final long result)
{
	try {
		System.out.println("onCoinsReceived()");

		if (tx.getInputs() == null || tx.getInputs().size() == 0) {
			notifyCoinbaseReceived(BigInteger.valueOf(result));
		} else {
			final TransactionInput input = tx.getInputs().get(0);

			final Address from = input.getFromAddress();

			handler.post(new Runnable()
			{
				public void run()
				{
					notifyCoinsReceived(from, BigInteger.valueOf(result));

					notifyWidgets();

				}
			});
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
/** Calculates the byte used in the protocol to represent the combination of mode and anyoneCanPay. */
public static int calcSigHashValue(Transaction.SigHash mode, boolean anyoneCanPay) {
    int sighashFlags = mode.ordinal() + 1;
    if (anyoneCanPay)
        sighashFlags |= Transaction.SIGHASH_ANYONECANPAY_VALUE;
    return sighashFlags;
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
public static boolean isSelectable(Transaction tx) {
    // Only pick chain-included transactions, or transactions that are ours and pending.
    TransactionConfidence confidence = tx.getConfidence();
    TransactionConfidence.ConfidenceType type = confidence.getConfidenceType();
    if (type.equals(TransactionConfidence.ConfidenceType.BUILDING))
        return true;
    return type.equals(TransactionConfidence.ConfidenceType.PENDING) &&
           confidence.getSource().equals(TransactionConfidence.Source.SELF) &&
           confidence.numBroadcastPeers() > 1;
}
 

import com.google.bitcoin.core.Transaction; //导入依赖的package包/类
public static boolean isSelectable(Transaction tx) {
    // Only pick chain-included transactions, or transactions that are ours and pending.
    TransactionConfidence confidence = tx.getConfidence();
    TransactionConfidence.ConfidenceType type = confidence.getConfidenceType();
    return type.equals(TransactionConfidence.ConfidenceType.BUILDING) ||

           type.equals(TransactionConfidence.ConfidenceType.PENDING) &&
           confidence.getSource().equals(TransactionConfidence.Source.SELF) &&
           // In regtest mode we expect to have only one peer, so we won't see transactions propagate.
           // TODO: The value 1 below dates from a time when transactions we broadcast *to* were counted, set to 0
           (confidence.numBroadcastPeers() > 1 || tx.getParams() == RegTestParams.get());
}