#107/ Update GetNodeVersionInfo response object

java-example/src/main/java/org/onflow/examples/java/getNodeVersionInfo/GetNodeVersionInfoAccessAPIConnector.java

@@ -0,0 +1,23 @@
+package org.onflow.examples.java.getNodeVersionInfo;
+
+import org.onflow.flow.sdk.FlowAccessApi;
+import org.onflow.flow.sdk.FlowNodeVersionInfo;
+
+public class GetNodeVersionInfoAccessAPIConnector {
+    private final FlowAccessApi accessAPI;
+
+    public GetNodeVersionInfoAccessAPIConnector(FlowAccessApi accessAPI) {
+        this.accessAPI = accessAPI;
+    }
+
+    public FlowNodeVersionInfo getNodeVersionInfo() {
+        FlowAccessApi.AccessApiCallResponse<FlowNodeVersionInfo> response = accessAPI.getNodeVersionInfo();
+        if (response instanceof FlowAccessApi.AccessApiCallResponse.Success) {
+            return ((FlowAccessApi.AccessApiCallResponse.Success<FlowNodeVersionInfo>) response).getData();
+        } else {
+            FlowAccessApi.AccessApiCallResponse.Error errorResponse = (FlowAccessApi.AccessApiCallResponse.Error) response;
+            throw new RuntimeException(errorResponse.getMessage(), errorResponse.getThrowable());
+        }
+    }
+}
+

java-example/src/test/java/org/onflow/examples/java/getNodeVersionInfo/GetNodeVersionInfoAccessAPIConnectorTest.java

@@ -0,0 +1,31 @@
+package org.onflow.examples.java.getNodeVersionInfo;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.onflow.flow.common.test.FlowEmulatorProjectTest;
+import org.onflow.flow.common.test.FlowTestClient;
+import org.onflow.flow.sdk.FlowAccessApi;
+import org.onflow.flow.sdk.FlowNodeVersionInfo;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@FlowEmulatorProjectTest(flowJsonLocation = "../flow/flow.json")
+public class GetNodeVersionInfoAccessAPIConnectorTest {
+    @FlowTestClient
+    private FlowAccessApi accessAPI;
+    private GetNodeVersionInfoAccessAPIConnector nodeVersionInfoConnector;
+    @BeforeEach
+    public void setup() {
+        nodeVersionInfoConnector = new GetNodeVersionInfoAccessAPIConnector(accessAPI);
+    }
+
+    @Test
+    public void canFetchNodeVersionInfo() {
+        FlowNodeVersionInfo nodeVersionInfo = nodeVersionInfoConnector.getNodeVersionInfo();
+        assertNotNull(nodeVersionInfo, "Node version info should not be null");
+        assertEquals(nodeVersionInfo.getProtocolVersion(), 0);
+        assertEquals(nodeVersionInfo.getSporkRootBlockHeight(), 0);
+        assertEquals(nodeVersionInfo.getNodeRootBlockHeight(), 0);
+        assertNull(nodeVersionInfo.getCompatibleRange());
+    }
+}

kotlin-example/src/main/kotlin/org/onflow/examples/kotlin/getNodeVersionInfo/GetNodeVersionInfoAccessAPIConnector.kt

@@ -0,0 +1,15 @@
+package org.onflow.examples.kotlin.getNodeVersionInfo
+
+import org.onflow.flow.sdk.FlowAccessApi
+import org.onflow.flow.sdk.FlowNodeVersionInfo
+
+internal class GetNodeVersionInfoAccessAPIConnector(
+    private val accessAPI: FlowAccessApi
+) {
+    fun getNodeVersionInfo(): FlowNodeVersionInfo {
+        return when (val response = accessAPI.getNodeVersionInfo()) {
+            is FlowAccessApi.AccessApiCallResponse.Success -> response.data
+            is FlowAccessApi.AccessApiCallResponse.Error -> throw Exception(response.message, response.throwable)
+        }
+    }
+}

kotlin-example/src/test/kotlin/org/onflow/examples/kotlin/getNodeVersionInfo/GetNodeVersionInfoAccessAPIConnectorTest.kt

@@ -0,0 +1,32 @@
+package org.onflow.examples.kotlin.getNodeVersionInfo
+
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.onflow.flow.common.test.FlowEmulatorProjectTest
+import org.onflow.flow.common.test.FlowTestClient
+import org.onflow.flow.sdk.FlowAccessApi
+import org.onflow.flow.sdk.FlowNodeVersionInfo
+
+@FlowEmulatorProjectTest(flowJsonLocation = "../flow/flow.json")
+internal class GetNodeVersionInfoAccessAPIConnectorTest {
+    @FlowTestClient
+    lateinit var accessAPI: FlowAccessApi
+
+    private lateinit var nodeVersionInfoConnector: GetNodeVersionInfoAccessAPIConnector
+
+    @BeforeEach
+    fun setup() {
+        nodeVersionInfoConnector = GetNodeVersionInfoAccessAPIConnector(accessAPI)
+    }
+
+    @Test
+    fun `Can fetch node version info`() {
+        val nodeVersionInfo: FlowNodeVersionInfo = nodeVersionInfoConnector.getNodeVersionInfo()
+        assertNotNull(nodeVersionInfo, "Node version info should not be null")
+        assertEquals(nodeVersionInfo.protocolVersion, 0)
+        assertEquals(nodeVersionInfo.sporkRootBlockHeight, 0)
+        assertEquals(nodeVersionInfo.nodeRootBlockHeight, 0)
+        assertEquals(nodeVersionInfo.compatibleRange, null)
+    }
+}

sdk/build.gradle.kts

@@ -25,7 +25,7 @@ dependencies {
     api("org.jetbrains.kotlin:kotlin-reflect:1.9.22")
     dokkaHtmlPlugin("org.jetbrains.dokka:kotlin-as-java-plugin:1.9.10")
 
-    api("org.onflow:flow:1.0.0")
+    api("org.onflow:flow:1.1.0")
     api("com.github.TrustedDataFramework:java-rlp:1.1.20")
     api("org.jetbrains.kotlinx:kotlinx-serialization-json:1.4.1")
     api("org.bouncycastle:bcpkix-jdk18on:1.78.1")

sdk/src/intTest/org/onflow/flow/sdk/transaction/TransactionIntegrationTest.kt

@@ -55,6 +55,24 @@ class TransactionIntegrationTest {
         assertThat(networkParams).isEqualTo(FlowChainId.EMULATOR)
     }
 
+    @Test
+    fun `Can get node version info`() {
+        val nodeVersionInfo = try {
+            handleResult(
+                accessAPI.getNodeVersionInfo(),
+                "Failed to get network parameters"
+            )
+        } catch (e: Exception) {
+            fail("Failed to retrieve network parameters: ${e.message}")
+        }
+
+        assertThat(nodeVersionInfo).isNotNull()
+        assertThat(nodeVersionInfo.protocolVersion).isEqualTo(0)
+        assertThat(nodeVersionInfo.sporkRootBlockHeight).isEqualTo(0)
+        assertThat(nodeVersionInfo.nodeRootBlockHeight).isEqualTo(0)
+        assertThat(nodeVersionInfo.compatibleRange).isEqualTo(null)
+    }
+
     @Test
     fun `Can parse events`() {
         val txResult = createAndSubmitAccountCreationTransaction(

sdk/src/main/kotlin/org/onflow/flow/sdk/AsyncFlowAccessApi.kt

@@ -50,6 +50,8 @@ interface AsyncFlowAccessApi {
 
     fun getLatestProtocolStateSnapshot(): CompletableFuture<FlowAccessApi.AccessApiCallResponse<FlowSnapshot>>
 
+    fun getNodeVersionInfo(): CompletableFuture<FlowAccessApi.AccessApiCallResponse<FlowNodeVersionInfo>>
+
     fun getTransactionsByBlockId(id: FlowId): CompletableFuture<FlowAccessApi.AccessApiCallResponse<List<FlowTransaction>>>
 
     fun getTransactionResultsByBlockId(id: FlowId): CompletableFuture<FlowAccessApi.AccessApiCallResponse<List<FlowTransactionResult>>>

sdk/src/main/kotlin/org/onflow/flow/sdk/FlowAccessApi.kt

@@ -57,6 +57,8 @@ interface FlowAccessApi {
 
     fun getLatestProtocolStateSnapshot(): AccessApiCallResponse<FlowSnapshot>
 
+    fun getNodeVersionInfo(): AccessApiCallResponse<FlowNodeVersionInfo>
+
     fun getTransactionsByBlockId(id: FlowId): AccessApiCallResponse<List<FlowTransaction>>
 
     fun getTransactionResultsByBlockId(id: FlowId): AccessApiCallResponse<List<FlowTransactionResult>>

sdk/src/main/kotlin/org/onflow/flow/sdk/impl/AsyncFlowAccessApiImpl.kt

@@ -514,6 +514,32 @@ class AsyncFlowAccessApiImpl(
         }
     }
 
+    override fun getNodeVersionInfo(): CompletableFuture<FlowAccessApi.AccessApiCallResponse<FlowNodeVersionInfo>> {
+        return try {
+            completableFuture(
+                try {
+                    api.getNodeVersionInfo(Access.GetNodeVersionInfoRequest.newBuilder().build())
+                } catch (e: Exception) {
+                    return CompletableFuture.completedFuture(FlowAccessApi.AccessApiCallResponse.Error("Failed to get node version info", e))
+                }
+            ).handle { response, ex ->
+                if (ex != null) {
+                    FlowAccessApi.AccessApiCallResponse.Error("Failed to get node version info", ex)
+                } else {
+                    val compatibleRange = if (response.info.hasCompatibleRange()) {
+                        FlowCompatibleRange(response.info.compatibleRange.startHeight, response.info.compatibleRange.endHeight)
+                    } else {
+                        null
+                    }
+
+                    FlowAccessApi.AccessApiCallResponse.Success(FlowNodeVersionInfo(response.info.semver, response.info.commit, response.info.sporkId.toByteArray(), response.info.protocolVersion, response.info.sporkRootBlockHeight, response.info.nodeRootBlockHeight, compatibleRange))
+                }
+            }
+        } catch (e: Exception) {
+            CompletableFuture.completedFuture(FlowAccessApi.AccessApiCallResponse.Error("Failed to get node version info", e))
+        }
+    }
+
     override fun getTransactionsByBlockId(id: FlowId): CompletableFuture<FlowAccessApi.AccessApiCallResponse<List<FlowTransaction>>> {
         return try {
             completableFuture(

sdk/src/main/kotlin/org/onflow/flow/sdk/impl/FlowAccessApiImpl.kt

@@ -342,6 +342,25 @@ class FlowAccessApiImpl(
         }
     }
 
+    override fun getNodeVersionInfo(): FlowAccessApi.AccessApiCallResponse<FlowNodeVersionInfo> {
+        return try {
+            val ret = api.getNodeVersionInfo(
+                Access.GetNodeVersionInfoRequest.newBuilder()
+                    .build()
+            )
+
+            val compatibleRange = if (ret.info.hasCompatibleRange()) {
+                FlowCompatibleRange(ret.info.compatibleRange.startHeight, ret.info.compatibleRange.endHeight)
+            } else {
+                null
+            }
+
+            FlowAccessApi.AccessApiCallResponse.Success(FlowNodeVersionInfo(ret.info.semver, ret.info.commit, ret.info.sporkId.toByteArray(), ret.info.protocolVersion, ret.info.sporkRootBlockHeight, ret.info.nodeRootBlockHeight, compatibleRange))
+        } catch (e: Exception) {
+            FlowAccessApi.AccessApiCallResponse.Error("Failed to get node version info", e)
+        }
+    }
+
     override fun getTransactionsByBlockId(id: FlowId): FlowAccessApi.AccessApiCallResponse<List<FlowTransaction>> {
         return try {
             val ret = api.getTransactionsByBlockID(

sdk/src/main/kotlin/org/onflow/flow/sdk/models.kt

@@ -1162,6 +1162,73 @@ data class FlowSnapshot(
     override fun hashCode(): Int = bytes.contentHashCode()
 }
 
+data class FlowCompatibleRange(
+    val startHeight: Long,
+    val endHeight: Long
+) : Serializable
+
+data class FlowNodeVersionInfo(
+    val semver: String,
+    val commit: String,
+    val sporkId: ByteArray,
+    val protocolVersion: Long,
+    val sporkRootBlockHeight: Long,
+    val nodeRootBlockHeight: Long,
+    val compatibleRange: FlowCompatibleRange?
+) : Serializable {
+    companion object {
+        @JvmStatic
+        fun of(value: NodeVersionInfoOuterClass.NodeVersionInfo) = FlowNodeVersionInfo(
+            semver = value.semver,
+            commit = value.commit,
+            sporkId = value.sporkId.toByteArray(),
+            protocolVersion = value.protocolVersion,
+            sporkRootBlockHeight = value.sporkRootBlockHeight,
+            nodeRootBlockHeight = value.nodeRootBlockHeight,
+            compatibleRange = if (value.hasCompatibleRange()) {
+                FlowCompatibleRange(value.compatibleRange.startHeight, value.compatibleRange.endHeight)
+            } else {
+                null
+            }
+        )
+    }
+
+    @JvmOverloads
+    fun builder(builder: NodeVersionInfoOuterClass.NodeVersionInfo.Builder = NodeVersionInfoOuterClass.NodeVersionInfo.newBuilder()): NodeVersionInfoOuterClass.NodeVersionInfo.Builder = builder
+        .setSemver(semver)
+        .setCommit(commit)
+        .setSporkId(UnsafeByteOperations.unsafeWrap(sporkId))
+        .setProtocolVersion(protocolVersion)
+        .setSporkRootBlockHeight(sporkRootBlockHeight)
+        .setNodeRootBlockHeight(nodeRootBlockHeight)
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is FlowNodeVersionInfo) return false
+
+        if (semver != other.semver) return false
+        if (commit != other.commit) return false
+        if (!sporkId.contentEquals(other.sporkId)) return false
+        if (protocolVersion != other.protocolVersion) return false
+        if (sporkRootBlockHeight != other.sporkRootBlockHeight) return false
+        if (nodeRootBlockHeight != other.nodeRootBlockHeight) return false
+        if (compatibleRange != other.compatibleRange) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = semver.hashCode()
+        result = 31 * result + commit.hashCode()
+        result = 31 * result + sporkId.contentHashCode()
+        result = 31 * result + protocolVersion.hashCode()
+        result = 31 * result + sporkRootBlockHeight.hashCode()
+        result = 31 * result + nodeRootBlockHeight.hashCode()
+        result = 31 * result + compatibleRange.hashCode()
+        return result
+    }
+}
+
 data class FlowEventPayload(
     override val bytes: ByteArray
 ) : Serializable,

sdk/src/test/kotlin/org/onflow/flow/sdk/impl/AsyncFlowAccessApiImplTest.kt

@@ -3,6 +3,7 @@ package org.onflow.flow.sdk.impl
 import com.google.common.util.concurrent.ListenableFuture
 import com.google.common.util.concurrent.SettableFuture
 import com.google.protobuf.ByteString
+import org.junit.jupiter.api.Assertions.assertArrayEquals
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
@@ -13,6 +14,7 @@ import org.onflow.flow.sdk.*
 import org.onflow.protobuf.access.Access
 import org.onflow.protobuf.access.AccessAPIGrpc
 import org.onflow.protobuf.entities.ExecutionResultOuterClass
+import org.onflow.protobuf.entities.NodeVersionInfoOuterClass
 import org.onflow.protobuf.entities.TransactionOuterClass
 import java.math.BigDecimal
 import java.time.LocalDateTime
@@ -327,6 +329,44 @@ class AsyncFlowAccessApiImplTest {
         assertEquals(mockFlowSnapshot, result.data)
     }
 
+    @Test
+    fun `test getNodeVersionInfo`() {
+        val mockNodeVersionInfo = Access.GetNodeVersionInfoResponse.newBuilder()
+            .setInfo(
+                NodeVersionInfoOuterClass.NodeVersionInfo.newBuilder()
+                    .setSemver("v0.0.1")
+                    .setCommit("123456")
+                    .setSporkId(ByteString.copyFromUtf8("sporkId"))
+                    .setProtocolVersion(5)
+                    .setSporkRootBlockHeight(1000)
+                    .setNodeRootBlockHeight(1001)
+                    .setCompatibleRange(
+                        NodeVersionInfoOuterClass.CompatibleRange.newBuilder()
+                            .setStartHeight(100)
+                            .setEndHeight(200)
+                            .build()
+                    )
+                    .build()
+            ).build()
+
+        `when`(api.getNodeVersionInfo(any())).thenReturn(setupFutureMock(mockNodeVersionInfo))
+
+        val result = asyncFlowAccessApi.getNodeVersionInfo().get()
+
+        assert(result is FlowAccessApi.AccessApiCallResponse.Success)
+        result as FlowAccessApi.AccessApiCallResponse.Success
+        val nodeVersionInfo = result.data
+
+        assertEquals("v0.0.1", nodeVersionInfo.semver)
+        assertEquals("123456", nodeVersionInfo.commit)
+        assertArrayEquals("sporkId".toByteArray(), nodeVersionInfo.sporkId)
+        assertEquals(5, nodeVersionInfo.protocolVersion)
+        assertEquals(1000L, nodeVersionInfo.sporkRootBlockHeight)
+        assertEquals(1001L, nodeVersionInfo.nodeRootBlockHeight)
+        assertEquals(100L, nodeVersionInfo.compatibleRange?.startHeight)
+        assertEquals(200L, nodeVersionInfo.compatibleRange?.endHeight)
+    }
+
     @Test
     fun `test getTransactionsByBlockId`() {
         val blockId = FlowId("01")