All Classes and Interfaces
Class
Description
Parameters for Bitcoin-like networks.
An AbstractBlockChain holds a series of
Block objects, links them together, and knows how to verify that
the chain follows the rules of the NetworkParameters for this chain.Indicates whether new Block was on the best chain or not
Deprecated.
A base class which provides basic support for socket timeouts.
Base class for addresses, e.g.
This exception is thrown by
Base58, Bech32 and the PrefixedChecksummedBytes hierarchy of
classes when you try to decode data and a character isn't valid.This exception is thrown by
Base58, Bech32 and the PrefixedChecksummedBytes hierarchy of
classes when you try to decode data and the checksum isn't valid.This exception is thrown by
Base58, Bech32 and the PrefixedChecksummedBytes hierarchy of
classes when you try to decode data and the data isn't of the right size.This exception is thrown by the
PrefixedChecksummedBytes hierarchy of classes when you try and decode an
address or private key with an invalid prefix (version header or human-readable part).This exception is thrown by
SegwitAddress when you try to decode data and the witness version doesn't
match the Bech32 encoding as per BIP350.This exception is thrown by the
PrefixedChecksummedBytes hierarchy of classes when you try and decode an
address with a prefix (version header or human-readable part) that used by another network (usually: mainnet vs
testnet).Represents an "addr" message on the P2P network, which contains broadcast IP addresses of other peers.
Represents an "addrv2" message on the P2P network, which contains broadcast IP addresses of other peers.
This coin selector will select any transaction at all, regardless of where it came from or whether it was
confirmed yet.
Indicates that an attempt was made to upgrade a random wallet to deterministic, but there were no non-rotating
random keys to use as source material for the seed.
Find/create App Data Directory in correct platform-specific location.
Base58 is a way to encode Bitcoin addresses (or arbitrary data) as alphanumeric strings.
A simple implementation of
TaggableObject that uses a hashmap that is
synchronized on this object's Java monitor.A
KeyChain that implements the simplest model possible: it can have keys imported into it, and just acts as
a dumb bag of keys.Whether this basic key chain is empty, full of regular (usable for signing) keys, or full of watching keys.
Implementation of the Bech32 encoding.
Implementation of BIP 38
passphrase-protected private keys.
Methods to serialize and de-serialize messages to the Bitcoin network format as defined in
the protocol specification.
Provides a standard implementation of a Bitcoin URI with support for the following:
Exception to provide the following to
BitcoinURI:A block is a group of transactions, and is one of the fundamental data structures of the Bitcoin system.
Flags used to control which elements of block validation are done on
received blocks.
A BlockChain implements the simplified payment verification mode of the Bitcoin protocol.
This class reads block files stored in the Bitcoin Core format.
Creates a simple connection to a server using a
StreamConnection to process data.A thin wrapper around a set of
BlockingClients.Represents Block Locator in GetBlocks and GetHeaders messages
An implementor of BlockStore saves StoredBlock objects to disk.
Thrown when something goes wrong with storing a block.
A Bloom filter is a probabilistic data structure which can be sent to another client so that it can avoid
sending us transactions that aren't relevant to our set of keys.
The BLOOM_UPDATE_* constants control when the bloom filter is auto-updated by the peer using
it as a filter, either never, for all outputs or only for P2PK outputs (default)
A Java logging formatter that writes more compact output than the default.
This class, a concrete extension of
BtcFormat, is distinguished by its
accommodation of multiple denominational units as follows:Enum for specifying the style of currency indicators that are used
when formatting, either codes or symbols.
This class, a concrete extension of
BtcFormat, is distinguished in that each
instance formats and by-default parses all Bitcoin monetary values in units of a single
denomination that is specified at the time that instance is constructed.Instances of this class format and parse locale-specific numerical
representations of Bitcoin monetary values.
This class constructs new instances of
BtcFormat, allowing for the
configuration of those instances before they are constructed.Thrown by
SPVBlockStore when the process cannot gain exclusive access to the chain file.Vends hard-coded
StoredBlocks for blocks throughout the chain.Represents a Message type that can be contained within another Message.
This is just a wrapper for the i (child number) as per BIP 32 with a boolean getter for the most significant bit
and a getter for the actual 0-based child number.
A generic interface for an object which keeps track of a set of open client connections, creates new ones and
ensures they are serviced properly.
Represents a monetary Bitcoin value.
Represents the results of a
CoinSelector.select(Coin, List) operation.A CoinSelector is responsible for picking some outputs to spend, from the list of all possible outputs.
The Context object holds various objects and pieces of configuration that are scoped to a specific instantiation of
bitcoinj for a specific network.
A
ThreadFactory that propagates a Context from the creating
thread into the new thread.This signer may be used as a template for creating custom multisig transaction signers.
Thread factory whose threads are marked as daemon and won't prevent process exit.
A generic full pruned block store for a relational database.
A DecryptingKeyBag filters a pre-existing key bag, decrypting keys as they are requested using the provided
AES key.
This class implements a
CoinSelector which attempts to get the highest priority
possible.Default factory for creating keychains while de-serializing.
The default risk analysis.
The reason a transaction is considered non-standard, returned by
DefaultRiskAnalysis.isStandard(Transaction).A DeterministicHierarchy calculates and keeps a whole tree (hierarchy) of keys originating from a single
root key.
A deterministic key is a node in a
DeterministicHierarchy.A deterministic key chain is a
KeyChain that uses the
BIP 32 standard, as implemented by
DeterministicHierarchy, to derive all the keys in the keychain from a master seed.Holds the seed bytes for the BIP32 deterministic wallet algorithm, inside a
DeterministicKeyChain.Indicates that an attempt was made to use HD wallet features on a wallet that was deserialized from an old,
pre-HD random wallet without calling upgradeToDeterministic() beforehand.
Indicates that the pre-HD random wallet is encrypted, so you should try the upgrade again after getting the
users password.
Supports peer discovery through DNS.
Implements discovery from a single DNS host.
An implementation of
AbstractPeerDataEventListener that listens to chain download events and tracks progress
as a percentage.Parses and generates private keys in the form used by the Bitcoin "dumpprivkey" command.
Represents an elliptic curve public and (optionally) private key, usable for digital signatures but not encryption.
Groups the two components that make up a signature, and provides a way to encode to DER form, which is
how ECDSA signatures are represented when embedded in other data structures in the Bitcoin protocol.
Parent class for header only messages that don't have a payload.
Provides a uniform way to access something that can be optionally encrypted with a
KeyCrypter, yielding an EncryptedData, and
which can have a creation time associated with it.An encryptable key chain is a key-chain that can be encrypted with a user-provided password or AES key.
An instance of EncryptedData is a holder for an initialization vector and encrypted bytes.
Tracks successes and failures and calculates a time to retry the operation.
Parameters to configure a particular kind of exponential backoff.
Represents an "feefilter" message on the P2P network, which instructs a peer to filter transaction invs for
transactions that fall below the feerate provided.
Represents a monetary fiat value.
A FilteredBlock is used to relay a block with its transactions filtered using a
BloomFilter.A filtering coin selector delegates to another coin selector, but won't select outputs spent by the given transactions.
A reusable object that will calculate, given a list of
PeerFilterProviders, a merged
BloomFilter and earliest key time for all of them.A FullPrunedBlockChain works in conjunction with a
FullPrunedBlockStore to verify all the rules of the
Bitcoin system, with the downside being a large cost in system resources.An implementor of FullPrunedBlockStore saves StoredBlock objects to some storage mechanism.
Represents the "getaddr" P2P protocol message, which requests network
AddressMessages from a peer.Represents the "getblocks" P2P network message, which requests the hashes of the parts of the block chain we're
missing.
Represents the "getdata" P2P network message, which requests the contents of blocks or transactions given their
hashes.
The "getheaders" command is structurally identical to "getblocks", but has different meaning.
This command is supported only by Bitcoin XT nodes, which
advertise themselves using the second service bit flag.
A full pruned block store using the H2 pure-java embedded database.
Implementation of the BIP 32
deterministic wallet child key generation algorithm.
HD Key derivation path.
Static utilities used in BIP 32 Hierarchical Deterministic Wallets (HDW).
A protocol message that contains a repeated series of block headers, sent in response to the "getheaders" command.
A class that knows how to read signed sets of seeds over HTTP, using a simple protobuf based protocol.
Thrown to indicate that you don't have enough money available to perform the requested operation.
Represents the "inv" P2P network message.
A KeyBag is simply an object that can map public keys, their 160-bit hashes and script hashes to ECKey
and
RedeemData objects.A KeyChain is a class that stores a collection of keys for a
Wallet.Factory interface for creation keychains while de-serializing a wallet.
A KeyChainGroup is used by the
Wallet and manages: a BasicKeyChain object
(which will normally be empty), and zero or more DeterministicKeyChains.Builder for
KeyChainGroup.Defines a structure for hierarchical deterministic wallets.
A KeyCrypter can be used to encrypt and decrypt a message.
Exception to provide the following:
This exception is thrown when a private key or seed is decrypted, the decrypted message is damaged
(e.g.
This exception is thrown when a private key or seed is decrypted, it doesn't match its public key any
more.
This class encrypts and decrypts byte arrays and strings using scrypt as the
key derivation function and AES for the encryption.
A coin selector that takes all coins assigned to keys created before the given timestamp.
A wrapper around ECPoint that delays decoding of the point for as long as possible.
A Bitcoin address looks like 1MsScoe2fTJoq4ZPdQgqyhgWeoNamYPevy and is derived from an elliptic curve public key
plus a set of network parameters.
An SPV block store that writes every header it sees to a LevelDB.
An implementation of a Fully Pruned Block Store using a leveldb implementation as the backing data store.
A SecureRandom implementation that is able to override the standard JVM provided implementation, and which simply
serves random numbers by reading /dev/urandom.
A simple wrapper around a listener and an executor, with some utility methods.
Abstract superclass of classes with list based payload, ie InventoryMessage and GetDataMessage.
TransactionSigner implementation for signing inputs using keys from provided KeyBag.Parameters for the main production network on which people trade goods and services.
A multi-signature keychain using synchronized HD keys (a.k.a HDM)
Builds a
MarriedKeyChainKeeps
StoredBlocks in memory.The "mempool" message asks a remote peer to announce all transactions in its memory pool, possibly restricted by
any Bloom filter set on the connection.
A Message is a data structure that can be serialized/deserialized using the Bitcoin serialization format.
Generic interface for classes which serialize/deserialize messages.
A target to which messages can be written/connection can be closed
This transaction signer resolves missing signatures in accordance with the given
Wallet.MissingSigsMode.A MnemonicCode object may be used to convert between binary seed values and
lists of words per the BIP 39
specification
Exceptions thrown by the MnemonicCode module.
Thrown when a list of MnemonicCode words fails the checksum check.
Thrown when an argument to MnemonicCode is the wrong length.
Thrown when a word is encountered which is not in the MnemonicCode's word list.
Classes implementing this interface represent a monetary value, such as a Bitcoin or fiat amount.
Utility for formatting and parsing coin values to and from human readable form.
MultiplexingDiscovery queries multiple PeerDiscovery objects, optionally shuffles their responses and then returns the results,
thus selecting randomly between them and reducing the influence of any particular seed.
A full pruned block store using the MySQL database engine.
An event listener that relays events to a native C++ object.
An event listener that relays events to a native C++ object.
An event listener that relays events to a native C++ object.
An event listener that relays events to a native C++ object.
This class holds native methods to handle ECDSA verification.
Assertion utilities for
NativeSecp256k1Assertion failure exception
An event listener that relays events to a native C++ object.
An event listener that relays events to a native C++ object.
An event listener that relays events to a native C++ object.
An event listener that relays events to a native C++ object.
An event listener that relays events to a native C++ object.
An event listener that relays events to a native C++ object.
NetworkParameters contains the data needed for working with an instantiation of a Bitcoin chain.
Utility class that holds all the registered
NetworkParameters types used for address auto discovery.Listener interface for when a new block on the best chain is seen.
Creates a simple connection to a server using a
StreamConnection to process data.A class which manages a set of client connections.
Creates a simple server listener which listens for incoming client connections and uses a
StreamConnection to
process data.Sent by a peer when a getdata request doesn't find the requested data in the mempool.
Called when a new transaction is broadcast over the network.
Exception to provide the following to
BitcoinURI:A data structure that contains proofs of block inclusion for one or more transactions, in an efficient manner.
Utility methods and constants for working with
BIP 70 aka the payment protocol.
Message returned by the merchant in response to a Payment message.
Value object to hold amount/script pairs.
Information about the X.509 signature's issuer and subject.
Provides a standard implementation of the Payment Protocol (BIP 0070)
This is a clean-room implementation of PBKDF2 using RFC 2898 as a reference.
A Peer handles the high level communication with a Bitcoin node, extending a
PeerSocketHandler which
handles low-level message (de)serialization.A PeerAddress holds an IP address and port number representing the network location of
a peer in the Bitcoin P2P network.
Implementors can listen to events indicating a new peer connecting.
Implementors can listen to events indicating a peer disconnecting.
Implementors can listen to events for peers being discovered.
A PeerDiscovery object is responsible for finding addresses of other nodes in the Bitcoin P2P network.
Thrown when a problem occurs in communicating with a peer, and we should
retry.
An interface which provides the information required to properly filter data downloaded from Peers.
Runs a set of connections to the P2P network, brings up connections to replace disconnected nodes and manages
the interaction between them all.
Protobuf type
org.bitcoin.crawler.PeerSeedDataProtobuf type
org.bitcoin.crawler.PeerSeedDataProtobuf type
org.bitcoin.crawler.PeerSeedsProtobuf type
org.bitcoin.crawler.PeerSeedsProtobuf type
org.bitcoin.crawler.SignedPeerSeedsProtobuf type
org.bitcoin.crawler.SignedPeerSeedsHandles high-level message (de)serialization for peers, acting as the bridge between the
org.bitcoinj.net classes and Peer.Instances of this class are not safe for use by multiple threads.
Instances of this class are not safe for use by multiple threads.
A full pruned block store using the Postgres database engine.
The following format is often used to represent some type of data (e.g.
Data attached to a Key message that defines the data needed by the BIP32 deterministic key hierarchy algorithm.
Data attached to a Key message that defines the data needed by the BIP32 deterministic key hierarchy algorithm.
Protobuf type
wallet.EncryptedDataProtobuf type
wallet.EncryptedData
An exchange rate between Bitcoin and some fiat currency.
An exchange rate between Bitcoin and some fiat currency.
An extension to the wallet
An extension to the wallet
A key used to control Bitcoin spending.
A key used to control Bitcoin spending.
Protobuf enum
wallet.Key.OutputScriptTypeProtobuf enum
wallet.Key.Type
Generalized form of "send payment to this/these bitcoin addresses"
Generalized form of "send payment to this/these bitcoin addresses"
Protobuf type
payments.PaymentProtobuf type
payments.PaymentProtobuf type
payments.PaymentACKProtobuf type
payments.PaymentACKProtobuf type
payments.PaymentDetailsProtobuf type
payments.PaymentDetailsProtobuf type
payments.PaymentRequestProtobuf type
payments.PaymentRequestProtobuf type
wallet.PeerAddressProtobuf type
wallet.PeerAddressProtobuf type
wallet.ScriptProtobuf type
wallet.ScriptProtobuf type
wallet.ScriptWitnessProtobuf type
wallet.ScriptWitness
The parameters used in the scrypt key derivation function.
The parameters used in the scrypt key derivation function.
A simple key->value mapping that has no interpreted content at all.
A simple key->value mapping that has no interpreted content at all.
Protobuf type
wallet.TransactionProtobuf type
wallet.Transaction
This is a bitfield oriented enum, with the following bits:
bit 0 - spent
bit 1 - appears in alt chain
bit 2 - appears in best chain
bit 3 - double-spent
bit 4 - pending (we would like the tx to go into the best chain)
Not all combinations are interesting, just the ones actually used in the enum.
For what purpose the transaction was created.
A description of the confidence we have that a transaction cannot be reversed in the future.
A description of the confidence we have that a transaction cannot be reversed in the future.
Where did we get this transaction from? Knowing the source may help us to risk analyze pending transactions.
Protobuf enum
wallet.TransactionConfidence.TypeProtobuf type
wallet.TransactionInputProtobuf type
wallet.TransactionInputProtobuf type
wallet.TransactionOutputProtobuf type
wallet.TransactionOutput
A bitcoin wallet
A bitcoin wallet
The encryption type of the wallet.
Protobuf type
payments.X509CertificatesProtobuf type
payments.X509CertificatesPrunedException is thrown in cases where a fully verifying node has deleted (pruned) old block data that turned
out to be necessary for handling a re-org.
This class aggregates data required to spend transaction output.
Network parameters for the regression test mode of bitcoind in which all blocks are trivially solvable.
This exception is used by the TransactionBroadcast class to indicate that a broadcast
Transaction has been rejected by the network, for example because it violates a
protocol rule.
A message sent by nodes when a message we sent was rejected (ie a transaction had too little fee/was invalid/etc).
Listener interface for when the best chain has changed.
Exception to provide the following to
BitcoinURI:A RiskAnalysis represents an analysis of how likely it is that a transaction (and its dependencies) represents a
possible double spending attack.
Programs embedded inside transactions that control redemption of payments.
Enumeration to encapsulate the type of this script.
Tools for the construction of commonly used script types.
A script element that is either a data push (signature, pubkey, etc) or a non-push (logic, numeric, etc) operation.
Various constants that define the assembly-like scripting language that forms part of the Bitcoin protocol.
This is a Script pattern matcher with some typical script patterns
Implementors are called when the contents of the wallet changes, for instance due to receiving/sending money
or a block chain re-organize.
This class holds the context reference used in native methods to handle ECDSA operations.
SeedPeers stores a pre-determined list of Bitcoin node addresses.
Implementation of native segwit addresses.
Represents the
sendaddrv2 P2P protocol message, which indicates that a node can understand and prefers
to receive addrv2 messages instead of addr messages.
A new message, "sendheaders", which indicates that a node prefers to receive new block announcements via a "headers"
message rather than an "inv".
A SendRequest gives the wallet information about precisely how to send money to a recipient or set of recipients.
A
Sha256Hash wraps a byte[] so that Sha256Hash.equals(java.lang.Object) and Sha256Hash.hashCode() work correctly, allowing it to be used as a key in a
map.An SPVBlockStore holds a limited number of block headers in a memory mapped ring buffer.
Wraps a
Block object with extra data that can be derived from the block chain but is slow or inconvenient to
calculate.Contains minimal data necessary to disconnect/connect the transactions
in the stored block at will.
A generic handler which is used in
NioServer, NioClient and BlockingClient to handle incoming
data streams.A factory which generates new
StreamConnections when a new connection is opened.An object that can carry around and possibly serialize a map of strings to immutable byte arrays.
Parameters for the testnet, a separate public instance of Bitcoin that has relaxed rules suitable for development
and testing of applications and new Bitcoin versions.
Various threading related utilities.
A transaction represents the movement of coins from some addresses to some other addresses.
This enum describes the underlying reason the transaction was created.
These constants are a part of a scriptSig signature on the inputs.
This interface is used to abstract the
Wallet and the TransactionRepresents a single transaction broadcast that we are performing.
An interface for receiving progress information on the propagation of the tx, from 0.0 to 1.0
A general interface which declares the ability to broadcast transactions.
A TransactionConfidence object tracks data you can use to make a confidence decision about a transaction.
Describes the state of the transaction in general terms.
A confidence listener is informed when the level of
TransactionConfidence is updated by something, like
for example a Wallet.An enum that describes why a transaction confidence listener is being invoked (i.e.
Information about where the transaction was first seen (network, sent direct from peer, created by ourselves).
Implementors are called when confidence of a transaction changes.
A transfer of coins from one address to another creates a transaction in which the outputs
can be claimed by the recipient in the input of another transaction.
This message is a reference or pointer to an output of a different transaction.
A TransactionOutput message contains a scriptPubKey that controls who is able to spend its value.
TransactionOutputChanges represents a delta to the set of unspent outputs.
Listener interface for when we receive a new block that contains a relevant
transaction.
A TransactionSignature wraps an
ECKey.ECDSASignature and adds methods for handling
the additional SIGHASH mode byte that is used.Implementations of this interface are intended to sign inputs of the given transaction.
This class wraps transaction proposed to complete keeping a metadata that may be updated, used and effectively
shared by transaction signers.
An implementation of TrustStoreLoader handles fetching a KeyStore from the operating system, a file, etc.
Tracks transactions that are being announced across the network.
Network parameters used by the bitcoinj unit tests (and potentially your own).
Instances of this class are not safe for use by multiple threads.
Thrown by the
WalletProtobufSerializer when the serialized protocol buffer is either corrupted,
internally inconsistent or appears to be from the future.An unsynchronized implementation of ByteArrayOutputStream that will return the backing byte array if its length == size().
A collection of various utility methods that are helpful for working with the Bitcoin protocol.
A UTXO message contains the information necessary to check a spending transaction.
A UTXOProvider encapsulates functionality for returning unspent transaction outputs,
for use by the wallet or other code that crafts spends.
Message representing a list of unspent transaction outputs ("utxos"), returned in response to sending a
GetUTXOsMessage ("getutxos").A variable-length encoded unsigned integer using Satoshi's encoding (a.k.a.
The verack message, sent by a client accepting the version message they
received from their peer.
A VersionMessage holds information exchanged during connection setup with another peer.
Caching counter for the block versions within a moving window.
A Wallet stores keys and a record of transactions that send and receive value from those keys.
Thrown if the private keys and seed of this wallet cannot be decrypted due to the supplied encryption
key or password being wrong.
It's possible to calculate a wallets balance from multiple points of view.
Class of exceptions thrown in
Wallet.completeTx(SendRequest).Thrown when we were trying to empty the wallet, and the total amount of money we were trying to empty after
being reduced for the fee was smaller than the min payment.
Thrown if the resultant transaction would violate the dust rules (an output that's too small to be worthwhile).
Thrown if the resultant transaction is too big for Bitcoin to process.
Enumerates possible resolutions for missing signatures.
Thrown if there is more than one OP_RETURN output for the resultant transaction.
A SendResult is returned to you as part of sending coins to a recipient.
Utility class that wraps the boilerplate needed to set up a new SPV bitcoinj app.
Implementors are called when the contents of the wallet changes, for instance due to receiving/sending money
or a block chain re-organize.
Implementors are called when the contents of the wallet changes, for instance due to receiving/sending money
or a block chain re-organize.
Implementors are called when the contents of the wallet changes, for instance due to receiving/sending money
or a block chain re-organize.
An object implementing this interface can be added to a
Wallet and provide arbitrary byte arrays that will
be serialized alongside the wallet.A class that handles atomic and optionally delayed writing of the wallet file to disk.
Implementors can do pre/post treatment of the wallet file.
Serialize and de-serialize a wallet to a byte stream containing a
protocol buffer.
Implementors are called when the wallet is reorganized.
Stores data about a transaction that is only relevant to the
Wallet class.X509Utils provides tools for working with X.509 certificates and keystores, as used in the BIP 70 payment protocol.