All Classes Interface Summary Class Summary Enum Summary Exception Summary
| Class |
Description |
| AbstractBlockChain |
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. |
| AbstractBlockChain.NewBlockType |
Indicates whether new Block was on the best chain or not
|
| AbstractKeyChainEventListener |
|
| AbstractTimeoutHandler |
Deprecated.
|
| Address |
Interface for addresses, e.g.
|
| AddressEventListener |
Implementors can listen to addresses being received from remote peers.
|
| AddressFormatException |
|
| AddressFormatException.InvalidCharacter |
This exception is thrown by Base58, Bech32 and the EncodedPrivateKey hierarchy of
classes when you try to decode data and a character isn't valid. |
| AddressFormatException.InvalidChecksum |
This exception is thrown by Base58, Bech32 and the EncodedPrivateKey hierarchy of
classes when you try to decode data and the checksum isn't valid. |
| AddressFormatException.InvalidDataLength |
This exception is thrown by Base58, Bech32 and the EncodedPrivateKey hierarchy of
classes when you try to decode data and the data isn't of the right size. |
| AddressFormatException.InvalidPrefix |
This exception is thrown by the EncodedPrivateKey hierarchy of classes when you try and decode an
address or private key with an invalid prefix (version header or human-readable part).
|
| AddressFormatException.UnexpectedWitnessVersion |
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.
|
| AddressFormatException.WrongNetwork |
This exception is thrown by the EncodedPrivateKey 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).
|
| AddressMessage |
Abstract superclass for address messages on the P2P network, which contain network addresses of other peers.
|
| AddressParser |
Functional interface for parsing an Address. |
| AddressParser.AddressParserProvider |
Interface implemented by custom address parser providers.
|
| AddressV1Message |
Represents an "addr" message on the P2P network, which contains broadcast IP addresses of other peers.
|
| AddressV2Message |
Represents an "addrv2" message on the P2P network, which contains broadcast addresses of other peers.
|
| AesKey |
Wrapper for a byte[] containing an AES Key.
|
| AllowUnconfirmedCoinSelector |
This coin selector will select any transaction at all, regardless of where it came from or whether it was
confirmed yet.
|
| AllRandomKeysRotating |
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.
|
| AppDataDirectory |
Find/create App Data Directory in correct platform-specific location.
|
| Base58 |
Base58 is a way to encode Bitcoin addresses (or arbitrary data) as alphanumeric strings.
|
| BaseMessage |
A Message is a data structure that can be serialized/deserialized using the Bitcoin serialization format.
|
| BaseTaggableObject |
Deprecated.
|
| BasicKeyChain |
A KeyChain that implements the simplest model possible: it can have keys imported into it, and just acts as
a dumb bag of keys. |
| BasicKeyChain.State |
Whether this basic key chain is empty, full of regular (usable for signing) keys, or full of watching keys.
|
| Bech32 |
Implementation of the Bech32 encoding.
|
| Bech32.Bech32Bytes |
Binary data in 5-bits-per-byte format as used in Bech32 encoding/decoding.
|
| Bech32.Bech32Data |
Bech32 data in 5-bit byte format with Bech32.Encoding and human-readable part (HRP) information. |
| Bech32.Encoding |
Enumeration of known Bech32 encoding format types: Bech32 and Bech32m.
|
| BIP38PrivateKey |
Implementation of BIP 38
passphrase-protected private keys. |
| BIP38PrivateKey.BadPassphraseException |
|
| BitcoinNetwork |
A convenient enum representation of a Bitcoin network.
|
| BitcoinNetworkParams |
Parameters for Bitcoin-like networks.
|
| BitcoinSerializer |
|
| BitcoinSerializer.BitcoinPacketHeader |
|
| BitcoinURI |
Provides a standard implementation of a Bitcoin URI with support for the following:
|
| BitcoinURIParseException |
|
| Block |
A block is a group of transactions, and is one of the fundamental data structures of the Bitcoin system.
|
| Block.VerifyFlag |
Flags used to control which elements of block validation are done on
received blocks.
|
| BlockChain |
A BlockChain implements the simplified payment verification mode of the Bitcoin protocol.
|
| BlockchainDownloadEventListener |
Event Listener for blockchain download.
|
| BlockFileLoader |
This class reads block files stored in the Bitcoin Core format.
|
| BlockingClient |
Creates a simple connection to a server using a StreamConnection to process data. |
| BlockingClientManager |
|
| BlockLocator |
Represents Block Locator in GetBlocks and GetHeaders messages
|
| BlocksDownloadedEventListener |
Implementors can listen to events like blocks being downloaded/transactions being broadcast/connect/disconnects,
they can pre-filter messages before they are processed by a Peer or PeerGroup, and they can
provide transactions to remote peers when they ask for them. |
| BlockStore |
An implementor of BlockStore saves StoredBlock objects to disk.
|
| BlockStoreException |
Thrown when something goes wrong with storing a block.
|
| BloomFilter |
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.
|
| BloomFilter.BloomUpdate |
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)
|
| BriefLogFormatter |
A Java logging formatter that writes more compact output than the default.
|
| BtcAutoFormat |
This class, a concrete extension of BtcFormat, is distinguished by its
accommodation of multiple denominational units as follows: |
| BtcAutoFormat.Style |
Enum for specifying the style of currency indicators that are used
when formatting, either codes or symbols.
|
| BtcFixedFormat |
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. |
| BtcFormat |
Instances of this class format and parse locale-specific numerical
representations of Bitcoin monetary values.
|
| BtcFormat.Builder |
This class constructs new instances of BtcFormat, allowing for the
configuration of those instances before they are constructed. |
| Buffers |
Utility methods for common operations on Bitcoin P2P message buffers.
|
| ByteArray |
An effectively-immutable byte array.
|
| ByteUtils |
Utility methods for bit, byte, and integer manipulation and conversion.
|
| ChainDownloadStartedEventListener |
Implementors can listen to events like blocks being downloaded/transactions being broadcast/connect/disconnects,
they can pre-filter messages before they are processed by a Peer or PeerGroup, and they can
provide transactions to remote peers when they ask for them. |
| ChainFileLockedException |
Thrown by SPVBlockStore when the process cannot gain exclusive access to the chain file. |
| CheckpointManager |
Vends hard-coded StoredBlocks for blocks throughout the chain. |
| ChildNumber |
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.
|
| ClientConnectionManager |
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.
|
| Coin |
Represents a monetary Bitcoin value.
|
| CoinSelection |
|
| CoinSelector |
A CoinSelector is responsible for picking some outputs to spend, from the list of all possible outputs.
|
| Context |
The Context object holds various objects and pieces of configuration that are scoped to a specific instantiation of
bitcoinj for a specific network.
|
| ContextPropagatingThreadFactory |
A ThreadFactory that propagates a Context from the creating
thread into the new thread. |
| CryptoUtils |
Utilities for the crypto module (e.g.
|
| CurrentKeyChangeEventListener |
|
| CustomTransactionSigner |
This signer may be used as a template for creating custom multisig transaction signers.
|
| CustomTransactionSigner.SignatureAndKey |
|
| DaemonThreadFactory |
Thread factory whose threads are marked as daemon and won't prevent process exit.
|
| DecryptingKeyBag |
A DecryptingKeyBag filters a pre-existing key bag, decrypting keys as they are requested using the provided
AES key.
|
| DefaultCoinSelector |
This class implements a CoinSelector which attempts to get the highest priority
possible. |
| DefaultKeyChainFactory |
Default factory for creating keychains while de-serializing.
|
| DefaultRiskAnalysis |
The default risk analysis.
|
| DefaultRiskAnalysis.Analyzer |
|
| DefaultRiskAnalysis.RuleViolation |
|
| DeterministicHierarchy |
A DeterministicHierarchy calculates and keeps a whole tree (hierarchy) of keys originating from a single
root key.
|
| DeterministicKey |
|
| DeterministicKeyChain |
|
| DeterministicKeyChain.Builder<T extends DeterministicKeyChain.Builder<T>> |
|
| DeterministicSeed |
|
| DeterministicUpgradeRequiredException |
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.
|
| DeterministicUpgradeRequiresPassword |
Indicates that the pre-HD random wallet is encrypted, so you should try the upgrade again after getting the
users password.
|
| DnsDiscovery |
Supports peer discovery through DNS.
|
| DnsDiscovery.DnsSeedDiscovery |
Implements discovery from a single DNS host.
|
| DownloadProgressTracker |
|
| DumpedPrivateKey |
Parses and generates private keys in the form used by the Bitcoin "dumpprivkey" command.
|
| ECKey |
Represents an elliptic curve public and (optionally) private key, usable for digital signatures but not encryption.
|
| ECKey.ECDSASignature |
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.
|
| ECKey.KeyIsEncryptedException |
|
| ECKey.MissingPrivateKeyException |
|
| EmptyMessage |
Parent class for header only messages that don't have a payload.
|
| EncodedPrivateKey |
Some form of string-encoded private key.
|
| EncryptableItem |
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. |
| EncryptableKeyChain |
An encryptable key chain is a key-chain that can be encrypted with a user-provided password or AES key.
|
| EncryptedData |
An instance of EncryptedData is a holder for an initialization vector and encrypted bytes.
|
| ExchangeRate |
An exchange rate is expressed as a ratio of a Coin and a Fiat amount. |
| ExponentialBackoff |
Tracks successes and failures and calculates a time to retry the operation.
|
| ExponentialBackoff.Params |
Parameters to configure a particular kind of exponential backoff.
|
| FakeTxBuilder |
Methods for building fake transactions for unit tests.
|
| FakeTxBuilder.BlockPair |
|
| FakeTxBuilder.DoubleSpends |
|
| FeeFilterMessage |
Represents a "feefilter" message on the P2P network, which instructs a peer to filter transaction invs for
transactions that fall below the feerate provided.
|
| Fiat |
Represents a monetary fiat value.
|
| FilteredBlock |
A FilteredBlock is used to relay a block with its transactions filtered using a BloomFilter. |
| FilteringCoinSelector |
A filtering coin selector delegates to another coin selector, but won't select outputs spent by the given transactions.
|
| FilterMerger |
|
| FilterMerger.Result |
|
| FullPrunedBlockChain |
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. |
| FullPrunedBlockStore |
An implementor of FullPrunedBlockStore saves StoredBlock objects to some storage mechanism.
|
| FutureUtils |
Utilities for CompletableFuture.
|
| FutureUtils.ThrowingSupplier<T> |
Subinterface of Supplier for Lambdas which throw exceptions.
|
| GetAddrMessage |
Represents the "getaddr" P2P protocol message, which requests network AddressMessages from a peer. |
| GetBlocksMessage |
Represents the "getblocks" P2P network message, which requests the hashes of the parts of the block chain we're
missing.
|
| GetDataEventListener |
Implementors can listen to events like blocks being downloaded/transactions being broadcast/connect/disconnects,
they can pre-filter messages before they are processed by a Peer or PeerGroup, and they can
provide transactions to remote peers when they ask for them. |
| GetDataMessage |
Represents the "getdata" P2P network message, which requests the contents of blocks or transactions given their
hashes.
|
| GetHeadersMessage |
The "getheaders" command is structurally identical to "getblocks", but has different meaning.
|
| HDDerivationException |
|
| HDKeyDerivation |
Implementation of the BIP 32
deterministic wallet child key generation algorithm. |
| HDKeyDerivation.PublicDeriveMode |
|
| HDKeyDerivation.RawKeyBytes |
|
| HDPath |
HD Key derivation path.
|
| HDUtils |
Static utilities used in BIP 32 Hierarchical Deterministic Wallets (HDW).
|
| HeadersMessage |
A protocol message that contains a repeated series of block headers, sent in response to the "getheaders" command.
|
| HexFormat |
This class implements a subset of the functionality of the HexFormat class available in Java 17 and later.
|
| InsufficientMoneyException |
Thrown to indicate that you don't have enough money available to perform the requested operation.
|
| InternalUtils |
Utilities for internal use only.
|
| InternalUtils.Joiner |
A functional interface for joining Strings or Objects via Object.toString() using
a pre-configured delimiter.
|
| InternalUtils.Splitter |
A functional interface for splitting Strings using a pre-configured regular expression.
|
| InventoryItem |
|
| InventoryItem.Type |
|
| InventoryMessage |
Represents the "inv" P2P network message.
|
| KeyBag |
A KeyBag is simply an object that can map public keys, their 160-bit hashes and script hashes to ECKey
and RedeemData objects. |
| KeyChain |
A KeyChain is a class that stores a collection of keys for a Wallet. |
| KeyChain.KeyPurpose |
|
| KeyChainEventListener |
|
| KeyChainFactory |
Factory interface for creation keychains while de-serializing a wallet.
|
| KeyChainGroup |
|
| KeyChainGroup.Builder |
|
| KeyChainGroupStructure |
Defines a structure for hierarchical deterministic wallets.
|
| KeyCrypter |
A KeyCrypter can be used to encrypt and decrypt a message.
|
| KeyCrypterException |
Exception to provide the following:
|
| KeyCrypterException.InvalidCipherText |
This exception is thrown when a private key or seed is decrypted, the decrypted message is damaged
(e.g.
|
| KeyCrypterException.PublicPrivateMismatch |
This exception is thrown when a private key or seed is decrypted, it doesn't match its public key any
more.
|
| KeyCrypterScrypt |
This class encrypts and decrypts byte arrays and strings using scrypt as the
key derivation function and AES for the encryption.
|
| KeyTimeCoinSelector |
A coin selector that takes all coins assigned to keys created before the given timestamp.
|
| LazyECPoint |
A wrapper around a SECP256K1 ECPoint that delays decoding of the point for as long as possible.
|
| LegacyAddress |
A Bitcoin address looks like 1MsScoe2fTJoq4ZPdQgqyhgWeoNamYPevy and is derived from an elliptic curve public key
plus a set of network parameters.
|
| LegacyAddress.AddressHeader |
Address header of legacy P2PKH addresses for standard Bitcoin networks.
|
| LegacyAddress.P2SHHeader |
Address header of legacy P2SH addresses for standard Bitcoin networks.
|
| LinuxSecureRandom |
A SecureRandom implementation that is able to override the standard JVM provided implementation, and which simply
serves random numbers by reading /dev/urandom.
|
| ListenableCompletableFuture<V> |
A CompletableFuture that is also a ListenableFuture for migration
from Guava ListenableFuture to CompletableFuture.
|
| ListenableCompletionStage<V> |
A CompletionStage with a ListenableFuture-compatible interface to smooth migration
from Guava ListenableFuture to CompletableFuture/CompletionStage.
|
| ListenerRegistration<T> |
A simple wrapper around a listener and an executor, with some utility methods.
|
| ListMessage |
Abstract superclass of classes with list based payload, ie InventoryMessage and GetDataMessage.
|
| LocalTransactionSigner |
|
| LockTime |
|
| LockTime.HeightLock |
A LockTime instance that contains a block height.
|
| LockTime.TimeLock |
A LockTime instance that contains a timestamp.
|
| MainNetParams |
Parameters for the main production network on which people trade goods and services.
|
| MemoryBlockStore |
|
| MemoryFullPrunedBlockStore |
|
| MemoryFullPrunedBlockStore.StoredBlockAndWasUndoableFlag |
|
| MemoryPoolMessage |
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.
|
| Message |
A Message is a data structure that can be serialized/deserialized using the Bitcoin serialization format.
|
| MessageSerializer |
Generic interface for classes which serialize/deserialize messages.
|
| MessageVerifyUtils |
Small utility class for verifying signatures of text messages created with
Bitcoin addresses (more precisely: with the private key of Bitcoin addresses).
|
| MessageWriteTarget |
A target to which messages can be written/connection can be closed
|
| MissingSigResolutionSigner |
|
| MnemonicCode |
|
| MnemonicException |
Exceptions thrown by the MnemonicCode module.
|
| MnemonicException.MnemonicChecksumException |
Thrown when a list of MnemonicCode words fails the checksum check.
|
| MnemonicException.MnemonicLengthException |
Thrown when an argument to MnemonicCode is the wrong length.
|
| MnemonicException.MnemonicWordException |
Thrown when a word is encountered which is not in the MnemonicCode's word list.
|
| MockAltNetwork |
Mock Alt-net implementation of Network for unit tests. |
| MockAltNetworkParams |
|
| Monetary |
Classes implementing this interface represent a monetary value, such as a Bitcoin or fiat amount.
|
| MonetaryFormat |
Utility for formatting and parsing coin values to and from human-readable form.
|
| MultiplexingDiscovery |
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.
|
| NativeBlockChainListener |
Deprecated.
|
| NativeFutureCallback |
Deprecated.
|
| NativeKeyChainEventListener |
Deprecated.
|
| NativeScriptsChangeEventListener |
Deprecated.
|
| NativeTransactionConfidenceEventListener |
Deprecated.
|
| NativeTransactionConfidenceListener |
Deprecated.
|
| NativeWalletChangeEventListener |
Deprecated.
|
| NativeWalletCoinsReceivedEventListener |
Deprecated.
|
| NativeWalletCoinsSentEventListener |
Deprecated.
|
| NativeWalletReorganizeEventListener |
Deprecated.
|
| Network |
Interface for a generic Bitcoin-like cryptocurrency network.
|
| NetworkParameters |
NetworkParameters contains the data needed for working with an instantiation of a Bitcoin chain.
|
| Networks |
Utility class that holds all the registered NetworkParameters types used for address auto discovery. |
| NewBestBlockListener |
Listener interface for when a new block on the best chain is seen.
|
| NioClient |
Creates a simple connection to a server using a StreamConnection to process data. |
| NioClientManager |
A class which manages a set of client connections.
|
| NioServer |
Creates a simple server listener which listens for incoming client connections and uses a StreamConnection to
process data. |
| NotFoundMessage |
Sent by a peer when a getdata request doesn't find the requested data in the mempool.
|
| OnTransactionBroadcastListener |
Called when a new transaction is broadcast over the network.
|
| OptionalFieldValidationException |
|
| PartialMerkleTree |
A data structure that contains proofs of block inclusion for one or more transactions, in an efficient manner.
|
| PaymentProtocol |
|
| PaymentProtocol.Ack |
Message returned by the merchant in response to a Payment message.
|
| PaymentProtocol.Output |
Value object to hold amount/script pairs.
|
| PaymentProtocol.PkiVerificationData |
Information about the X.509 signature's issuer and subject.
|
| PaymentProtocolException |
|
| PaymentProtocolException.Expired |
|
| PaymentProtocolException.InvalidNetwork |
|
| PaymentProtocolException.InvalidOutputs |
|
| PaymentProtocolException.InvalidPaymentRequestURL |
|
| PaymentProtocolException.InvalidPaymentURL |
|
| PaymentProtocolException.InvalidPkiData |
|
| PaymentProtocolException.InvalidPkiType |
|
| PaymentProtocolException.InvalidVersion |
|
| PaymentProtocolException.PkiVerificationException |
|
| PaymentSession |
Provides a standard implementation of the Payment Protocol (BIP 0070)
|
| PBKDF2SHA512 |
This is a clean-room implementation of PBKDF2 using RFC 2898 as a reference.
|
| Peer |
A Peer handles the high level communication with a Bitcoin node, extending a PeerSocketHandler which
handles low-level message (de)serialization. |
| PeerAddress |
A PeerAddress holds an IP address and port number representing the network location of
a peer in the Bitcoin P2P network.
|
| PeerConnectedEventListener |
Implementors can listen to events indicating a new peer connecting.
|
| PeerDataEventListener |
Deprecated.
|
| PeerDisconnectedEventListener |
Implementors can listen to events indicating a peer disconnecting.
|
| PeerDiscoveredEventListener |
Implementors can listen to events for peers being discovered.
|
| PeerDiscovery |
A PeerDiscovery object is responsible for finding addresses of other nodes in the Bitcoin P2P network.
|
| PeerDiscoveryException |
|
| PeerException |
Thrown when a problem occurs in communicating with a peer, and we should
retry.
|
| PeerFilterProvider |
An interface which provides the information required to properly filter data downloaded from Peers.
|
| PeerGroup |
Runs a set of connections to the P2P network, brings up connections to replace disconnected nodes and manages
the interaction between them all.
|
| PeerGroup.FilterRecalculateMode |
|
| PeerSocketHandler |
Handles high-level message (de)serialization for peers, acting as the bridge between the
org.bitcoinj.net classes and Peer. |
| Ping |
|
| PlatformUtils |
Utilities for determining platform information (OS and runtime)
|
| PlatformUtils.OS |
|
| PlatformUtils.Runtime |
|
| Pong |
|
| Preconditions |
|
| PreMessageReceivedEventListener |
Implementors can listen to events like blocks being downloaded/transactions being broadcast/connect/disconnects,
they can pre-filter messages before they are processed by a Peer or PeerGroup, and they can
provide transactions to remote peers when they ask for them. |
| ProtocolException |
|
| ProtocolVersion |
Define important versions of the Bitcoin Protocol
|
| PrunedException |
PrunedException 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.
|
| RedeemData |
This class aggregates data required to spend transaction output.
|
| RegTestParams |
Network parameters for the regression test mode of bitcoind in which all blocks are trivially solvable.
|
| RejectedTransactionException |
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.
|
| RejectMessage |
A message sent by nodes when a message we sent was rejected (ie a transaction had too little fee/was invalid/etc).
|
| RejectMessage.RejectCode |
|
| ReorganizeListener |
Listener interface for when the best chain has changed.
|
| RequiredFieldValidationException |
|
| RiskAnalysis |
A RiskAnalysis represents an analysis of how likely it is that a transaction (and its dependencies) represents a
possible double spending attack.
|
| RiskAnalysis.Analyzer |
|
| RiskAnalysis.Result |
|
| Script |
Programs embedded inside transactions that control redemption of payments.
|
| Script.VerifyFlag |
|
| ScriptBuilder |
Tools for the construction of commonly used script types.
|
| ScriptChunk |
A script element that is either a data push (signature, pubkey, etc) or a non-push (logic, numeric, etc) operation.
|
| ScriptError |
|
| ScriptException |
|
| ScriptOpCodes |
Various constants that define the assembly-like scripting language that forms part of the Bitcoin protocol.
|
| ScriptPattern |
This is a Script pattern matcher with some typical script patterns
|
| ScriptsChangeEventListener |
Implementors are called when the contents of the wallet changes, for instance due to receiving/sending money
or a block chain re-organize.
|
| ScriptType |
Supported Bitcoin script types and their script identifier strings.
|
| SeedPeers |
SeedPeers stores a pre-determined list of Bitcoin node addresses.
|
| SegwitAddress |
Implementation of native segwit addresses.
|
| SegwitAddress.SegwitHrp |
Human-readable part (HRP) of Segwit addresses for standard Bitcoin networks.
|
| SendAddrV2Message |
Represents the sendaddrv2 P2P protocol message, which indicates that a node can understand and prefers
to receive addrv2 messages instead of addr messages.
|
| SendHeadersMessage |
A new message, "sendheaders", which indicates that a node prefers to receive new block announcements via a "headers"
message rather than an "inv".
|
| SendRequest |
A SendRequest gives the wallet information about precisely how to send money to a recipient or set of recipients.
|
| Services |
Wrapper for services bitfield used in various messages of the Bitcoin protocol.
|
| Sha256Hash |
|
| SignatureDecodeException |
|
| SigNetParams |
Parameters for the signet, a separate public instance of Bitcoin that has relaxed rules suitable for development
and testing of applications and new Bitcoin versions.
|
| SocketTimeoutTask |
|
| SPVBlockStore |
An SPVBlockStore holds a limited number of block headers in a memory mapped ring buffer.
|
| Stopwatch |
A tool for measuring time, mainly for log messages.
|
| StoredBlock |
Wraps a Block object with extra data that can be derived from the block chain but is slow or inconvenient to
calculate. |
| StoredUndoableBlock |
Contains minimal data necessary to disconnect/connect the transactions
in the stored block at will.
|
| StreamConnection |
|
| StreamConnectionFactory |
A factory which generates new StreamConnections when a new connection is opened. |
| StreamUtils |
Stream Utilities.
|
| TaggableObject |
Deprecated.
|
| TestNet3Params |
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.
|
| Threading |
Various threading related utilities.
|
| Threading.UserThread |
|
| TimeoutHandler |
Provides basic support for socket timeouts.
|
| TimeUtils |
Utilities for time and mock time.
|
| TorUtils |
Utilities for encoding and decoding Onion addresses.
|
| Transaction |
A transaction represents the movement of coins from some addresses to some other addresses.
|
| Transaction.Purpose |
This enum describes the underlying reason the transaction was created.
|
| Transaction.SigHash |
These constants are a part of a scriptSig signature on the inputs.
|
| TransactionBag |
|
| TransactionBroadcast |
Represents a single transaction broadcast that we are performing.
|
| TransactionBroadcast.ProgressCallback |
An interface for receiving progress information on the propagation of the tx, from 0.0 to 1.0
|
| TransactionBroadcaster |
A general interface which declares the ability to broadcast transactions.
|
| TransactionConfidence |
A TransactionConfidence object tracks data you can use to make a confidence decision about a transaction.
|
| TransactionConfidence.ConfidenceType |
Describes the state of the transaction in general terms.
|
| TransactionConfidence.Listener |
|
| TransactionConfidence.Listener.ChangeReason |
An enum that describes why a transaction confidence listener is being invoked (i.e.
|
| TransactionConfidence.Source |
Information about where the transaction was first seen (network, sent direct from peer, created by ourselves).
|
| TransactionConfidenceEventListener |
Implementors are called when confidence of a transaction changes.
|
| TransactionInput |
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.
|
| TransactionInput.ConnectionResult |
|
| TransactionInput.ConnectMode |
|
| TransactionOutPoint |
This message is a reference or pointer to an output of a different transaction.
|
| TransactionOutput |
A TransactionOutput message contains a scriptPubKey that controls who is able to spend its value.
|
| TransactionOutputChanges |
TransactionOutputChanges represents a delta to the set of unspent outputs.
|
| TransactionReceivedInBlockListener |
Listener interface for when we receive a new block that contains a relevant
transaction.
|
| TransactionSignature |
A TransactionSignature wraps an ECKey.ECDSASignature and adds methods for handling
the additional SIGHASH mode byte that is used. |
| TransactionSigner |
Implementations of this interface are intended to sign inputs of the given transaction.
|
| TransactionSigner.MissingSignatureException |
|
| TransactionSigner.ProposedTransaction |
This class wraps transaction proposed to complete keeping a metadata that may be updated, used and effectively
shared by transaction signers.
|
| TransactionWitness |
|
| TrustStoreLoader |
An implementation of TrustStoreLoader handles fetching a KeyStore from the operating system, a file, etc.
|
| TrustStoreLoader.DefaultTrustStoreLoader |
|
| TrustStoreLoader.FileTrustStoreLoader |
|
| TxConfidenceTable |
Tracks transactions that are being announced across the network.
|
| UnitTestParams |
Network parameters used by the bitcoinj unit tests (and potentially your own).
|
| UnknownMessage |
Instances of this class are not safe for use by multiple threads.
|
| UnreadableWalletException |
Thrown by the WalletProtobufSerializer when the serialized protocol buffer is either corrupted,
internally inconsistent or appears to be from the future. |
| UnreadableWalletException.BadPassword |
|
| UnreadableWalletException.FutureVersion |
|
| UnreadableWalletException.WrongNetwork |
|
| Utils |
A collection of various utility methods that are helpful for working with the Bitcoin protocol.
|
| UTXO |
A UTXO message contains the information necessary to check a spending transaction.
|
| UTXOProvider |
A UTXOProvider encapsulates functionality for returning unspent transaction outputs,
for use by the wallet or other code that crafts spends.
|
| UTXOProviderException |
|
| VarInt |
A variable-length encoded unsigned integer using Satoshi's encoding (a.k.a.
|
| VerificationException |
|
| VerificationException.BlockVersionOutOfDate |
|
| VerificationException.CoinbaseHeightMismatch |
|
| VerificationException.CoinbaseScriptSizeOutOfRange |
|
| VerificationException.DuplicatedOutPoint |
|
| VerificationException.EmptyInputsOrOutputs |
|
| VerificationException.ExcessiveValue |
|
| VerificationException.LargerThanMaxBlockSize |
|
| VerificationException.NegativeValueOutput |
|
| VerificationException.NoncanonicalSignature |
|
| VerificationException.UnexpectedCoinbaseInput |
|
| VersionAck |
The verack message, sent by a client accepting the version message they
received from their peer.
|
| VersionMessage |
A VersionMessage holds information exchanged during connection setup with another peer.
|
| VersionTally |
Caching counter for the block versions within a moving window.
|
| Wallet |
A Wallet stores keys and a record of transactions that send and receive value from those keys.
|
| Wallet.BadWalletEncryptionKeyException |
Thrown if the private keys and seed of this wallet cannot be decrypted due to the supplied encryption
key or password being wrong.
|
| Wallet.BalanceType |
It's possible to calculate a wallets balance from multiple points of view.
|
| Wallet.CompletionException |
|
| Wallet.CouldNotAdjustDownwards |
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.
|
| Wallet.DustySendRequested |
Thrown if the resultant transaction would violate the dust rules (an output that's too small to be worthwhile).
|
| Wallet.ExceededMaxTransactionSize |
Thrown if the resultant transaction is too big for Bitcoin to process.
|
| Wallet.MissingSigsMode |
Enumerates possible resolutions for missing signatures.
|
| Wallet.MultipleOpReturnRequested |
Thrown if there is more than one OP_RETURN output for the resultant transaction.
|
| Wallet.SendResult |
A SendResult is returned to you as part of sending coins to a recipient.
|
| WalletAppKit |
Utility class that wraps the boilerplate needed to set up a new SPV bitcoinj app.
|
| WalletChangeEventListener |
Implementors are called when the contents of the wallet changes, for instance due to receiving/sending money
or a block chain re-organize.
|
| WalletCoinsReceivedEventListener |
Implementors are called when the contents of the wallet changes, for instance due to receiving/sending money
or a block chain re-organize.
|
| WalletCoinsSentEventListener |
Implementors are called when the contents of the wallet changes, for instance due to receiving/sending money
or a block chain re-organize.
|
| WalletExtension |
An object implementing this interface can be added to a Wallet and provide arbitrary byte arrays that will
be serialized alongside the wallet. |
| WalletFiles |
A class that handles atomic and optionally delayed writing of the wallet file to disk.
|
| WalletFiles.Listener |
Implementors can do pre/post treatment of the wallet file.
|
| WalletProtobufSerializer |
Serialize and de-serialize a wallet to a byte stream containing a
protocol buffer. |
| WalletProtobufSerializer.WalletFactory |
|
| WalletReorganizeEventListener |
Implementors are called when the wallet is reorganized.
|
| WalletTransaction |
Stores data about a transaction that is only relevant to the Wallet class. |
| WalletTransaction.Pool |
|
| X509Utils |
X509Utils provides tools for working with X.509 certificates and keystores, as used in the BIP 70 payment protocol.
|