Uses of Class
org.bitcoinj.core.Transaction

Packages that use Transaction

Package	Description
org.bitcoinj.core	The core package contains classes for network messages like Block and Transaction, peer connectivity via PeerGroup, block chain management and the Wallet class.
org.bitcoinj.jni
org.bitcoinj.protocols.channels	Micropayment channels allow for rapid tiny payments to be made to a third party once a channel has been set up, using some of the advanced features of the Bitcoin protocol.
org.bitcoinj.protocols.payments	The BIP70 payment protocol wraps Bitcoin transactions and adds various useful features like memos, refund addresses and authentication.
org.bitcoinj.script	Classes for working with and executing Bitcoin script programs, as embedded in inputs and outputs.
org.bitcoinj.signers	Transaction signers know how to calculate signatures over transactions in different contexts, for example, using local private keys or fetching them from remote servers.
org.bitcoinj.store	Block stores persist blockchain data downloaded from remote peers.
org.bitcoinj.testing	Various utilities for writing unit tests: also useful for testing your own code and apps that build on top of bitcoinj.
org.bitcoinj.wallet	Classes that support the Wallet, which knows how to find and save transactions relevant to a set of keys or scripts, calculate balances, and spend money: the wallet has many features and can be extended in various ways, please refer to the website for documentation on how to use it.

Uses of Transaction in org.bitcoinj.core

Fields in org.bitcoinj.core declared as Transaction

Modifier and Type	Field and Description
Transaction	Wallet.SendResult.tx The Bitcoin transaction message that moves the money.
Transaction	Wallet.SendRequest.tx A transaction, probably incomplete, that describes the outline of what you want to do.

Fields in org.bitcoinj.core with type parameters of type Transaction

Modifier and Type	Field and Description
ListenableFuture<Transaction>	Wallet.SendResult.broadcastComplete A future that will complete once the tx message has been successfully broadcast to the network.
static Comparator<Transaction>	Transaction.SORT_TX_BY_HEIGHT A comparator that can be used to sort transactions by their chain height.
static Comparator<Transaction>	Transaction.SORT_TX_BY_UPDATE_TIME A comparator that can be used to sort transactions by their updateTime field.
protected Map<Sha256Hash,Transaction>	Wallet.transactions

Methods in org.bitcoinj.core that return Transaction

Modifier and Type	Method and Description
Transaction	Wallet.createSend(Address address, Coin value) Statelessly creates a transaction that sends the given value to address.
Transaction	MemoryPool.get(Sha256Hash hash) Returns the Transaction for the given hash if we have downloaded it, or null if that hash is unknown or we only saw advertisements for it yet or it has been downloaded but garbage collected due to nowhere else holding a reference to it.
Transaction	TransactionConfidence.getOverridingTransaction() If this transaction has been overridden by a double spend (is dead), this call returns the overriding transaction.
Transaction	TransactionOutput.getParentTransaction() Returns the transaction that owns this output, or throws NullPointerException if unowned.
Transaction	TransactionInput.getParentTransaction()
Transaction	Wallet.getTransaction(Sha256Hash hash) Returns a transaction object given its hash, if it exists in this wallet, or null otherwise.
Transaction	MemoryPool.intern(Transaction tx) Puts the tx into the table and returns either it, or a different Transaction object that has the same hash.
Transaction	MemoryPool.seen(Transaction tx, PeerAddress byPeer) Called by peers when they receive a "tx" message containing a valid serialized transaction.
Transaction	Wallet.sendCoins(Peer peer, Wallet.SendRequest request) Sends coins to the given address, via the given Peer.
Transaction	Wallet.sendCoinsOffline(Wallet.SendRequest request) Sends coins to the given address but does not broadcast the resulting pending transaction.

Methods in org.bitcoinj.core that return types with arguments of type Transaction

Modifier and Type	Method and Description
ListenableFuture<Transaction>	TransactionBroadcast.broadcast()
ListenableFuture<Transaction>	TransactionBroadcaster.broadcastTransaction(Transaction tx) Broadcast the given transaction on the network
ListenableFuture<Transaction>	PeerGroup.broadcastTransaction(Transaction tx) Calls PeerGroup.broadcastTransaction(Transaction,int) with getMinBroadcastConnections() as the number of connections to wait for before commencing broadcast.
ListenableFuture<Transaction>	PeerGroup.broadcastTransaction(Transaction tx, int minConnections) Given a transaction, sends it un-announced to one peer and then waits for it to be received back from other peers.
ListenableFuture<List<Transaction>>	Peer.downloadDependencies(Transaction tx) Returns a future that wraps a list of all transactions that the given transaction depends on, recursively.
ListenableFuture<Transaction>	TransactionBroadcast.future()
Map<Sha256Hash,Transaction>	FilteredBlock.getAssociatedTransactions() Gets the set of transactions which were provided using provideTransaction() which match in getTransactionHashes()
ListenableFuture<Transaction>	TransactionConfidence.getDepthFuture(int depth)
ListenableFuture<Transaction>	TransactionConfidence.getDepthFuture(int depth, Executor executor) Returns a future that completes when the transaction has been confirmed by "depth" blocks.
ListenableFuture<Transaction>	Peer.getPeerMempoolTransaction(Sha256Hash hash) Asks the connected peer for the given transaction from its memory pool.
Collection<Transaction>	Wallet.getPendingTransactions() Returns an immutable view of the transactions currently waiting for network confirmations.
List<Transaction>	Wallet.getRecentTransactions(int numTransactions, boolean includeDead) Returns an list of N transactions, ordered by increasing age.
Map<Sha256Hash,Transaction>	Wallet.getTransactionPool(WalletTransaction.Pool pool) Returns transactions from a specific pool.
Map<Sha256Hash,Transaction>	TransactionBag.getTransactionPool(WalletTransaction.Pool pool) Returns transactions from a specific pool.
List<Transaction>	StoredUndoableBlock.getTransactions() Get the full list of transactions if it is stored, otherwise null.
List<Transaction>	Block.getTransactions() Returns an immutable list of transactions held in this block.
Set<Transaction>	Wallet.getTransactions(boolean includeDead) Returns a set of all transactions in the wallet.
List<Transaction>	Wallet.getTransactionsByTime() Returns all non-dead, active transactions ordered by recency.
ListenableFuture<List<Transaction>>	Wallet.maybeDoMaintenance(org.spongycastle.crypto.params.KeyParameter aesKey, boolean andSend) A wallet app should call this from time to time if key rotation is enabled in order to let the wallet craft and send transactions needed to re-organise coins internally.

Methods in org.bitcoinj.core with parameters of type Transaction

Modifier and Type	Method and Description
void	InventoryMessage.addTransaction(Transaction tx)
void	Block.addTransaction(Transaction t) Adds a transaction to this block.
boolean	BloomFilter.applyAndUpdate(Transaction tx)
ListenableFuture<Transaction>	TransactionBroadcaster.broadcastTransaction(Transaction tx) Broadcast the given transaction on the network
ListenableFuture<Transaction>	PeerGroup.broadcastTransaction(Transaction tx) Calls PeerGroup.broadcastTransaction(Transaction,int) with getMinBroadcastConnections() as the number of connections to wait for before commencing broadcast.
ListenableFuture<Transaction>	PeerGroup.broadcastTransaction(Transaction tx, int minConnections) Given a transaction, sends it un-announced to one peer and then waits for it to be received back from other peers.
void	Wallet.commitTx(Transaction tx) Updates the wallet with the given transaction: puts it into the pending pool, sets the spent flags and runs the onCoinsSent/onCoinsReceived event listener.
TransactionInput.ConnectionResult	TransactionInput.connect(Transaction transaction, TransactionInput.ConnectMode mode) Connects this input to the relevant output of the referenced transaction.
ListenableFuture<List<Transaction>>	Peer.downloadDependencies(Transaction tx) Returns a future that wraps a list of all transactions that the given transaction depends on, recursively.
static Wallet.SendRequest	Wallet.SendRequest.forTx(Transaction tx) Simply wraps a pre-built incomplete transaction provided by you.
Transaction	MemoryPool.intern(Transaction tx) Puts the tx into the table and returns either it, or a different Transaction object that has the same hash.
boolean	Wallet.isPendingTransactionRelevant(Transaction tx) This method is used by a 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.
boolean	Wallet.isTransactionRelevant(Transaction tx) 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.
boolean	BlockChainListener.isTransactionRelevant(Transaction tx) Returns true if the given transaction is interesting to the listener.
boolean	AbstractBlockChainListener.isTransactionRelevant(Transaction tx)
boolean	Wallet.isTransactionRisky(Transaction tx, List<Transaction> dependencies) Given a transaction and an optional list of dependencies (recursive/flattened), returns true if the given transaction would be rejected by the analyzer, or false otherwise.
boolean	Wallet.maybeCommitTx(Transaction tx) Calls Wallet.commitTx(org.bitcoinj.core.Transaction) if tx is not already in the pending pool
void	WalletEventListener.onCoinsReceived(Wallet wallet, Transaction tx, Coin prevBalance, Coin newBalance) This is called when a transaction is seen that sends coins to this wallet, either because it was broadcast across the network or because a block was received.
void	AbstractWalletEventListener.onCoinsReceived(Wallet wallet, Transaction tx, Coin prevBalance, Coin newBalance)
void	WalletEventListener.onCoinsSent(Wallet wallet, Transaction tx, Coin prevBalance, Coin newBalance) This is called when a transaction is seen that sends coins from this wallet, either because it was broadcast across the network or because a block was received.
void	AbstractWalletEventListener.onCoinsSent(Wallet wallet, Transaction tx, Coin prevBalance, Coin newBalance)
void	TransactionConfidence.Listener.onConfidenceChanged(Transaction tx, TransactionConfidence.Listener.ChangeReason reason)
void	PeerEventListener.onTransaction(Peer peer, Transaction t) Called when a new transaction is broadcast over the network.
void	AbstractPeerEventListener.onTransaction(Peer peer, Transaction t)
void	WalletEventListener.onTransactionConfidenceChanged(Wallet wallet, Transaction tx) Called when a transaction changes its confidence level.
void	AbstractWalletEventListener.onTransactionConfidenceChanged(Wallet wallet, Transaction tx)
boolean	FilteredBlock.provideTransaction(Transaction tx) Provide this FilteredBlock with a transaction which is in its merkle tree
protected void	Wallet.queueOnCoinsReceived(Transaction tx, Coin balance, Coin newBalance)
protected void	Wallet.queueOnCoinsSent(Transaction tx, Coin prevBalance, Coin newBalance)
void	Wallet.receiveFromBlock(Transaction tx, StoredBlock block, AbstractBlockChain.NewBlockType blockType, int relativityOffset) Called by the BlockChain when we receive a new block that sends coins to one of our addresses or spends coins from one of our addresses (note that a single transaction can do both).
void	BlockChainListener.receiveFromBlock(Transaction tx, StoredBlock block, AbstractBlockChain.NewBlockType blockType, int relativityOffset) Called by the BlockChain when we receive a new block that contains a relevant transaction.
void	AbstractBlockChainListener.receiveFromBlock(Transaction tx, StoredBlock block, AbstractBlockChain.NewBlockType blockType, int relativityOffset)
void	Wallet.receivePending(Transaction tx, List<Transaction> dependencies) Called when we have found a transaction (via network broadcast or otherwise) that is relevant to this wallet and want to record it.
void	Wallet.receivePending(Transaction tx, List<Transaction> dependencies, boolean overrideIsRelevant) Called when we have found a transaction (via network broadcast or otherwise) that is relevant to this wallet and want to record it.
Transaction	MemoryPool.seen(Transaction tx, PeerAddress byPeer) Called by peers when they receive a "tx" message containing a valid serialized transaction.
void	TransactionConfidence.setOverridingTransaction(Transaction overridingTransaction) Called when the transaction becomes newly dead, that is, we learn that one of its inputs has already been spent in such a way that the double-spending transaction takes precedence over this one.
static InventoryMessage	InventoryMessage.with(Transaction... txns) Creates a new inv message for the given transactions.

Method parameters in org.bitcoinj.core with type arguments of type Transaction

Modifier and Type	Method and Description
TransactionInput.ConnectionResult	TransactionInput.connect(Map<Sha256Hash,Transaction> transactions, TransactionInput.ConnectMode mode) Connects this input to the relevant output of the referenced transaction if it's in the given map.
boolean	Wallet.isTransactionRisky(Transaction tx, List<Transaction> dependencies) Given a transaction and an optional list of dependencies (recursive/flattened), returns true if the given transaction would be rejected by the analyzer, or false otherwise.
void	Wallet.receivePending(Transaction tx, List<Transaction> dependencies) Called when we have found a transaction (via network broadcast or otherwise) that is relevant to this wallet and want to record it.
void	Wallet.receivePending(Transaction tx, List<Transaction> dependencies, boolean overrideIsRelevant) Called when we have found a transaction (via network broadcast or otherwise) that is relevant to this wallet and want to record it.

Constructors in org.bitcoinj.core with parameters of type Transaction

Constructor and Description
TransactionBroadcast(PeerGroup peerGroup, Transaction tx)
TransactionConfidence(Transaction tx)
TransactionInput(NetworkParameters params, Transaction parentTransaction, byte[] scriptBytes) Creates an input that connects to nothing - used only in creation of coinbase transactions.
TransactionInput(NetworkParameters params, Transaction parentTransaction, byte[] payload, int offset) Deserializes an input message.
TransactionInput(NetworkParameters params, Transaction parentTransaction, byte[] payload, int offset, boolean parseLazy, boolean parseRetain) Deserializes an input message.
TransactionInput(NetworkParameters params, Transaction parentTransaction, byte[] scriptBytes, TransactionOutPoint outpoint)
TransactionInput(NetworkParameters params, Transaction parentTransaction, byte[] scriptBytes, TransactionOutPoint outpoint, Coin value)
TransactionOutPoint(NetworkParameters params, long index, Transaction fromTx)
TransactionOutput(NetworkParameters params, Transaction parent, byte[] payload, int offset) Deserializes a transaction output message.
TransactionOutput(NetworkParameters params, Transaction parent, byte[] payload, int offset, boolean parseLazy, boolean parseRetain) Deserializes a transaction output message.
TransactionOutput(NetworkParameters params, Transaction parent, Coin value, Address to) Creates an output that sends 'value' to the given address (public key hash).
TransactionOutput(NetworkParameters params, Transaction parent, Coin value, byte[] scriptBytes)
TransactionOutput(NetworkParameters params, Transaction parent, Coin value, ECKey to) Creates an output that sends 'value' to the given public key using a simple CHECKSIG script (no addresses).

Constructor parameters in org.bitcoinj.core with type arguments of type Transaction

Constructor and Description
Block(NetworkParameters params, long version, Sha256Hash prevBlockHash, Sha256Hash merkleRoot, long time, long difficultyTarget, long nonce, List<Transaction> transactions) Construct a block initialized with all the given fields.
StoredUndoableBlock(Sha256Hash hash, List<Transaction> transactions)

Uses of Transaction in org.bitcoinj.jni

Methods in org.bitcoinj.jni with parameters of type Transaction

Modifier and Type	Method and Description
boolean	NativeBlockChainListener.isTransactionRelevant(Transaction tx)
void	NativeWalletEventListener.onCoinsReceived(Wallet wallet, Transaction tx, Coin prevBalance, Coin newBalance)
void	NativeWalletEventListener.onCoinsSent(Wallet wallet, Transaction tx, Coin prevBalance, Coin newBalance)
void	NativeTransactionConfidenceListener.onConfidenceChanged(Transaction tx, TransactionConfidence.Listener.ChangeReason reason)
void	NativePeerEventListener.onTransaction(Peer peer, Transaction t)
void	NativeWalletEventListener.onTransactionConfidenceChanged(Wallet wallet, Transaction tx)
void	NativeBlockChainListener.receiveFromBlock(Transaction tx, StoredBlock block, AbstractBlockChain.NewBlockType blockType, int relativityOffset)

Uses of Transaction in org.bitcoinj.protocols.channels

Methods in org.bitcoinj.protocols.channels that return Transaction

Modifier and Type	Method and Description
Transaction	PaymentChannelClientState.getCompletedRefundTransaction() Once the servers signature over the refund transaction has been received and provided using PaymentChannelClientState.provideRefundSignature(byte[]) then this method can be called to receive the now valid and broadcastable refund transaction.
Transaction	PaymentChannelClientState.getIncompleteRefundTransaction() Returns a partially signed (invalid) refund transaction that should be passed to the server.
Transaction	PaymentChannelServerState.getMultisigContract() Gets the multisig contract which was used to initialize this channel
Transaction	PaymentChannelClientState.getMultisigContract() Returns the transaction that locks the money to the agreement of both parties.

Methods in org.bitcoinj.protocols.channels that return types with arguments of type Transaction

Modifier and Type	Method and Description
ListenableFuture<Transaction>	PaymentChannelServerState.close() Closes this channel and broadcasts the highest value payment transaction on the network.

Methods in org.bitcoinj.protocols.channels with parameters of type Transaction

Modifier and Type	Method and Description
boolean	PaymentChannelClientState.isSettlementTransaction(Transaction tx) Returns true if the tx is a valid settlement transaction.
ListenableFuture<PaymentChannelServerState>	PaymentChannelServerState.provideMultiSigContract(Transaction multisigContract) Called when the client provides the multi-sig contract.
byte[]	PaymentChannelServerState.provideRefundTransaction(Transaction refundTx, byte[] clientMultiSigPubKey) Called when the client provides the refund transaction.

Uses of Transaction in org.bitcoinj.protocols.payments

Methods in org.bitcoinj.protocols.payments that return types with arguments of type Transaction

Modifier and Type	Method and Description
static List<Transaction>	PaymentProtocol.parseTransactionsFromPaymentMessage(NetworkParameters params, Protos.Payment paymentMessage) Parse transactions from payment message.

Method parameters in org.bitcoinj.protocols.payments with type arguments of type Transaction

Modifier and Type	Method and Description
static Protos.Payment	PaymentProtocol.createPaymentMessage(List<Transaction> transactions, Coin refundAmount, Address refundAddress, String memo, byte[] merchantData) Create a payment message with one standard pay to address output.
static Protos.Payment	PaymentProtocol.createPaymentMessage(List<Transaction> transactions, List<Protos.Output> refundOutputs, String memo, byte[] merchantData) Create a payment message.
Protos.Payment	PaymentSession.getPayment(List<Transaction> txns, Address refundAddr, String memo) Generates a Payment message based on the information in the PaymentRequest.
ListenableFuture<PaymentProtocol.Ack>	PaymentSession.sendPayment(List<Transaction> txns, Address refundAddr, String memo) Generates a Payment message and sends the payment to the merchant who sent the PaymentRequest.

Uses of Transaction in org.bitcoinj.script

Methods in org.bitcoinj.script with parameters of type Transaction

Modifier and Type	Method and Description
void	Script.correctlySpends(Transaction txContainingThis, long scriptSigIndex, Script scriptPubKey) Verifies that this script (interpreted as a scriptSig) correctly spends the given scriptPubKey, enabling all validation rules.
void	Script.correctlySpends(Transaction txContainingThis, long scriptSigIndex, Script scriptPubKey, Set<Script.VerifyFlag> verifyFlags) Verifies that this script (interpreted as a scriptSig) correctly spends the given scriptPubKey.
static void	Script.executeScript(Transaction txContainingThis, long index, Script script, LinkedList<byte[]> stack, boolean enforceNullDummy) Exposes the script interpreter.

Uses of Transaction in org.bitcoinj.signers

Fields in org.bitcoinj.signers declared as Transaction

Modifier and Type	Field and Description
Transaction	TransactionSigner.ProposedTransaction.partialTx

Constructors in org.bitcoinj.signers with parameters of type Transaction

Constructor and Description
ProposedTransaction(Transaction partialTx)

Uses of Transaction in org.bitcoinj.store

Fields in org.bitcoinj.store with type parameters of type Transaction

Modifier and Type	Field and Description
protected Map<com.google.protobuf.ByteString,Transaction>	WalletProtobufSerializer.txMap

Uses of Transaction in org.bitcoinj.testing

Fields in org.bitcoinj.testing declared as Transaction

Modifier and Type	Field and Description
Transaction	FakeTxBuilder.DoubleSpends.prevTx
Transaction	FakeTxBuilder.DoubleSpends.t1
Transaction	FakeTxBuilder.DoubleSpends.t2
Transaction	MockTransactionBroadcaster.TxFuturePair.tx

Fields in org.bitcoinj.testing with type parameters of type Transaction

Modifier and Type	Field and Description
SettableFuture<Transaction>	MockTransactionBroadcaster.TxFuturePair.future

Methods in org.bitcoinj.testing that return Transaction

Modifier and Type	Method and Description
static Transaction	FakeTxBuilder.createFakeTx(NetworkParameters params, Coin value, Address to) Create a fake TX of sufficient realism to exercise the unit tests.
static Transaction[]	FakeTxBuilder.createFakeTx(NetworkParameters params, Coin value, Address to, Address from) Transaction[0] is a feeder transaction, supplying BTC to Transaction[1]
static Transaction	FakeTxBuilder.createFakeTx(NetworkParameters params, Coin value, ECKey to) Create a fake TX of sufficient realism to exercise the unit tests.
static Transaction	FakeTxBuilder.createFakeTxWithChangeAddress(NetworkParameters params, Coin value, Address to, Address changeOutput) Create a fake TX of sufficient realism to exercise the unit tests.
static Transaction	FakeTxBuilder.roundTripTransaction(NetworkParameters params, Transaction tx) Roundtrip a transaction so that it appears as if it has just come from the wire
protected Transaction	TestWithWallet.sendMoneyToWallet(Coin value, AbstractBlockChain.NewBlockType type)
protected Transaction	TestWithWallet.sendMoneyToWallet(Transaction tx, AbstractBlockChain.NewBlockType type)
protected Transaction	TestWithWallet.sendMoneyToWallet(Wallet wallet, Coin value, Address toAddress, AbstractBlockChain.NewBlockType type)
protected Transaction	TestWithWallet.sendMoneyToWallet(Wallet wallet, Coin value, ECKey toPubKey, AbstractBlockChain.NewBlockType type)
protected Transaction	TestWithWallet.sendMoneyToWallet(Wallet wallet, Transaction tx, AbstractBlockChain.NewBlockType type)
Transaction	MockTransactionBroadcaster.waitForTransaction()
Transaction	MockTransactionBroadcaster.waitForTransactionAndSucceed()

Methods in org.bitcoinj.testing that return types with arguments of type Transaction

Modifier and Type	Method and Description
SettableFuture<Transaction>	MockTransactionBroadcaster.broadcastTransaction(Transaction tx)

Methods in org.bitcoinj.testing with parameters of type Transaction

Modifier and Type	Method and Description
SettableFuture<Transaction>	MockTransactionBroadcaster.broadcastTransaction(Transaction tx)
static FakeTxBuilder.BlockPair	FakeTxBuilder.createFakeBlock(BlockStore blockStore, long timeSeconds, Transaction... transactions) Emulates receiving a valid block that builds on top of the chain.
static FakeTxBuilder.BlockPair	FakeTxBuilder.createFakeBlock(BlockStore blockStore, Transaction... transactions)
static Block	FakeTxBuilder.makeSolvedTestBlock(Block prev, Address to, Transaction... transactions)
static Block	FakeTxBuilder.makeSolvedTestBlock(Block prev, Transaction... transactions)
static Transaction	FakeTxBuilder.roundTripTransaction(NetworkParameters params, Transaction tx) Roundtrip a transaction so that it appears as if it has just come from the wire
protected Transaction	TestWithWallet.sendMoneyToWallet(Transaction tx, AbstractBlockChain.NewBlockType type)
protected Transaction	TestWithWallet.sendMoneyToWallet(Wallet wallet, Transaction tx, AbstractBlockChain.NewBlockType type)

Constructors in org.bitcoinj.testing with parameters of type Transaction

Constructor and Description
TxFuturePair(Transaction tx, SettableFuture<Transaction> future)

Constructor parameters in org.bitcoinj.testing with type arguments of type Transaction

Constructor and Description
TxFuturePair(Transaction tx, SettableFuture<Transaction> future)

Uses of Transaction in org.bitcoinj.wallet

Fields in org.bitcoinj.wallet declared as Transaction

Modifier and Type	Field and Description
protected Transaction	DefaultRiskAnalysis.nonFinal
protected Transaction	DefaultRiskAnalysis.tx

Fields in org.bitcoinj.wallet with type parameters of type Transaction

Modifier and Type	Field and Description
protected List<Transaction>	DefaultRiskAnalysis.dependencies

Methods in org.bitcoinj.wallet that return Transaction

Modifier and Type	Method and Description
Transaction	DefaultRiskAnalysis.getNonFinal() Returns the transaction that was found to be non-final, or null.
Transaction	DefaultRiskAnalysis.getNonStandard() Returns the transaction that was found to be non-standard, or null.
Transaction	WalletTransaction.getTransaction()

Methods in org.bitcoinj.wallet with parameters of type Transaction

Modifier and Type	Method and Description
RiskAnalysis	RiskAnalysis.Analyzer.create(Wallet wallet, Transaction tx, List<Transaction> dependencies)
DefaultRiskAnalysis	DefaultRiskAnalysis.Analyzer.create(Wallet wallet, Transaction tx, List<Transaction> dependencies)
void	FilteringCoinSelector.excludeOutputsSpentBy(Transaction tx)
static boolean	DefaultCoinSelector.isSelectable(Transaction tx)
static DefaultRiskAnalysis.RuleViolation	DefaultRiskAnalysis.isStandard(Transaction tx) Checks if a transaction is considered "standard" by the reference client's IsStandardTx and AreInputsStandard functions.
protected boolean	DefaultCoinSelector.shouldSelect(Transaction tx) Sub-classes can override this to just customize whether transactions are usable, but keep age sorting.
protected boolean	AllowUnconfirmedCoinSelector.shouldSelect(Transaction tx)

Method parameters in org.bitcoinj.wallet with type arguments of type Transaction

Modifier and Type	Method and Description
RiskAnalysis	RiskAnalysis.Analyzer.create(Wallet wallet, Transaction tx, List<Transaction> dependencies)
DefaultRiskAnalysis	DefaultRiskAnalysis.Analyzer.create(Wallet wallet, Transaction tx, List<Transaction> dependencies)

Constructors in org.bitcoinj.wallet with parameters of type Transaction

Constructor and Description
WalletTransaction(WalletTransaction.Pool pool, Transaction transaction)