feature: update SDK to new Iroha2 version with Trigger metadata suppo…

…rt (#407) Signed-off-by: Timur Guskov <[email protected]> Co-authored-by: Timur Guskov <[email protected]>
hyperledger-iroha · Apr 2, 2024 · 3c867ee · 3c867ee
1 parent 724d482
commit 3c867ee
Show file tree

Hide file tree

Showing 11 changed files with 269 additions and 3 deletions.
diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Instructions.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Instructions.kt
@@ -322,6 +322,21 @@ object Instructions {
         ),
     )
 
+    /**
+     * Set key/value for a given trigger
+     */
+    fun setKeyValue(
+        triggerId: TriggerId,
+        key: Name,
+        value: Value,
+    ) = InstructionExpr.SetKeyValue(
+        SetKeyValueExpr(
+            objectId = IdBox.TriggerId(triggerId).evaluatesTo(),
+            key = key.evaluatesTo(),
+            value = value.evaluatesTo(),
+        ),
+    )
+
     /**
      * Set key/value for a given asset definition
      */

diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/TransactionBuilder.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/TransactionBuilder.kt
@@ -314,6 +314,12 @@ class TransactionBuilder(builder: TransactionBuilder.() -> Unit = {}) {
         value: Value,
     ) = this.apply { instructions.value.add(Instructions.setKeyValue(definitionId, key, value)) }
 
+    fun setKeyValue(
+        triggerId: TriggerId,
+        key: Name,
+        value: Value,
+    ) = this.apply { instructions.value.add(Instructions.setKeyValue(triggerId, key, value)) }
+
     fun setKeyValue(
         domainId: DomainId,
         key: Name,

diff --git a/modules/client/src/test/create_nft_for_alice_smartcontract/src/lib.rs b/modules/client/src/test/create_nft_for_alice_smartcontract/src/lib.rs
@@ -17,7 +17,7 @@ static ALLOC: LockedAllocator<FreeListAllocator> = LockedAllocator::new(FreeList
 use iroha_trigger::{data_model::prelude::*, debug::DebugUnwrapExt, smart_contract::QueryHost};
 
 #[iroha_trigger::main]
-fn smartcontract_entry_point(_owner: AccountId, _event: Event) {
+fn smartcontract_entry_point(_id: TriggerId, _owner: AccountId, _event: Event) {
     let account_id: AccountId = "alice@wonderland".parse().unwrap();
     let limits = MetadataLimits::new(256, 256);
     let mut metadata = Metadata::new();

diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/TriggersTest.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/TriggersTest.kt
@@ -224,7 +224,7 @@ class TriggersTest : IrohaTest<Iroha2Client>() {
     @WithIroha([AliceHas100XorAndPermissionToBurn::class])
     @Story("Wasm trigger mints NFT for every user")
     @SdkTestId("wasm_trigger_to_mint_nft_for_every_user")
-    fun `wasm trigger to mint nft for every user`(): Unit = runBlocking {
+    fun `wasm trigger to mint nft for every user and update trigger metadata`(): Unit = runBlocking {
         val triggerId = TriggerId(name = "wasm_trigger".asName())
 
         val currentTime = Date().time / 1000
@@ -280,6 +280,21 @@ class TriggersTest : IrohaTest<Iroha2Client>() {
                     },
                 )
             }
+
+        val testKey = "key"
+        val testValue = "value"
+        client.sendTransaction {
+            accountId = ALICE_ACCOUNT_ID
+            setKeyValue(triggerId, testKey.asName(), testValue.asValue())
+            buildSigned(ALICE_KEYPAIR)
+        }.also { d ->
+            withTimeout(txTimeout) { d.await() }
+        }
+        QueryBuilder.findTriggerById(triggerId)
+            .account(ALICE_ACCOUNT_ID)
+            .buildSigned(ALICE_KEYPAIR)
+            .let { query -> client.sendQuery(query) }
+            .also { assertEquals(testValue, it.action.metadata.getStringValue(testKey)) }
     }
 
     @Test

diff --git a/modules/client/src/test/resources/create_nft_for_alice_smartcontract.wasm b/modules/client/src/test/resources/create_nft_for_alice_smartcontract.wasm
diff --git a/modules/client/src/test/resources/executor.wasm b/modules/client/src/test/resources/executor.wasm
diff --git a/modules/codegen/src/main/resources/schema.json b/modules/codegen/src/main/resources/schema.json
@@ -2833,6 +2833,22 @@
       }
     ]
   },
+  "MetadataChanged<TriggerId>": {
+    "Struct": [
+      {
+        "name": "target_id",
+        "type": "TriggerId"
+      },
+      {
+        "name": "key",
+        "type": "Name"
+      },
+      {
+        "name": "value",
+        "type": "Value"
+      }
+    ]
+  },
   "MetadataError": {
     "Enum": [
       {
@@ -4418,6 +4434,16 @@
         "tag": "Shortened",
         "discriminant": 3,
         "type": "TriggerNumberOfExecutionsChanged"
+      },
+      {
+        "tag": "MetadataInserted",
+        "discriminant": 4,
+        "type": "MetadataChanged<TriggerId>"
+      },
+      {
+        "tag": "MetadataRemoved",
+        "discriminant": 5,
+        "type": "MetadataChanged<TriggerId>"
       }
     ]
   },
@@ -4438,6 +4464,14 @@
       {
         "tag": "ByShortened",
         "discriminant": 3
+      },
+      {
+        "tag": "ByMetadataInserted",
+        "discriminant": 4
+      },
+      {
+        "tag": "ByMetadataRemoved",
+        "discriminant": 5
       }
     ]
   },

diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfTriggerId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfTriggerId.kt
@@ -0,0 +1,44 @@
+//
+// Auto-generated file. DO NOT EDIT!
+//
+package jp.co.soramitsu.iroha2.generated
+
+import jp.co.soramitsu.iroha2.codec.ScaleCodecReader
+import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter
+import jp.co.soramitsu.iroha2.codec.ScaleReader
+import jp.co.soramitsu.iroha2.codec.ScaleWriter
+import jp.co.soramitsu.iroha2.wrapException
+import kotlin.Unit
+
+/**
+ * MetadataChangedOfTriggerId
+ *
+ * Generated from 'MetadataChangedOfTriggerId' regular structure
+ */
+public data class MetadataChangedOfTriggerId(
+    public val targetId: TriggerId,
+    public val key: Name,
+    public val `value`: Value,
+) {
+    public companion object :
+        ScaleReader<MetadataChangedOfTriggerId>,
+        ScaleWriter<MetadataChangedOfTriggerId> {
+        override fun read(reader: ScaleCodecReader): MetadataChangedOfTriggerId = try {
+            MetadataChangedOfTriggerId(
+                TriggerId.read(reader),
+                Name.read(reader),
+                Value.read(reader),
+            )
+        } catch (ex: Exception) {
+            throw wrapException(ex)
+        }
+
+        override fun write(writer: ScaleCodecWriter, instance: MetadataChangedOfTriggerId): Unit = try {
+            TriggerId.write(writer, instance.targetId)
+            Name.write(writer, instance.key)
+            Value.write(writer, instance.`value`)
+        } catch (ex: Exception) {
+            throw wrapException(ex)
+        }
+    }
+}
diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerEvent.kt
@@ -151,6 +151,70 @@ public sealed class TriggerEvent : ModelEnum {
         }
     }
 
+    /**
+     * 'MetadataInserted' variant
+     */
+    public data class MetadataInserted(
+        public val metadataChangedOfTriggerId: MetadataChangedOfTriggerId,
+    ) : TriggerEvent() {
+        override fun discriminant(): Int = DISCRIMINANT
+
+        public companion object :
+            ScaleReader<jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataInserted>,
+            ScaleWriter<jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataInserted> {
+            public const val DISCRIMINANT: Int = 4
+
+            override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataInserted = try {
+                MetadataInserted(
+                    MetadataChangedOfTriggerId.read(reader),
+                )
+            } catch (ex: Exception) {
+                throw wrapException(ex)
+            }
+
+            override fun write(
+                writer: ScaleCodecWriter,
+                instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataInserted,
+            ): Unit = try {
+                MetadataChangedOfTriggerId.write(writer, instance.metadataChangedOfTriggerId)
+            } catch (ex: Exception) {
+                throw wrapException(ex)
+            }
+        }
+    }
+
+    /**
+     * 'MetadataRemoved' variant
+     */
+    public data class MetadataRemoved(
+        public val metadataChangedOfTriggerId: MetadataChangedOfTriggerId,
+    ) : TriggerEvent() {
+        override fun discriminant(): Int = DISCRIMINANT
+
+        public companion object :
+            ScaleReader<jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataRemoved>,
+            ScaleWriter<jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataRemoved> {
+            public const val DISCRIMINANT: Int = 5
+
+            override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataRemoved = try {
+                MetadataRemoved(
+                    MetadataChangedOfTriggerId.read(reader),
+                )
+            } catch (ex: Exception) {
+                throw wrapException(ex)
+            }
+
+            override fun write(
+                writer: ScaleCodecWriter,
+                instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataRemoved,
+            ): Unit = try {
+                MetadataChangedOfTriggerId.write(writer, instance.metadataChangedOfTriggerId)
+            } catch (ex: Exception) {
+                throw wrapException(ex)
+            }
+        }
+    }
+
     public companion object : ScaleReader<TriggerEvent>, ScaleWriter<TriggerEvent> {
         override fun read(reader: ScaleCodecReader): TriggerEvent = when (
             val discriminant =
@@ -160,6 +224,8 @@ public sealed class TriggerEvent : ModelEnum {
             1 -> Deleted.read(reader)
             2 -> Extended.read(reader)
             3 -> Shortened.read(reader)
+            4 -> MetadataInserted.read(reader)
+            5 -> MetadataRemoved.read(reader)
             else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") }
 
         override fun write(writer: ScaleCodecWriter, instance: TriggerEvent) {
@@ -169,6 +235,8 @@ public sealed class TriggerEvent : ModelEnum {
                 1 -> Deleted.write(writer, instance as Deleted)
                 2 -> Extended.write(writer, instance as Extended)
                 3 -> Shortened.write(writer, instance as Shortened)
+                4 -> MetadataInserted.write(writer, instance as MetadataInserted)
+                5 -> MetadataRemoved.write(writer, instance as MetadataRemoved)
                 else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") }
         }
     }

diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerEventFilter.kt
@@ -30,13 +30,17 @@ public sealed class TriggerEventFilter : ModelEnum {
         is ByDeleted -> ByDeleted.equals(this, other)
         is ByExtended -> ByExtended.equals(this, other)
         is ByShortened -> ByShortened.equals(this, other)
+        is ByMetadataInserted -> ByMetadataInserted.equals(this, other)
+        is ByMetadataRemoved -> ByMetadataRemoved.equals(this, other)
         else -> super.equals(other) }
 
     override fun hashCode(): Int = when (this) {
         is ByCreated -> ByCreated.hashCode()
         is ByDeleted -> ByDeleted.hashCode()
         is ByExtended -> ByExtended.hashCode()
         is ByShortened -> ByShortened.hashCode()
+        is ByMetadataInserted -> ByMetadataInserted.hashCode()
+        is ByMetadataRemoved -> ByMetadataRemoved.hashCode()
         else -> super.hashCode() }
 
     /**
@@ -187,6 +191,82 @@ public sealed class TriggerEventFilter : ModelEnum {
         }
     }
 
+    /**
+     * 'ByMetadataInserted' variant
+     */
+    public class ByMetadataInserted : TriggerEventFilter() {
+        override fun discriminant(): Int = DISCRIMINANT
+
+        public companion object :
+            ScaleReader<jp.co.soramitsu.iroha2.generated.TriggerEventFilter.ByMetadataInserted>,
+            ScaleWriter<jp.co.soramitsu.iroha2.generated.TriggerEventFilter.ByMetadataInserted> {
+            public const val DISCRIMINANT: Int = 4
+
+            override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEventFilter.ByMetadataInserted = try {
+                ByMetadataInserted()
+            } catch (ex: Exception) {
+                throw wrapException(ex)
+            }
+
+            override fun write(
+                writer: ScaleCodecWriter,
+                instance: jp.co.soramitsu.iroha2.generated.TriggerEventFilter.ByMetadataInserted,
+            ): Unit =
+                try {
+                } catch (ex: Exception) {
+                    throw wrapException(ex)
+                }
+
+            public fun equals(
+                o1: jp.co.soramitsu.iroha2.generated.TriggerEventFilter.ByMetadataInserted,
+                o2: Any?,
+            ): Boolean = when (o2) {
+                null -> false
+                else -> o2::class == o1::class
+            }
+
+            override fun hashCode(): Int = ".TriggerEventFilter.ByMetadataInserted".hashCode()
+        }
+    }
+
+    /**
+     * 'ByMetadataRemoved' variant
+     */
+    public class ByMetadataRemoved : TriggerEventFilter() {
+        override fun discriminant(): Int = DISCRIMINANT
+
+        public companion object :
+            ScaleReader<jp.co.soramitsu.iroha2.generated.TriggerEventFilter.ByMetadataRemoved>,
+            ScaleWriter<jp.co.soramitsu.iroha2.generated.TriggerEventFilter.ByMetadataRemoved> {
+            public const val DISCRIMINANT: Int = 5
+
+            override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEventFilter.ByMetadataRemoved = try {
+                ByMetadataRemoved()
+            } catch (ex: Exception) {
+                throw wrapException(ex)
+            }
+
+            override fun write(
+                writer: ScaleCodecWriter,
+                instance: jp.co.soramitsu.iroha2.generated.TriggerEventFilter.ByMetadataRemoved,
+            ): Unit =
+                try {
+                } catch (ex: Exception) {
+                    throw wrapException(ex)
+                }
+
+            public fun equals(
+                o1: jp.co.soramitsu.iroha2.generated.TriggerEventFilter.ByMetadataRemoved,
+                o2: Any?,
+            ): Boolean = when (o2) {
+                null -> false
+                else -> o2::class == o1::class
+            }
+
+            override fun hashCode(): Int = ".TriggerEventFilter.ByMetadataRemoved".hashCode()
+        }
+    }
+
     public companion object : ScaleReader<TriggerEventFilter>, ScaleWriter<TriggerEventFilter> {
         override fun read(reader: ScaleCodecReader): TriggerEventFilter = when (
             val discriminant =
@@ -196,6 +276,8 @@ public sealed class TriggerEventFilter : ModelEnum {
             1 -> ByDeleted.read(reader)
             2 -> ByExtended.read(reader)
             3 -> ByShortened.read(reader)
+            4 -> ByMetadataInserted.read(reader)
+            5 -> ByMetadataRemoved.read(reader)
             else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") }
 
         override fun write(writer: ScaleCodecWriter, instance: TriggerEventFilter) {
@@ -205,6 +287,8 @@ public sealed class TriggerEventFilter : ModelEnum {
                 1 -> ByDeleted.write(writer, instance as ByDeleted)
                 2 -> ByExtended.write(writer, instance as ByExtended)
                 3 -> ByShortened.write(writer, instance as ByShortened)
+                4 -> ByMetadataInserted.write(writer, instance as ByMetadataInserted)
+                5 -> ByMetadataRemoved.write(writer, instance as ByMetadataRemoved)
                 else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") }
         }
     }

diff --git a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaContainer.kt b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaContainer.kt
@@ -155,7 +155,7 @@ open class IrohaContainer : GenericContainer<IrohaContainer> {
         }.let { DockerImageName.parse(it) }
 
         const val NETWORK_ALIAS = "iroha"
-        const val DEFAULT_IMAGE_TAG = "sha256:b71e3ac42aeace89483eeadcded35cc6f982d4d9b48c002dd425f8dbaf669374"
+        const val DEFAULT_IMAGE_TAG = "sha256:cb9aefba9a2c56c40bdb84c4438c27c9769c1e2f56f1caa624f3561b19c0c2c4"
         const val DEFAULT_IMAGE_NAME = "hyperledger/iroha2"
         const val DEFAULT_EXECUTOR_FILE_NAME = "executor.wasm"
         const val DEFAULT_GENESIS_FILE_NAME = "genesis.json"