Basics to Develop a Corda Application with Spring Boot

Published : Dec 26, 2019

Corda Spring boot

  • In this article, we have explained how to make use of a client proxy to make RPCs for a Corda Node. The RPC client can be written in any JVM compatible language using the CordaRPCClient class. Once connected, you can trigger the vault and the flow, and get results.

    Begin with adding a variable for the spring boot version and Corda version that should've been installed locally, including spring classpath dependencies.

    buildscript {

        ext {

            corda_release_group = net.corda"






            spring_boot_version = '2.0.2.RELEASE'

            spring_boot_gradle_plugin_version = '2.1.1.RELEASE'


        repositories {




            maven { url '' }


        dependencies {

            classpath org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"

            classpath net.corda.plugins:cordapp:$corda_gradle_plugins_version"

            classpath net.corda.plugins:cordformation:$corda_gradle_plugins_version"


            classpath org.springframework.boot:spring-boot-gradle-plugin:$spring_boot_gradle_plugin_version"


    repositories {



        maven { url '' }

        //Corda testing node-driver requires gradle-tooling-api

        maven { url '' }

     //Required for Corda SNPASHOTs

        maven { url '' }

        maven { url '' }


    Add corda and spring dependencies in build.gradle file

    dependencies {

        compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"

        testCompile "org.jetbrains.kotlin:kotlin-test:$kotlin_version"

        testCompile "junit:junit:$junit_version"

      // Corda dependencies.

        cordaCompile $corda_release_group:corda-core:$corda_release_version"

        cordaCompile $corda_release_group:corda-jackson:$corda_release_version"

        cordaCompile $corda_release_group:corda-rpc:$corda_release_version"

        cordaCompile $corda_release_group:corda-node-api:$corda_release_version"

        cordaRuntime "$corda_release_group:corda:$corda_release_version"

        testCompile "$corda_release_group:corda-node-driver:$corda_release_version"

        cordaRuntime "org.apache.logging.log4j:log4j-slf4j-impl:$log4j_version"

        compile("org.springframework.boot:spring-boot-starter-websocket:$spring_boot_version") {

            exclude group: "org.springframework.boot", module: "spring-boot-starter-logging"


        compile "org.apache.logging.log4j:log4j-web:$log4j_version"


    Add a task for deploying your Node 

    task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {

        nodeDefaults {

            projectCordapp {

                deploy = false




        signing {

            enabled false


        node {

            name O=PartyA,L=London,C=GB"

            p2pPort 10005

            rpcSettings {




            rpcUsers = [[ username: "user1", "password": "test", "permissions": ["ALL"]]]


    }Add Task for Server 

    Add Task for Server 

    task runPartyAServer (type: JavaExec ,dependsOn: assemble) {

        classpath = sourceSets.main.runtimeClasspath

        main ='net.corda.server.ServerKt'



    The Server

    Similar to any other Spring Boot app, we define the main entry point with a SpringApplication instance. The @SpringBootApplication annotation should be added to the class consuming the SpringApplication instance, which in this case is Server.


    open class Starter

    fun main(args: Array<String>) {

            val app = SpringApplication(

            app.setBannerMode(Banner.Mode.CONSOLE) app.isWebEnvironment = true



    Connecting to the Node

    In corda application, to allow the server to interact with the Corda node a long-lasting connection via RPC needs to be established. We can do this by using CordaRPCConnection and CordaRPCClient .

    private const val CORDA_USER_NAME = "config.rpc.username"

    private const val CORDA_USER_PASSWORD = "config.rpc.password"

    private const val CORDA_NODE_HOST = ""

    private const val CORDA_RPC_PORT = "config.rpc.port"

    private const val CORDA__RPC_PORT1 = "configNode1.rpc.port"


    open class NodeRPCConnection (

        @Value("\${$CORDA_NODE_HOST}">) private val host: String ,

        @Value("\${$CORDA_NODE_HOST}">) private val username : String ,

        @Value("\${$CORDA_NODE_HOST}">) private val password : String ,

        @Value("\${$CORDA_NODE_HOST}">) private val rpcPort : Int ,

        @Value("\${$CORDA_NODE_HOST}">) private val host: rpcPort1 : In
    ) :AutoCloseable{

        lateinit var rpcConnection: CordaRPCConnection

     private set

        lateinit var proxy: CordaRPCOps



       fun initialiseNodeRPCConnectionDelhi()


       val rpcAddress = NetworkHostAndPort(host, rpcPort)

       val rpcClient = CordaRPCClient(rpcAddress)

       println("rpcClient=======" + rpcClient)

       val rpcConnection = rpcClient.start(username, password)

        proxy = rpcConnection.proxy




        override fun close() {



    Spring API

    Rest Controller


    class CustomController(rpc: NodeRPCConnection) {

        private val proxy = rpc.proxy

       @GetMapping(value = "/me" , produces =


          Returns the node's name where spring Application running.


         private fun me() : ResponseEntity<Map<String,Any>> {



         * Returns all parties registered with the [NetworkMapService]. 


         @GetMapping(value = "/peers", produces =
    , produces = arrayOf(MediaType.APPLICATION_JSON_VALUE))

         private fun peers() :ResponseEntity<Map<String,Any>> {

         var partylist = proxy.networkMapSnapshot().flatMap { it.legalIdentities}

          var peers : ArrayList = ArrayList()

          for (i in partylist)




            return ResponseHandler.generateResponse(HttpStatus.OK,true,peers)



    Application Properties

    config.rpc.username = user1

    config.rpc.password = test

    config.rpc.port= 10006


    We hope this post helps you understand how to develop a Corda application with spring boot. However, there is a lot to learn. We have only covered the basics in this post. We have implemented the CordaRPCConnection and CordaRPCClient. We have planned to write more posts on developing Corda while focusing on explaining more complex features. Also, take a look at our Corda blockchain development services for enterprise as well as public solutions.

How useful was this post?

Click on a star to rate it!

  • 0
  • 0

No votes so far! Be the first to rate this post.

Share :

Leave a Comment

Name is required

Comment is required

Recaptcha is required.

No Comments Yet.

More From Oodles

By using this site, you allow our use of cookies. For more information on the cookies we use and how to delete or block them, please read our cookie notice.

Chat with Us Chat with Us
We would love to hear from you!

Oodles | Blockchain Development Company

Name is required

Enter a valid Name

Please enter a valid Phone Number

Please remove URL from text

Recaptcha is required.