LightningJ

// To create a synchronousAPI there are three constructors available
// One simple with host,port and certificate to trust, last file is the file path to the macaroon, use null if no macaroons are used.
SynchronousLndAPI synchronousLndAPI = new SynchronousLndAPI("localhost",10001,
new File("/Library/Application Support/Lnd/tls.cert"),
new File(System.getProperty("user.home")+ "/Library/Application Support/Lnd/admin.macaroon"));
// A second with host,port and a custom SSL Context for more advanced SSL Context and Macaroon Context settings.
//SynchronousLndAPI synchronousLndAPI = new SynchronousLndAPI("localhost",10001,sSLContext, macaroonContext);
// The third that takes a ManagedChannel, with full customization capabilities of underlying API
// See GRPC Java documentation for details.
//SynchronousLndAPI synchronousLndAPI = new SynchronousLndAPI(managedChannel);

// By default is validation performed on all inbound and outbound messages, to turn of validation:
//synchronousLndAPI.setPerformValidation(false);

// Example call to get channel balance and write output as JSON (pretty printed)
System.out.println(synchronousLndAPI.channelBalance().toJsonAsString(true));

// Calls returns a wrapped response or Iterator of wrapped responses.
// Example to get a response:
ListPeersResponse listPeersResponse = synchronousLndAPI.listPeers(false);
// The response can be converted to XML or JSON or just parsed.


// A more advanced call returning an iterator is for example openChannel().

// To generate a request call, there are two ways to generate a request.
// Either build up a request object like below:
OpenChannelRequest openChannelRequest = new OpenChannelRequest();
openChannelRequest.setNodePubkeyString("02ad1fddad0c572ec3e886cbea31bbafa30b5f7e745da7e936ed9d1471116cdc02");
openChannelRequest.setLocalFundingAmount(40000);
openChannelRequest.setPushSat(25000);
openChannelRequest.setSatPerByte(0);

// Alternatively it is possible to specify the parameters directly without having to create a request.
// Iterator<OpenStatusUpdate> result = synchronousLndAPI.openChannel(1,null,"02ad1fddad0c572ec3e886cbea31bbafa30b5f7e745da7e936ed9d1471116cdc02", 40000L,25000L,null,0L,null,null);

// Perform the call using alternative 1
Iterator<OpenStatusUpdate> result = synchronousLndAPI.openChannel(openChannelRequest);

// This call will wait for a the channel has opened, which means confirmation block must
// generated in btc. If simnet is used you can manually generate blocks with
// 'btcctl --simnet --rpcuser=kek --rpcpass=kek generate 3'

while (result.hasNext()) {
    System.out.println("Received Update: " + result.next().toJsonAsString(true));
}

// To close the api use the method
synchronousLndAPI.close();

// Create  API, using the most simple constructor. There are alternatives
// where it is possible to specify custom SSLContext or just a managed channel.
// See SynchronousLndAPIExample for details.
AsynchronousLndAPI asynchronousLndAPI = new AsynchronousLndAPI("localhost",10001,new File("/Users/philip/Library/Application Support/Lnd/tls.cert"),null);

try {
    // Example of a simple asynchronous call.
    System.out.println("Sending WalletBalance request...");
    asynchronousLndAPI.walletBalance(new StreamObserver<WalletBalanceResponse>() {

        // Each response is sent in a onNext call.
        @Override
        public void onNext(WalletBalanceResponse value) {
            System.out.println("Received WalletBalance response: " + value.toJsonAsString(true));
        }

        // Errors during the stream is showed here.
        @Override
        public void onError(Throwable t) {
            System.err.println("Error occurred during WalletBalance call: " + t.getMessage());
            t.printStackTrace(System.err);
        }

        // When the stream have finished is onCompleted called.
        @Override
        public void onCompleted() {
            System.out.println("WalletBalance call closed.");
        }
    });

    // Call to subscribe for invoices.
    // To recieve invoices you can use the lncli to send payment of an invoice to your LND node.
    // and it will show up here.
    System.out.println("Subscribing to invoices call...");
    asynchronousLndAPI.subscribeInvoices(new StreamObserver<Invoice>() {
        @Override
        public void onNext(Invoice value) {
            System.out.println("Received Invoice: " + value.toJsonAsString(true));
        }

        @Override
        public void onError(Throwable t) {
            System.err.println("Error occurred during subscribeInvoices call: " + t.getMessage());
            t.printStackTrace(System.err);
        }

        @Override
        public void onCompleted() {
            System.out.println("subscribeInvoices call closed.");
        }
    });

    System.out.println("Press Ctrl-C to stop listening for invoices");
    while (true) {
        Thread.sleep(1000);
    }

} finally {
    // To close the api use the method
    asynchronousLndAPI.close();
}

// Get API
SynchronousLndAPI synchronousLndAPI = getSynchronousLndAPI();

try {
    // Perform a call
    synchronousLndAPI.channelBalance();
} catch (ValidationException ve) {
    // Thrown if request or response contained invalid data
} catch (StatusException se) {
    // Thrown if GRPC related exception happened.
}

// Example of more fine grained exception handling.
try {
    synchronousLndAPI.channelBalance();
} catch (ValidationException ve) {
    // Thrown if request or response contained invalid data
} catch (ClientSideException cse) {
    // Thrown if there is some problem on the client side such as invalid request data.
} catch (ServerSideException sse) {
    // Thrown if there is some problem on the server side that might persist for some time.
} catch (CommunicationException ce) {
    // Thrown if communication problems occurred such as  timeout or dropped package and request can be retried.
}

AsynchronousLndAPI asynchronousLndAPI = getAsynchronousLndAPI();

asynchronousLndAPI.channelBalance(new StreamObserver<ChannelBalanceResponse>() {
    @Override
    public void onNext(ChannelBalanceResponse value) {
        // Handle ok resonses
    }

    @Override
    public void onError(Throwable t) {
        // Here is exceptions sent of same type as thrown by synchronous API.
    }

    @Override
    public void onCompleted() {
        // Call completed
    }
});