Add the following to your pom.xml:

Add the following to the repositories section of your build.gradle:

Java implementation of a JSON-RPC client. JsonRpcClientHttpUrlConnection can be subclassed or called directly using the send() method and Object parameters.

Dynamic RPC methods are implemented via the DynamicRPCFallback Groovy trait. DynamicRPCClient can be used to talk to any JSON-RPC server using standard Java types and Jackson JSON conversion.

Java Bitcoin JSON-RPC client and supporting types, both bitcoinj types and POJOs for Bitcoin Core JSON.

If the RPC procedure takes a Bitcoin address as parameter, then the Java method will take an org.bitcoinj.core.Address. If the RPC returns a transaction, the Java method will return an org.bitcoinj.core.Transaction.

See the JavaDoc for BitcoinClient to see the methods implemented.

Subclass of Bitcoin JSON-RPC client with fallback to dynamic methods (using DynamicRPCFallback). This is useful when new methods are added to the server/protocol and static methods and types haven’t been written for them yet.

An alternative implementation of bitcoin-cli in Java. If converted to a fat jar, it is executable with java -jar. The command:

java -jar cj-btc-cli-0.6.4.jar -rpcport=8080 getblockcount

will output:

For help type:

java -jar bitcoinj-cli-0.6.4.jar -?

or read the manual page.

Jackson serializers, deserializers & POJOs used to create and parse JSON by both client and server implementations of Bitcoin JSON-RPC.

Service-Layer object(s) that power the Daemon. These objects rely solely on javax.annotation and jakarta.inject for configuration and can be wired with Spring, Micronaut IOC, or Guice.

Built as a fat, executable jar, so it can be run with java -jar.

An experimental port of bitcoinj-daemon to Micronaut.

A starting point for building a complete bitcoind equivalent using bitcoinj. It currently serves a small subset of the Bitcoin RPC API (Bitcoin uses JSON-RPC.)

It builds as a native binary using GraalVM.

Groovy DSL support to write things like:

Bitcoin Core integration test framework and tests (Regression Tests using Spock)

Sample Spock Integration Tests

    def "Use RegTest mode to generate a block upon request"() {
        given: "a certain starting height"
        def startHeight = blockCount

        when: "we generate 1 new block"
        generateBlock()

        then: "the block height is 1 higher"
        blockCount == startHeight + 1
    }

    def "When we send an amount to a newly created address, it arrives"() {
        given: "A new, empty Bitcoin address"
        def destinationAddress = getNewAddress()

        when: "we send it testAmount (from coins mined in RegTest mode)"
        sendToAddress(destinationAddress, testAmount, "comment", "comment-to")

        and: "we generate 1 new block"
        generateBlock()

        then: "the new address has a balance of testAmount"
        testAmount == getReceivedByAddress(destinationAddress)
    }

JavaMoney (also known as JSR 354) is the new Java Standard for advanced and flexible currency handling on the Java platform.

JSR 354 provides a portable and extensible framework for handling of Money & Currency. The API models monetary amounts and currencies in a platform independent and portable way, including well defined extension points.

Support for virtual currencies is one of the key design goals in the specification. The consensusj-currency module allows Bitcoin to be used by standard Java APIs in the same ways as fiat currencies.

consensusj-currency contains BitcoinCurrencyProvider which will add "BTC" as a standard currency code to any applications that includes the consensusj-currency JAR in its classpath.

The JavaMoney Reference Implementation (aka "Moneta") contains implementations of ExchangeRateProvider for ECB (European Central Bank) and IMF (International Monetary Fund). There is also U.S. FRB (Federal Reserve Bank) and Yahoo Finance ExchangeRateProvider in the JavaMoney financial library add-on module.

The #consensusj-exchange module includes an adapter class BaseXChangeExchangeRateProvider that adapts implementations of the Exchange interface in the popular and complete XChange library to be used by JavaMoney-compatible applications.

./gradlew build

./gradlew :consensusj-jsonrpc-cli:nativeCompile

consensusj-jsonrpc-cli/build/jsonrpc -?

./gradlew :cj-btc-cli:nativeCompile

cj-btc-cli/build/cj-btc-cli -?

./gradlew :consensusj-jsonrpc-daemon:run

./gradlew :consensusj-jsonrpc-daemon:nativeCompile
consensusj-jsonrpc-daemon/build/native/nativeCompile/jsonrpc-echod

./gradlew :cj-btc-daemon:run

./gradlew :cj-btc-daemon:nativeCompile
cj-btc-daemon/build/native/nativeCompile/jbitcoind