FlowBlockSeal protobuf updates

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

@@ -1201,27 +1201,80 @@ data class FlowCollectionGuarantee(
 }
 
 data class FlowBlockSeal(
- val id: FlowId,
+ val blockId: FlowId,
  val executionReceiptId: FlowId,
  val executionReceiptSignatures: List<FlowSignature>,
- val resultApprovalSignatures: List<FlowSignature>
+ val resultApprovalSignatures: List<FlowSignature>,
+ val finalState: ByteArray,
+ val resultId: FlowId,
+ val aggregatedApprovalSigs: List<FlowAggregatedSignature>,
 ) : Serializable {
  companion object {
  @JvmStatic
  fun of(value: BlockSealOuterClass.BlockSeal) = FlowBlockSeal(
- id = FlowId.of(value.blockId.toByteArray()),
+ blockId = FlowId.of(value.blockId.toByteArray()),
  executionReceiptId = FlowId.of(value.executionReceiptId.toByteArray()),
  executionReceiptSignatures = value.executionReceiptSignaturesList.map { FlowSignature(it.toByteArray()) },
- resultApprovalSignatures = value.executionReceiptSignaturesList.map { FlowSignature(it.toByteArray()) }
+ resultApprovalSignatures = value.resultApprovalSignaturesList.map { FlowSignature(it.toByteArray()) },
+ finalState = value.finalState.toByteArray(),
+ resultId = FlowId.of(value.resultId.toByteArray()),
+ aggregatedApprovalSigs = value.aggregatedApprovalSigsList.map { FlowAggregatedSignature.of(it) },
  )
  }
 
  @JvmOverloads
  fun builder(builder: BlockSealOuterClass.BlockSeal.Builder = BlockSealOuterClass.BlockSeal.newBuilder()): BlockSealOuterClass.BlockSeal.Builder = builder
- .setBlockId(id.byteStringValue)
+ .setBlockId(blockId.byteStringValue)
  .setExecutionReceiptId(executionReceiptId.byteStringValue)
  .addAllExecutionReceiptSignatures(executionReceiptSignatures.map { it.byteStringValue })
  .addAllResultApprovalSignatures(resultApprovalSignatures.map { it.byteStringValue })
+ .setFinalState(UnsafeByteOperations.unsafeWrap(finalState))
+ .setResultId(resultId.byteStringValue)
+ .addAllAggregatedApprovalSigs(aggregatedApprovalSigs.map { it.builder().build() })
+
+ override fun equals(other: Any?): Boolean {
+ if (this === other) return true
+ if (other !is FlowBlockSeal) return false
+
+ if (blockId != other.blockId) return false
+ if (executionReceiptId != other.executionReceiptId) return false
+ if (executionReceiptSignatures != other.executionReceiptSignatures) return false
+ if (resultApprovalSignatures != other.resultApprovalSignatures) return false
+ if (!finalState.contentEquals(other.finalState)) return false
+ if (resultId != other.resultId) return false
+ if (aggregatedApprovalSigs != other.aggregatedApprovalSigs) return false
+
+ return true
+ }
+
+ override fun hashCode(): Int {
+ var result = blockId.hashCode()
+ result = 31 * result + executionReceiptId.hashCode()
+ result = 31 * result + executionReceiptSignatures.hashCode()
+ result = 31 * result + resultApprovalSignatures.hashCode()
+ result = 31 * result + finalState.contentHashCode()
+ result = 31 * result + resultId.hashCode()
+ result = 31 * result + aggregatedApprovalSigs.hashCode()
+ return result
+ }
+}
+
+data class FlowAggregatedSignature(
+ val verifierSignatures: List<FlowSignature>,
+ val signerIds: List<FlowId>,
+) : Serializable {
+ companion object {
+ @JvmStatic
+ fun of(value: BlockSealOuterClass.AggregatedSignature) = FlowAggregatedSignature(
+ verifierSignatures = value.verifierSignaturesList.map { FlowSignature(it.toByteArray()) },
+ signerIds = value.signerIdsList.map { FlowId.of(it.toByteArray()) }
+ )
+ }
+
+ @JvmOverloads
+ fun builder(builder: BlockSealOuterClass.AggregatedSignature.Builder = BlockSealOuterClass.AggregatedSignature.newBuilder()): BlockSealOuterClass.AggregatedSignature.Builder = builder
+ .addAllVerifierSignatures(verifierSignatures.map { it.byteStringValue })
+ .addAllSignerIds(signerIds.map { it.byteStringValue })
 }
 
 data class FlowCollection(

sdk/src/test/kotlin/org/onflow/flow/sdk/models/FlowAggregatedSignatureTest.kt

@@ -0,0 +1,89 @@
+package org.onflow.flow.sdk.models
+
+import org.onflow.flow.sdk.FlowAggregatedSignature
+import org.onflow.flow.sdk.FlowId
+import org.onflow.flow.sdk.FlowSignature
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+import org.mockito.Mockito
+import org.onflow.protobuf.entities.BlockSealOuterClass
+
+class FlowAggregatedSignatureTest {
+ @Test
+ fun `test FlowAggregatedSignature equals and hashCode`() {
+ val signature1 = FlowSignature("signature1".toByteArray())
+ val signature2 = FlowSignature("signature2".toByteArray())
+
+ val signerId1 = FlowId.of("signerId1".toByteArray())
+ val signerId2 = FlowId.of("signerId2".toByteArray())
+
+ val aggregatedSignature1 = FlowAggregatedSignature(
+ verifierSignatures = listOf(signature1),
+ signerIds = listOf(signerId1)
+ )
+
+ val aggregatedSignature2 = FlowAggregatedSignature(
+ verifierSignatures = listOf(signature1),
+ signerIds = listOf(signerId1)
+ )
+
+ val aggregatedSignature3 = FlowAggregatedSignature(
+ verifierSignatures = listOf(signature2),
+ signerIds = listOf(signerId2)
+ )
+
+ // Test equality
+ assertEquals(aggregatedSignature1, aggregatedSignature2)
+ assertNotEquals(aggregatedSignature1, aggregatedSignature3)
+
+ // Test hashCode
+ assertEquals(aggregatedSignature1.hashCode(), aggregatedSignature2.hashCode())
+ assertNotEquals(aggregatedSignature1.hashCode(), aggregatedSignature3.hashCode())
+ }
+
+ @Test
+ fun `test FlowAggregatedSignature of function`() {
+ // Mock BlockSealOuterClass.AggregatedSignature
+ val aggregatedSignatureProto = Mockito.mock(BlockSealOuterClass.AggregatedSignature::class.java)
+
+ val signatureBytes = "signature".toByteArray()
+ val signerIdBytes = "signerId".toByteArray()
+
+ Mockito.`when`(aggregatedSignatureProto.verifierSignaturesList).thenReturn(
+ listOf(
+ com.google.protobuf.ByteString
+ .copyFrom(signatureBytes)
+ )
+ )
+ Mockito.`when`(aggregatedSignatureProto.signerIdsList).thenReturn(
+ listOf(
+ com.google.protobuf.ByteString
+ .copyFrom(signerIdBytes)
+ )
+ )
+
+ val flowAggregatedSignature = FlowAggregatedSignature.of(aggregatedSignatureProto)
+
+ assertEquals(1, flowAggregatedSignature.verifierSignatures.size)
+ assertEquals(FlowSignature(signatureBytes), flowAggregatedSignature.verifierSignatures[0])
+
+ assertEquals(1, flowAggregatedSignature.signerIds.size)
+ assertEquals(FlowId.of(signerIdBytes), flowAggregatedSignature.signerIds[0])
+ }
+
+ @Test
+ fun `test FlowAggregatedSignature builder function`() {
+ val signature1 = FlowSignature("signature1".toByteArray())
+ val signerId1 = FlowId.of("signerId1".toByteArray())
+
+ val aggregatedSignature = FlowAggregatedSignature(
+ verifierSignatures = listOf(signature1),
+ signerIds = listOf(signerId1)
+ )
+
+ val builderResult = aggregatedSignature.builder()
+
+ assertEquals(listOf(signature1.byteStringValue), builderResult.verifierSignaturesList)
+ assertEquals(listOf(signerId1.byteStringValue), builderResult.signerIdsList)
+ }
+}

sdk/src/test/kotlin/org/onflow/flow/sdk/models/FlowBlockSealTest.kt

@@ -0,0 +1,140 @@
+package org.onflow.flow.sdk.models
+
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+import org.mockito.Mockito
+import org.onflow.flow.sdk.FlowAggregatedSignature
+import org.onflow.flow.sdk.FlowBlockSeal
+import org.onflow.flow.sdk.FlowId
+import org.onflow.flow.sdk.FlowSignature
+import org.onflow.protobuf.entities.BlockSealOuterClass
+
+class FlowBlockSealTest {
+ @Test
+ fun `test FlowBlockSeal equals and hashCode`() {
+ val blockId = FlowId.of("blockId".toByteArray())
+ val executionReceiptId = FlowId.of("executionReceiptId".toByteArray())
+ val resultId = FlowId.of("resultId".toByteArray())
+ val finalState = "finalState".toByteArray()
+
+ val signature1 = FlowSignature("signature1".toByteArray())
+ val signature2 = FlowSignature("signature2".toByteArray())
+
+ val aggregatedSignature1 = FlowAggregatedSignature(
+ verifierSignatures = listOf(signature1),
+ signerIds = listOf(blockId)
+ )
+
+ val seal1 = FlowBlockSeal(
+ blockId = blockId,
+ executionReceiptId = executionReceiptId,
+ executionReceiptSignatures = listOf(signature1),
+ resultApprovalSignatures = listOf(signature2),
+ finalState = finalState,
+ resultId = resultId,
+ aggregatedApprovalSigs = listOf(aggregatedSignature1)
+ )
+
+ val seal2 = FlowBlockSeal(
+ blockId = blockId,
+ executionReceiptId = executionReceiptId,
+ executionReceiptSignatures = listOf(signature1),
+ resultApprovalSignatures = listOf(signature2),
+ finalState = finalState,
+ resultId = resultId,
+ aggregatedApprovalSigs = listOf(aggregatedSignature1)
+ )
+
+ // Testing equals
+ assertEquals(seal1, seal2)
+
+ // Testing hashCode
+ assertEquals(seal1.hashCode(), seal2.hashCode())
+ }
+
+ @Test
+ fun `test FlowBlockSeal of function`() {
+ // Mock BlockSealOuterClass.BlockSeal
+ val blockSealProto = Mockito.mock(BlockSealOuterClass.BlockSeal::class.java)
+
+ val blockIdBytes = "blockId".toByteArray()
+ val executionReceiptIdBytes = "executionReceiptId".toByteArray()
+ val resultIdBytes = "resultId".toByteArray()
+ val finalStateBytes = "finalState".toByteArray()
+
+ Mockito.`when`(blockSealProto.blockId).thenReturn(
+ com.google.protobuf.ByteString
+ .copyFrom(blockIdBytes)
+ )
+ Mockito.`when`(blockSealProto.executionReceiptId).thenReturn(
+ com.google.protobuf.ByteString
+ .copyFrom(executionReceiptIdBytes)
+ )
+ Mockito.`when`(blockSealProto.resultId).thenReturn(
+ com.google.protobuf.ByteString
+ .copyFrom(resultIdBytes)
+ )
+ Mockito.`when`(blockSealProto.finalState).thenReturn(
+ com.google.protobuf.ByteString
+ .copyFrom(finalStateBytes)
+ )
+ Mockito.`when`(blockSealProto.executionReceiptSignaturesList).thenReturn(
+ listOf(
+ com.google.protobuf.ByteString
+ .copyFrom("signature1".toByteArray())
+ )
+ )
+ Mockito.`when`(blockSealProto.resultApprovalSignaturesList).thenReturn(
+ listOf(
+ com.google.protobuf.ByteString
+ .copyFrom("signature2".toByteArray())
+ )
+ )
+ Mockito.`when`(blockSealProto.aggregatedApprovalSigsList).thenReturn(
+ listOf(
+ BlockSealOuterClass.AggregatedSignature.newBuilder().build()
+ )
+ )
+
+ val flowBlockSeal = FlowBlockSeal.of(blockSealProto)
+
+ assertEquals(FlowId.of(blockIdBytes), flowBlockSeal.blockId)
+ assertEquals(FlowId.of(executionReceiptIdBytes), flowBlockSeal.executionReceiptId)
+ assertEquals(FlowId.of(resultIdBytes), flowBlockSeal.resultId)
+ assertArrayEquals(finalStateBytes, flowBlockSeal.finalState)
+ }
+
+ @Test
+ fun `test FlowBlockSeal builder function`() {
+ val blockId = FlowId.of("blockId".toByteArray())
+ val executionReceiptId = FlowId.of("executionReceiptId".toByteArray())
+ val resultId = FlowId.of("resultId".toByteArray())
+ val finalState = "finalState".toByteArray()
+
+ val signature1 = FlowSignature("signature1".toByteArray())
+ val signature2 = FlowSignature("signature2".toByteArray())
+ val aggregatedSignature1 = FlowAggregatedSignature(
+ verifierSignatures = listOf(signature1),
+ signerIds = listOf(blockId)
+ )
+
+ val seal = FlowBlockSeal(
+ blockId = blockId,
+ executionReceiptId = executionReceiptId,
+ executionReceiptSignatures = listOf(signature1),
+ resultApprovalSignatures = listOf(signature2),
+ finalState = finalState,
+ resultId = resultId,
+ aggregatedApprovalSigs = listOf(aggregatedSignature1)
+ )
+
+ val builderResult = seal.builder()
+
+ assertEquals(blockId.byteStringValue, builderResult.blockId)
+ assertEquals(executionReceiptId.byteStringValue, builderResult.executionReceiptId)
+ assertEquals(resultId.byteStringValue, builderResult.resultId)
+ assertEquals(finalState.toList(), builderResult.finalState.toByteArray().toList())
+ assertEquals(listOf(signature1.byteStringValue), builderResult.executionReceiptSignaturesList)
+ assertEquals(listOf(signature2.byteStringValue), builderResult.resultApprovalSignaturesList)
+ }
+}