#107/ Update GetNodeVersionInfo response object

.gitignore

@@ -4,3 +4,4 @@ build
 sdk/gradle.properties
 flowdb
 .DS_Store
+.kotlin/errors

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,14 @@
+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 =
+        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

@@ -32,7 +32,7 @@ sourceSets {
 
 dependencies {
     api("org.jetbrains.kotlin:kotlin-reflect:2.0.21")
-    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.7.3")
     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

@@ -62,6 +62,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

@@ -588,6 +588,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

@@ -341,6 +341,25 @@ class FlowAccessApiImpl(
             FlowAccessApi.AccessApiCallResponse.Error("Failed to get latest protocol state snapshot", e)
         }
 
+    override fun getNodeVersionInfo(): FlowAccessApi.AccessApiCallResponse<FlowNodeVersionInfo> =
+        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>> =
         try {
             val ret = api.getTransactionsByBlockID(