diff --git a/docker-compose/docker-compose.yaml b/docker-compose/docker-compose.yaml index 00f76bccb..0f9005c0a 100644 --- a/docker-compose/docker-compose.yaml +++ b/docker-compose/docker-compose.yaml @@ -1,6 +1,6 @@ services: irohad0: - image: hyperledger/iroha:dev + image: hyperledger/iroha:2.0.0-rc.1.0 platform: linux/amd64 environment: CHAIN: 00000000-0000-0000-0000-000000000000 @@ -46,7 +46,7 @@ services: exec irohad " irohad1: - image: hyperledger/iroha:dev + image: hyperledger/iroha:2.0.0-rc.1.0 platform: linux/amd64 environment: CHAIN: 00000000-0000-0000-0000-000000000000 @@ -70,7 +70,7 @@ services: retries: 30 start_period: 4s irohad2: - image: hyperledger/iroha:dev + image: hyperledger/iroha:2.0.0-rc.1.0 platform: linux/amd64 environment: CHAIN: 00000000-0000-0000-0000-000000000000 @@ -94,7 +94,7 @@ services: retries: 30 start_period: 4s irohad3: - image: hyperledger/iroha:dev + image: hyperledger/iroha:2.0.0-rc.1.0 platform: linux/amd64 environment: CHAIN: 00000000-0000-0000-0000-000000000000 diff --git a/modules/block/src/test/resources/executor.wasm b/modules/block/src/test/resources/executor.wasm index f7aa34b22..11cc0f19f 100644 Binary files a/modules/block/src/test/resources/executor.wasm and b/modules/block/src/test/resources/executor.wasm differ 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 index 12560a8fe..ad4722e3b 100755 Binary files a/modules/client/src/test/resources/create_nft_for_alice_smartcontract.wasm and b/modules/client/src/test/resources/create_nft_for_alice_smartcontract.wasm differ diff --git a/modules/client/src/test/resources/create_nft_for_alice_smartcontract/Cargo.toml b/modules/client/src/test/resources/create_nft_for_alice_smartcontract/Cargo.toml index 0b6abc4c5..1a51f2a41 100644 --- a/modules/client/src/test/resources/create_nft_for_alice_smartcontract/Cargo.toml +++ b/modules/client/src/test/resources/create_nft_for_alice_smartcontract/Cargo.toml @@ -28,7 +28,7 @@ opt-level = "z" # Optimize for size vs speed with "s"/"z"(removes vectorizat codegen-units = 1 # Further reduces binary size but increases compilation time [dependencies] -iroha_trigger = { git = "https://github.com/hyperledger/iroha/", branch = "2.0.0-rc.1", features = ["debug"] } +iroha_trigger = { git = "https://github.com/hyperledger/iroha/", tag = "v2.0.0-rc.1.0", features = ["debug"] } dlmalloc = { version = "0.2.6", features = ["global"] } panic-halt = "0.2.0" diff --git a/modules/client/src/test/resources/executor.wasm b/modules/client/src/test/resources/executor.wasm index f7aa34b22..11cc0f19f 100644 Binary files a/modules/client/src/test/resources/executor.wasm and b/modules/client/src/test/resources/executor.wasm differ diff --git a/modules/client/src/test/resources/executor/Cargo.toml b/modules/client/src/test/resources/executor/Cargo.toml index 544739c2b..57d45af29 100644 --- a/modules/client/src/test/resources/executor/Cargo.toml +++ b/modules/client/src/test/resources/executor/Cargo.toml @@ -22,7 +22,7 @@ opt-level = "z" # Optimize for size vs speed with "s"/"z"(removes vectorizat codegen-units = 1 # Further reduces binary size but increases compilation time [dependencies] -iroha_executor = { git = "https://github.com/hyperledger/iroha/", branch = "2.0.0-rc.1", features = ["debug"] } +iroha_executor = { git = "https://github.com/hyperledger/iroha/", tag = "v2.0.0-rc.1.0", features = ["debug"] } dlmalloc = { version = "0.2.6", features = ["global"] } panic-halt = "0.2.0" diff --git a/modules/codegen/src/main/resources/schema.json b/modules/codegen/src/main/resources/schema.json index 6b47e7fa1..85751191e 100644 --- a/modules/codegen/src/main/resources/schema.json +++ b/modules/codegen/src/main/resources/schema.json @@ -261,6 +261,36 @@ } ] }, + "ActionPredicateAtom": { + "Enum": [] + }, + "ActionProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "ActionPredicateAtom" + }, + { + "tag": "Metadata", + "discriminant": 1, + "type": "MetadataProjection" + } + ] + }, + "ActionProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Metadata", + "discriminant": 1, + "type": "MetadataProjection" + } + ] + }, "Algorithm": { "Enum": [ { @@ -780,7 +810,16 @@ ] }, "AssetValuePredicateAtom": { - "Enum": [] + "Enum": [ + { + "tag": "IsNumeric", + "discriminant": 0 + }, + { + "tag": "IsStore", + "discriminant": 1 + } + ] }, "AssetValueProjection": { "Enum": [ @@ -788,6 +827,16 @@ "tag": "Atom", "discriminant": 0, "type": "AssetValuePredicateAtom" + }, + { + "tag": "Numeric", + "discriminant": 1, + "type": "NumericProjection" + }, + { + "tag": "Store", + "discriminant": 2, + "type": "MetadataProjection" } ] }, @@ -796,6 +845,16 @@ { "tag": "Atom", "discriminant": 0 + }, + { + "tag": "Numeric", + "discriminant": 1, + "type": "NumericProjection" + }, + { + "tag": "Store", + "discriminant": 2, + "type": "MetadataProjection" } ] }, @@ -2130,18 +2189,6 @@ } ] }, - "FindAccountMetadata": { - "Struct": [ - { - "name": "id", - "type": "AccountId" - }, - { - "name": "key", - "type": "Name" - } - ] - }, "FindAccounts": null, "FindAccountsWithAsset": { "Struct": [ @@ -2152,54 +2199,10 @@ ] }, "FindActiveTriggerIds": null, - "FindAssetDefinitionMetadata": { - "Struct": [ - { - "name": "id", - "type": "AssetDefinitionId" - }, - { - "name": "key", - "type": "Name" - } - ] - }, - "FindAssetMetadata": { - "Struct": [ - { - "name": "id", - "type": "AssetId" - }, - { - "name": "key", - "type": "Name" - } - ] - }, - "FindAssetQuantityById": { - "Struct": [ - { - "name": "id", - "type": "AssetId" - } - ] - }, "FindAssets": null, "FindAssetsDefinitions": null, "FindBlockHeaders": null, "FindBlocks": null, - "FindDomainMetadata": { - "Struct": [ - { - "name": "id", - "type": "DomainId" - }, - { - "name": "key", - "type": "Name" - } - ] - }, "FindDomains": null, "FindError": { "Enum": [ @@ -2287,18 +2290,6 @@ ] }, "FindTransactions": null, - "FindTriggerMetadata": { - "Struct": [ - { - "name": "id", - "type": "TriggerId" - }, - { - "name": "key", - "type": "Name" - } - ] - }, "FindTriggers": null, "ForwardCursor": { "Struct": [ @@ -2684,6 +2675,32 @@ "Ipv4Addr": "Array", "Ipv6Addr": "Array", "Json": "String", + "JsonPredicateAtom": { + "Enum": [ + { + "tag": "Equals", + "discriminant": 0, + "type": "Json" + } + ] + }, + "JsonProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "JsonPredicateAtom" + } + ] + }, + "JsonProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + } + ] + }, "Level": { "Enum": [ { @@ -2837,6 +2854,30 @@ } ] }, + "MetadataKeyProjection": { + "Struct": [ + { + "name": "key", + "type": "Name" + }, + { + "name": "projection", + "type": "JsonProjection" + } + ] + }, + "MetadataKeyProjection": { + "Struct": [ + { + "name": "key", + "type": "Name" + }, + { + "name": "projection", + "type": "JsonProjection" + } + ] + }, "MetadataPredicateAtom": { "Enum": [] }, @@ -2846,6 +2887,11 @@ "tag": "Atom", "discriminant": 0, "type": "MetadataPredicateAtom" + }, + { + "tag": "Key", + "discriminant": 1, + "type": "MetadataKeyProjection" } ] }, @@ -2854,6 +2900,11 @@ { "tag": "Atom", "discriminant": 0 + }, + { + "tag": "Key", + "discriminant": 1, + "type": "MetadataKeyProjection" } ] }, @@ -3131,6 +3182,26 @@ } ] }, + "NumericPredicateAtom": { + "Enum": [] + }, + "NumericProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "NumericPredicateAtom" + } + ] + }, + "NumericProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + } + ] + }, "NumericSpec": { "Struct": [ { @@ -3634,123 +3705,138 @@ "type": "Vec" }, { - "tag": "Name", + "tag": "Json", "discriminant": 3, + "type": "Vec" + }, + { + "tag": "Numeric", + "discriminant": 4, + "type": "Vec" + }, + { + "tag": "Name", + "discriminant": 5, "type": "Vec" }, { "tag": "DomainId", - "discriminant": 4, + "discriminant": 6, "type": "Vec" }, { "tag": "Domain", - "discriminant": 5, + "discriminant": 7, "type": "Vec" }, { "tag": "AccountId", - "discriminant": 6, + "discriminant": 8, "type": "Vec" }, { "tag": "Account", - "discriminant": 7, + "discriminant": 9, "type": "Vec" }, { "tag": "AssetId", - "discriminant": 8, + "discriminant": 10, "type": "Vec" }, { "tag": "Asset", - "discriminant": 9, + "discriminant": 11, "type": "Vec" }, { "tag": "AssetValue", - "discriminant": 10, + "discriminant": 12, "type": "Vec" }, { "tag": "AssetDefinitionId", - "discriminant": 11, + "discriminant": 13, "type": "Vec" }, { "tag": "AssetDefinition", - "discriminant": 12, + "discriminant": 14, "type": "Vec" }, { "tag": "Role", - "discriminant": 13, + "discriminant": 15, "type": "Vec" }, { "tag": "Parameter", - "discriminant": 14, + "discriminant": 16, "type": "Vec" }, { "tag": "Permission", - "discriminant": 15, + "discriminant": 17, "type": "Vec" }, { "tag": "CommittedTransaction", - "discriminant": 16, + "discriminant": 18, "type": "Vec" }, { "tag": "SignedTransaction", - "discriminant": 17, + "discriminant": 19, "type": "Vec" }, { "tag": "TransactionHash", - "discriminant": 18, + "discriminant": 20, "type": "Vec>" }, { "tag": "TransactionRejectionReason", - "discriminant": 19, + "discriminant": 21, "type": "Vec>" }, { "tag": "Peer", - "discriminant": 20, + "discriminant": 22, "type": "Vec" }, { "tag": "RoleId", - "discriminant": 21, + "discriminant": 23, "type": "Vec" }, { "tag": "TriggerId", - "discriminant": 22, + "discriminant": 24, "type": "Vec" }, { "tag": "Trigger", - "discriminant": 23, + "discriminant": 25, "type": "Vec" }, + { + "tag": "Action", + "discriminant": 26, + "type": "Vec" + }, { "tag": "Block", - "discriminant": 24, + "discriminant": 27, "type": "Vec" }, { "tag": "BlockHeader", - "discriminant": 25, + "discriminant": 28, "type": "Vec" }, { "tag": "BlockHeaderHash", - "discriminant": 26, + "discriminant": 29, "type": "Vec>" } ] @@ -4815,84 +4901,29 @@ }, "SingularQueryBox": { "Enum": [ - { - "tag": "FindAssetQuantityById", - "discriminant": 0, - "type": "FindAssetQuantityById" - }, { "tag": "FindExecutorDataModel", - "discriminant": 1, + "discriminant": 0, "type": "FindExecutorDataModel" }, { "tag": "FindParameters", - "discriminant": 2, + "discriminant": 1, "type": "FindParameters" - }, - { - "tag": "FindDomainMetadata", - "discriminant": 3, - "type": "FindDomainMetadata" - }, - { - "tag": "FindAccountMetadata", - "discriminant": 4, - "type": "FindAccountMetadata" - }, - { - "tag": "FindAssetMetadata", - "discriminant": 5, - "type": "FindAssetMetadata" - }, - { - "tag": "FindAssetDefinitionMetadata", - "discriminant": 6, - "type": "FindAssetDefinitionMetadata" - }, - { - "tag": "FindTriggerMetadata", - "discriminant": 7, - "type": "FindTriggerMetadata" } ] }, "SingularQueryOutputBox": { "Enum": [ - { - "tag": "Numeric", - "discriminant": 0, - "type": "Numeric" - }, { "tag": "ExecutorDataModel", - "discriminant": 1, + "discriminant": 0, "type": "ExecutorDataModel" }, - { - "tag": "Json", - "discriminant": 2, - "type": "Json" - }, - { - "tag": "Trigger", - "discriminant": 3, - "type": "Trigger" - }, { "tag": "Parameters", - "discriminant": 4, + "discriminant": 1, "type": "Parameters" - }, - { - "tag": "Transaction", - "discriminant": 5, - "type": "CommittedTransaction" - }, - { - "tag": "BlockHeader", - "discriminant": 6, - "type": "BlockHeader" } ] }, @@ -5590,6 +5621,11 @@ "tag": "Id", "discriminant": 1, "type": "TriggerIdProjection" + }, + { + "tag": "Action", + "discriminant": 2, + "type": "ActionProjection" } ] }, @@ -5603,6 +5639,11 @@ "tag": "Id", "discriminant": 1, "type": "TriggerIdProjection" + }, + { + "tag": "Action", + "discriminant": 2, + "type": "ActionProjection" } ] }, @@ -5759,6 +5800,9 @@ "Vec>": { "Vec": "AccountProjection" }, + "Vec": { + "Vec": "Action" + }, "Vec": { "Vec": "Asset" }, @@ -5858,12 +5902,18 @@ "Vec": { "Vec": "InstructionBox" }, + "Vec": { + "Vec": "Json" + }, "Vec": { "Vec": "Metadata" }, "Vec": { "Vec": "Name" }, + "Vec": { + "Vec": "Numeric" + }, "Vec>": { "Vec": "Option" }, diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionPredicateAtom.kt new file mode 100644 index 000000000..eff81a321 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionPredicateAtom.kt @@ -0,0 +1,36 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +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 kotlin.Int + +/** + * ActionPredicateAtom + * + * Generated from 'ActionPredicateAtom' enum + */ +public sealed class ActionPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): ActionPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: ActionPredicateAtom) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..160d44f8e --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfPredicateMarker.kt @@ -0,0 +1,105 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +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.Int +import kotlin.Unit + +/** + * ActionProjectionOfPredicateMarker + * + * Generated from 'ActionProjectionOfPredicateMarker' enum + */ +public sealed class ActionProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val actionPredicateAtom: ActionPredicateAtom) : ActionProjectionOfPredicateMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 0 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ActionProjectionOfPredicateMarker.Atom = try { + Atom( + ActionPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.ActionProjectionOfPredicateMarker.Atom, + ): Unit = try { + ActionPredicateAtom.write(writer, instance.actionPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Metadata' variant + */ + public data class Metadata(public val metadataProjectionOfPredicateMarker: MetadataProjectionOfPredicateMarker) : + ActionProjectionOfPredicateMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 1 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ActionProjectionOfPredicateMarker.Metadata = try { + Metadata( + MetadataProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.ActionProjectionOfPredicateMarker.Metadata, + ): Unit = try { + MetadataProjectionOfPredicateMarker.write(writer, instance.metadataProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): ActionProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Metadata.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: ActionProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Metadata.write(writer, instance as Metadata) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..9b12a6375 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfSelectorMarker.kt @@ -0,0 +1,121 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +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.Any +import kotlin.Boolean +import kotlin.Int +import kotlin.Unit + +/** + * ActionProjectionOfSelectorMarker + * + * Generated from 'ActionProjectionOfSelectorMarker' enum + */ +public sealed class ActionProjectionOfSelectorMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + override fun equals(other: Any?): Boolean = when (this) { + is Atom -> Atom.equals(this, other) + else -> super.equals(other) + } + + override fun hashCode(): Int = when (this) { + is Atom -> Atom.hashCode() + else -> super.hashCode() + } + + /** + * 'Atom' variant + */ + public class Atom : ActionProjectionOfSelectorMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 0 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ActionProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.ActionProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.ActionProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".ActionProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Metadata' variant + */ + public data class Metadata(public val metadataProjectionOfSelectorMarker: MetadataProjectionOfSelectorMarker) : + ActionProjectionOfSelectorMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 1 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ActionProjectionOfSelectorMarker.Metadata = try { + Metadata( + MetadataProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.ActionProjectionOfSelectorMarker.Metadata, + ): Unit = try { + MetadataProjectionOfSelectorMarker.write(writer, instance.metadataProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): ActionProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Metadata.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: ActionProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Metadata.write(writer, instance as Metadata) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValuePredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValuePredicateAtom.kt index ec36e4790..55bf945b4 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValuePredicateAtom.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValuePredicateAtom.kt @@ -8,7 +8,11 @@ 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.Any +import kotlin.Boolean import kotlin.Int +import kotlin.Unit /** * AssetValuePredicateAtom @@ -21,16 +25,98 @@ public sealed class AssetValuePredicateAtom : ModelEnum { */ public abstract fun discriminant(): Int + override fun equals(other: Any?): Boolean = when (this) { + is IsNumeric -> IsNumeric.equals(this, other) + is IsStore -> IsStore.equals(this, other) + else -> super.equals(other) + } + + override fun hashCode(): Int = when (this) { + is IsNumeric -> IsNumeric.hashCode() + is IsStore -> IsStore.hashCode() + else -> super.hashCode() + } + + /** + * 'IsNumeric' variant + */ + public class IsNumeric : AssetValuePredicateAtom() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 0 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetValuePredicateAtom.IsNumeric = try { + IsNumeric() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetValuePredicateAtom.IsNumeric, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.AssetValuePredicateAtom.IsNumeric, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".AssetValuePredicateAtom.IsNumeric".hashCode() + } + } + + /** + * 'IsStore' variant + */ + public class IsStore : AssetValuePredicateAtom() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 1 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetValuePredicateAtom.IsStore = try { + IsStore() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetValuePredicateAtom.IsStore): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.AssetValuePredicateAtom.IsStore, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".AssetValuePredicateAtom.IsStore".hashCode() + } + } + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): AssetValuePredicateAtom = when (val discriminant = reader.readUByte()) { + 0 -> IsNumeric.read(reader) + 1 -> IsStore.read(reader) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } override fun write(writer: ScaleCodecWriter, instance: AssetValuePredicateAtom) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { + 0 -> IsNumeric.write(writer, instance as IsNumeric) + 1 -> IsStore.write(writer, instance as IsStore) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValueProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValueProjectionOfPredicateMarker.kt index 7462a68a8..50daba8dc 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValueProjectionOfPredicateMarker.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValueProjectionOfPredicateMarker.kt @@ -53,11 +53,77 @@ public sealed class AssetValueProjectionOfPredicateMarker : ModelEnum { } } + /** + * 'Numeric' variant + */ + public data class Numeric(public val numericProjectionOfPredicateMarker: NumericProjectionOfPredicateMarker) : + AssetValueProjectionOfPredicateMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 1 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetValueProjectionOfPredicateMarker.Numeric = + try { + Numeric( + NumericProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetValueProjectionOfPredicateMarker.Numeric, + ): Unit = try { + NumericProjectionOfPredicateMarker.write(writer, instance.numericProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Store' variant + */ + public data class Store(public val metadataProjectionOfPredicateMarker: MetadataProjectionOfPredicateMarker) : + AssetValueProjectionOfPredicateMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 2 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetValueProjectionOfPredicateMarker.Store = + try { + Store( + MetadataProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetValueProjectionOfPredicateMarker.Store, + ): Unit = try { + MetadataProjectionOfPredicateMarker.write(writer, instance.metadataProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): AssetValueProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) + 1 -> Numeric.read(reader) + 2 -> Store.read(reader) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } @@ -65,6 +131,8 @@ public sealed class AssetValueProjectionOfPredicateMarker : ModelEnum { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) + 1 -> Numeric.write(writer, instance as Numeric) + 2 -> Store.write(writer, instance as Store) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValueProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValueProjectionOfSelectorMarker.kt index 589cdd46b..afcad4b20 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValueProjectionOfSelectorMarker.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValueProjectionOfSelectorMarker.kt @@ -70,11 +70,76 @@ public sealed class AssetValueProjectionOfSelectorMarker : ModelEnum { } } + /** + * 'Numeric' variant + */ + public data class Numeric(public val numericProjectionOfSelectorMarker: NumericProjectionOfSelectorMarker) : + AssetValueProjectionOfSelectorMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 1 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetValueProjectionOfSelectorMarker.Numeric = + try { + Numeric( + NumericProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetValueProjectionOfSelectorMarker.Numeric, + ): Unit = try { + NumericProjectionOfSelectorMarker.write(writer, instance.numericProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Store' variant + */ + public data class Store(public val metadataProjectionOfSelectorMarker: MetadataProjectionOfSelectorMarker) : + AssetValueProjectionOfSelectorMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 2 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetValueProjectionOfSelectorMarker.Store = try { + Store( + MetadataProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetValueProjectionOfSelectorMarker.Store, + ): Unit = try { + MetadataProjectionOfSelectorMarker.write(writer, instance.metadataProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): AssetValueProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) + 1 -> Numeric.read(reader) + 2 -> Store.read(reader) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } @@ -82,6 +147,8 @@ public sealed class AssetValueProjectionOfSelectorMarker : ModelEnum { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) + 1 -> Numeric.write(writer, instance as Numeric) + 2 -> Store.write(writer, instance as Store) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonPredicateAtom.kt new file mode 100644 index 000000000..b343a7440 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonPredicateAtom.kt @@ -0,0 +1,67 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +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.Int +import kotlin.Unit + +/** + * JsonPredicateAtom + * + * Generated from 'JsonPredicateAtom' enum + */ +public sealed class JsonPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Equals' variant + */ + public data class Equals(public val json: Json) : JsonPredicateAtom() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 0 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.JsonPredicateAtom.Equals = try { + Equals( + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.JsonPredicateAtom.Equals): Unit = try { + Json.write(writer, instance.json) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): JsonPredicateAtom = when (val discriminant = reader.readUByte()) { + 0 -> Equals.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: JsonPredicateAtom) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Equals.write(writer, instance as Equals) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..da8287701 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfPredicateMarker.kt @@ -0,0 +1,72 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +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.Int +import kotlin.Unit + +/** + * JsonProjectionOfPredicateMarker + * + * Generated from 'JsonProjectionOfPredicateMarker' enum + */ +public sealed class JsonProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val jsonPredicateAtom: JsonPredicateAtom) : JsonProjectionOfPredicateMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 0 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.JsonProjectionOfPredicateMarker.Atom = try { + Atom( + JsonPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.JsonProjectionOfPredicateMarker.Atom, + ): Unit = try { + JsonPredicateAtom.write(writer, instance.jsonPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): JsonProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: JsonProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..7c9c8c987 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfSelectorMarker.kt @@ -0,0 +1,88 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +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.Any +import kotlin.Boolean +import kotlin.Int +import kotlin.Unit + +/** + * JsonProjectionOfSelectorMarker + * + * Generated from 'JsonProjectionOfSelectorMarker' enum + */ +public sealed class JsonProjectionOfSelectorMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + override fun equals(other: Any?): Boolean = when (this) { + is Atom -> Atom.equals(this, other) + else -> super.equals(other) + } + + override fun hashCode(): Int = when (this) { + is Atom -> Atom.hashCode() + else -> super.hashCode() + } + + /** + * 'Atom' variant + */ + public class Atom : JsonProjectionOfSelectorMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 0 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.JsonProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.JsonProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.JsonProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".JsonProjectionOfSelectorMarker.Atom".hashCode() + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): JsonProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: JsonProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataKeyProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataKeyProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..3d53f1979 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataKeyProjectionOfPredicateMarker.kt @@ -0,0 +1,38 @@ +// +// 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 + +/** + * MetadataKeyProjectionOfPredicateMarker + * + * Generated from 'MetadataKeyProjectionOfPredicateMarker' regular structure + */ +public data class MetadataKeyProjectionOfPredicateMarker(public val key: Name, public val projection: JsonProjectionOfPredicateMarker) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): MetadataKeyProjectionOfPredicateMarker = try { + MetadataKeyProjectionOfPredicateMarker( + Name.read(reader), + JsonProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: MetadataKeyProjectionOfPredicateMarker): Unit = try { + Name.write(writer, instance.key) + JsonProjectionOfPredicateMarker.write(writer, instance.projection) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataKeyProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataKeyProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..8e8841773 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataKeyProjectionOfSelectorMarker.kt @@ -0,0 +1,38 @@ +// +// 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 + +/** + * MetadataKeyProjectionOfSelectorMarker + * + * Generated from 'MetadataKeyProjectionOfSelectorMarker' regular structure + */ +public data class MetadataKeyProjectionOfSelectorMarker(public val key: Name, public val projection: JsonProjectionOfSelectorMarker) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): MetadataKeyProjectionOfSelectorMarker = try { + MetadataKeyProjectionOfSelectorMarker( + Name.read(reader), + JsonProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: MetadataKeyProjectionOfSelectorMarker): Unit = try { + Name.write(writer, instance.key) + JsonProjectionOfSelectorMarker.write(writer, instance.projection) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataProjectionOfPredicateMarker.kt index faa0cfd9e..f0bb49659 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataProjectionOfPredicateMarker.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataProjectionOfPredicateMarker.kt @@ -53,11 +53,43 @@ public sealed class MetadataProjectionOfPredicateMarker : ModelEnum { } } + /** + * 'Key' variant + */ + public data class Key(public val metadataKeyProjectionOfPredicateMarker: MetadataKeyProjectionOfPredicateMarker) : + MetadataProjectionOfPredicateMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 1 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MetadataProjectionOfPredicateMarker.Key = try { + Key( + MetadataKeyProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.MetadataProjectionOfPredicateMarker.Key, + ): Unit = try { + MetadataKeyProjectionOfPredicateMarker.write(writer, instance.metadataKeyProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): MetadataProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) + 1 -> Key.read(reader) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } @@ -65,6 +97,7 @@ public sealed class MetadataProjectionOfPredicateMarker : ModelEnum { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) + 1 -> Key.write(writer, instance as Key) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataProjectionOfSelectorMarker.kt index 7645cee4f..81fc8ae24 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataProjectionOfSelectorMarker.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataProjectionOfSelectorMarker.kt @@ -69,11 +69,43 @@ public sealed class MetadataProjectionOfSelectorMarker : ModelEnum { } } + /** + * 'Key' variant + */ + public data class Key(public val metadataKeyProjectionOfSelectorMarker: MetadataKeyProjectionOfSelectorMarker) : + MetadataProjectionOfSelectorMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 1 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MetadataProjectionOfSelectorMarker.Key = try { + Key( + MetadataKeyProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.MetadataProjectionOfSelectorMarker.Key, + ): Unit = try { + MetadataKeyProjectionOfSelectorMarker.write(writer, instance.metadataKeyProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): MetadataProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) + 1 -> Key.read(reader) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } @@ -81,6 +113,7 @@ public sealed class MetadataProjectionOfSelectorMarker : ModelEnum { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) + 1 -> Key.write(writer, instance as Key) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericPredicateAtom.kt new file mode 100644 index 000000000..aebf3e160 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericPredicateAtom.kt @@ -0,0 +1,36 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +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 kotlin.Int + +/** + * NumericPredicateAtom + * + * Generated from 'NumericPredicateAtom' enum + */ +public sealed class NumericPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): NumericPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: NumericPredicateAtom) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..0070eade0 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericProjectionOfPredicateMarker.kt @@ -0,0 +1,72 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +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.Int +import kotlin.Unit + +/** + * NumericProjectionOfPredicateMarker + * + * Generated from 'NumericProjectionOfPredicateMarker' enum + */ +public sealed class NumericProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val numericPredicateAtom: NumericPredicateAtom) : NumericProjectionOfPredicateMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 0 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.NumericProjectionOfPredicateMarker.Atom = try { + Atom( + NumericPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.NumericProjectionOfPredicateMarker.Atom, + ): Unit = try { + NumericPredicateAtom.write(writer, instance.numericPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): NumericProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: NumericProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..d245e05fd --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericProjectionOfSelectorMarker.kt @@ -0,0 +1,88 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +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.Any +import kotlin.Boolean +import kotlin.Int +import kotlin.Unit + +/** + * NumericProjectionOfSelectorMarker + * + * Generated from 'NumericProjectionOfSelectorMarker' enum + */ +public sealed class NumericProjectionOfSelectorMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + override fun equals(other: Any?): Boolean = when (this) { + is Atom -> Atom.equals(this, other) + else -> super.equals(other) + } + + override fun hashCode(): Int = when (this) { + is Atom -> Atom.hashCode() + else -> super.hashCode() + } + + /** + * 'Atom' variant + */ + public class Atom : NumericProjectionOfSelectorMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 0 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.NumericProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.NumericProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.NumericProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".NumericProjectionOfSelectorMarker.Atom".hashCode() + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): NumericProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: NumericProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputBatchBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputBatchBox.kt index 322f86808..6659c2161 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputBatchBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputBatchBox.kt @@ -117,6 +117,67 @@ public sealed class QueryOutputBatchBox : ModelEnum { } } + /** + * 'Json' variant + */ + public data class Json(public val vec: List) : QueryOutputBatchBox() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 3 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Json = try { + Json( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Json.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Json): Unit = try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.Json.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Numeric' variant + */ + public data class Numeric(public val vec: List) : QueryOutputBatchBox() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 4 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Numeric = try { + Numeric( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Numeric.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Numeric): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.Numeric.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + /** * 'Name' variant */ @@ -126,7 +187,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 3 + public const val DISCRIMINANT: Int = 5 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Name = try { Name( @@ -156,7 +217,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 4 + public const val DISCRIMINANT: Int = 6 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.DomainId = try { DomainId( @@ -187,7 +248,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 5 + public const val DISCRIMINANT: Int = 7 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Domain = try { Domain( @@ -218,7 +279,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 6 + public const val DISCRIMINANT: Int = 8 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AccountId = try { AccountId( @@ -249,7 +310,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 7 + public const val DISCRIMINANT: Int = 9 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Account = try { Account( @@ -280,7 +341,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 8 + public const val DISCRIMINANT: Int = 10 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetId = try { AssetId( @@ -311,7 +372,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 9 + public const val DISCRIMINANT: Int = 11 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Asset = try { Asset( @@ -341,7 +402,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 10 + public const val DISCRIMINANT: Int = 12 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetValue = try { AssetValue( @@ -372,7 +433,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 11 + public const val DISCRIMINANT: Int = 13 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetDefinitionId = try { AssetDefinitionId( @@ -405,7 +466,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 12 + public const val DISCRIMINANT: Int = 14 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetDefinition = try { AssetDefinition( @@ -438,7 +499,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 13 + public const val DISCRIMINANT: Int = 15 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Role = try { Role( @@ -468,7 +529,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 14 + public const val DISCRIMINANT: Int = 16 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Parameter = try { Parameter( @@ -499,7 +560,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 15 + public const val DISCRIMINANT: Int = 17 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Permission = try { Permission( @@ -531,7 +592,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 16 + public const val DISCRIMINANT: Int = 18 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.CommittedTransaction = try { CommittedTransaction( @@ -564,7 +625,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 17 + public const val DISCRIMINANT: Int = 19 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.SignedTransaction = try { SignedTransaction( @@ -598,7 +659,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 18 + public const val DISCRIMINANT: Int = 20 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.TransactionHash = try { TransactionHash( @@ -634,7 +695,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 19 + public const val DISCRIMINANT: Int = 21 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.TransactionRejectionReason = try { @@ -672,7 +733,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 20 + public const val DISCRIMINANT: Int = 22 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Peer = try { Peer( @@ -702,7 +763,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 21 + public const val DISCRIMINANT: Int = 23 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.RoleId = try { RoleId( @@ -733,7 +794,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 22 + public const val DISCRIMINANT: Int = 24 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.TriggerId = try { TriggerId( @@ -764,7 +825,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 23 + public const val DISCRIMINANT: Int = 25 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Trigger = try { Trigger( @@ -786,6 +847,37 @@ public sealed class QueryOutputBatchBox : ModelEnum { } } + /** + * 'Action' variant + */ + public data class Action(public val vec: List) : QueryOutputBatchBox() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 26 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Action = try { + Action( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Action.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Action): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.Action.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + /** * 'Block' variant */ @@ -795,7 +887,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 24 + public const val DISCRIMINANT: Int = 27 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Block = try { Block( @@ -825,7 +917,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 25 + public const val DISCRIMINANT: Int = 28 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.BlockHeader = try { BlockHeader( @@ -856,7 +948,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 26 + public const val DISCRIMINANT: Int = 29 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.BlockHeaderHash = try { BlockHeaderHash( @@ -885,30 +977,33 @@ public sealed class QueryOutputBatchBox : ModelEnum { 0 -> PublicKey.read(reader) 1 -> String.read(reader) 2 -> Metadata.read(reader) - 3 -> Name.read(reader) - 4 -> DomainId.read(reader) - 5 -> Domain.read(reader) - 6 -> AccountId.read(reader) - 7 -> Account.read(reader) - 8 -> AssetId.read(reader) - 9 -> Asset.read(reader) - 10 -> AssetValue.read(reader) - 11 -> AssetDefinitionId.read(reader) - 12 -> AssetDefinition.read(reader) - 13 -> Role.read(reader) - 14 -> Parameter.read(reader) - 15 -> Permission.read(reader) - 16 -> CommittedTransaction.read(reader) - 17 -> SignedTransaction.read(reader) - 18 -> TransactionHash.read(reader) - 19 -> TransactionRejectionReason.read(reader) - 20 -> Peer.read(reader) - 21 -> RoleId.read(reader) - 22 -> TriggerId.read(reader) - 23 -> Trigger.read(reader) - 24 -> Block.read(reader) - 25 -> BlockHeader.read(reader) - 26 -> BlockHeaderHash.read(reader) + 3 -> Json.read(reader) + 4 -> Numeric.read(reader) + 5 -> Name.read(reader) + 6 -> DomainId.read(reader) + 7 -> Domain.read(reader) + 8 -> AccountId.read(reader) + 9 -> Account.read(reader) + 10 -> AssetId.read(reader) + 11 -> Asset.read(reader) + 12 -> AssetValue.read(reader) + 13 -> AssetDefinitionId.read(reader) + 14 -> AssetDefinition.read(reader) + 15 -> Role.read(reader) + 16 -> Parameter.read(reader) + 17 -> Permission.read(reader) + 18 -> CommittedTransaction.read(reader) + 19 -> SignedTransaction.read(reader) + 20 -> TransactionHash.read(reader) + 21 -> TransactionRejectionReason.read(reader) + 22 -> Peer.read(reader) + 23 -> RoleId.read(reader) + 24 -> TriggerId.read(reader) + 25 -> Trigger.read(reader) + 26 -> Action.read(reader) + 27 -> Block.read(reader) + 28 -> BlockHeader.read(reader) + 29 -> BlockHeaderHash.read(reader) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } @@ -918,30 +1013,33 @@ public sealed class QueryOutputBatchBox : ModelEnum { 0 -> PublicKey.write(writer, instance as PublicKey) 1 -> String.write(writer, instance as String) 2 -> Metadata.write(writer, instance as Metadata) - 3 -> Name.write(writer, instance as Name) - 4 -> DomainId.write(writer, instance as DomainId) - 5 -> Domain.write(writer, instance as Domain) - 6 -> AccountId.write(writer, instance as AccountId) - 7 -> Account.write(writer, instance as Account) - 8 -> AssetId.write(writer, instance as AssetId) - 9 -> Asset.write(writer, instance as Asset) - 10 -> AssetValue.write(writer, instance as AssetValue) - 11 -> AssetDefinitionId.write(writer, instance as AssetDefinitionId) - 12 -> AssetDefinition.write(writer, instance as AssetDefinition) - 13 -> Role.write(writer, instance as Role) - 14 -> Parameter.write(writer, instance as Parameter) - 15 -> Permission.write(writer, instance as Permission) - 16 -> CommittedTransaction.write(writer, instance as CommittedTransaction) - 17 -> SignedTransaction.write(writer, instance as SignedTransaction) - 18 -> TransactionHash.write(writer, instance as TransactionHash) - 19 -> TransactionRejectionReason.write(writer, instance as TransactionRejectionReason) - 20 -> Peer.write(writer, instance as Peer) - 21 -> RoleId.write(writer, instance as RoleId) - 22 -> TriggerId.write(writer, instance as TriggerId) - 23 -> Trigger.write(writer, instance as Trigger) - 24 -> Block.write(writer, instance as Block) - 25 -> BlockHeader.write(writer, instance as BlockHeader) - 26 -> BlockHeaderHash.write(writer, instance as BlockHeaderHash) + 3 -> Json.write(writer, instance as Json) + 4 -> Numeric.write(writer, instance as Numeric) + 5 -> Name.write(writer, instance as Name) + 6 -> DomainId.write(writer, instance as DomainId) + 7 -> Domain.write(writer, instance as Domain) + 8 -> AccountId.write(writer, instance as AccountId) + 9 -> Account.write(writer, instance as Account) + 10 -> AssetId.write(writer, instance as AssetId) + 11 -> Asset.write(writer, instance as Asset) + 12 -> AssetValue.write(writer, instance as AssetValue) + 13 -> AssetDefinitionId.write(writer, instance as AssetDefinitionId) + 14 -> AssetDefinition.write(writer, instance as AssetDefinition) + 15 -> Role.write(writer, instance as Role) + 16 -> Parameter.write(writer, instance as Parameter) + 17 -> Permission.write(writer, instance as Permission) + 18 -> CommittedTransaction.write(writer, instance as CommittedTransaction) + 19 -> SignedTransaction.write(writer, instance as SignedTransaction) + 20 -> TransactionHash.write(writer, instance as TransactionHash) + 21 -> TransactionRejectionReason.write(writer, instance as TransactionRejectionReason) + 22 -> Peer.write(writer, instance as Peer) + 23 -> RoleId.write(writer, instance as RoleId) + 24 -> TriggerId.write(writer, instance as TriggerId) + 25 -> Trigger.write(writer, instance as Trigger) + 26 -> Action.write(writer, instance as Action) + 27 -> Block.write(writer, instance as Block) + 28 -> BlockHeader.write(writer, instance as BlockHeader) + 29 -> BlockHeaderHash.write(writer, instance as BlockHeaderHash) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetParameter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetParameter.kt index e638aa633..e4ce80e50 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetParameter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetParameter.kt @@ -8,6 +8,7 @@ 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.generated.InstructionBox import jp.co.soramitsu.iroha2.transaction.Instruction import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit @@ -19,6 +20,7 @@ import kotlin.Unit */ public data class SetParameter(public val parameter: Parameter) : Instruction { override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SetParameter = try { SetParameter( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SingularQueryBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SingularQueryBox.kt index 5f7770912..4442b6507 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SingularQueryBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SingularQueryBox.kt @@ -23,37 +23,6 @@ public sealed class SingularQueryBox : ModelEnum { */ public abstract fun discriminant(): Int - /** - * 'FindAssetQuantityById' variant - */ - public data class FindAssetQuantityById(public val findAssetQuantityById: jp.co.soramitsu.iroha2.generated.FindAssetQuantityById) : - SingularQueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 0 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindAssetQuantityById = try { - FindAssetQuantityById( - jp.co.soramitsu.iroha2.generated.FindAssetQuantityById.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindAssetQuantityById, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetQuantityById.write(writer, instance.findAssetQuantityById) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - /** * 'FindExecutorDataModel' variant */ @@ -64,7 +33,7 @@ public sealed class SingularQueryBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 1 + public const val DISCRIMINANT: Int = 0 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindExecutorDataModel = try { FindExecutorDataModel( @@ -94,7 +63,7 @@ public sealed class SingularQueryBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 2 + public const val DISCRIMINANT: Int = 1 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindParameters = try { FindParameters( @@ -113,187 +82,18 @@ public sealed class SingularQueryBox : ModelEnum { } } - /** - * 'FindDomainMetadata' variant - */ - public data class FindDomainMetadata(public val findDomainMetadata: jp.co.soramitsu.iroha2.generated.FindDomainMetadata) : - SingularQueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 3 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindDomainMetadata = try { - FindDomainMetadata( - jp.co.soramitsu.iroha2.generated.FindDomainMetadata.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindDomainMetadata, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindDomainMetadata.write(writer, instance.findDomainMetadata) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAccountMetadata' variant - */ - public data class FindAccountMetadata(public val findAccountMetadata: jp.co.soramitsu.iroha2.generated.FindAccountMetadata) : - SingularQueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 4 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindAccountMetadata = try { - FindAccountMetadata( - jp.co.soramitsu.iroha2.generated.FindAccountMetadata.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindAccountMetadata, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAccountMetadata.write(writer, instance.findAccountMetadata) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAssetMetadata' variant - */ - public data class FindAssetMetadata(public val findAssetMetadata: jp.co.soramitsu.iroha2.generated.FindAssetMetadata) : - SingularQueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 5 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindAssetMetadata = try { - FindAssetMetadata( - jp.co.soramitsu.iroha2.generated.FindAssetMetadata.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindAssetMetadata, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetMetadata.write(writer, instance.findAssetMetadata) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAssetDefinitionMetadata' variant - */ - public data class FindAssetDefinitionMetadata( - public val findAssetDefinitionMetadata: jp.co.soramitsu.iroha2.generated.FindAssetDefinitionMetadata, - ) : SingularQueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 6 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindAssetDefinitionMetadata = - try { - FindAssetDefinitionMetadata( - jp.co.soramitsu.iroha2.generated.FindAssetDefinitionMetadata.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindAssetDefinitionMetadata, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetDefinitionMetadata.write(writer, instance.findAssetDefinitionMetadata) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindTriggerMetadata' variant - */ - public data class FindTriggerMetadata(public val findTriggerMetadata: jp.co.soramitsu.iroha2.generated.FindTriggerMetadata) : - SingularQueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 7 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindTriggerMetadata = try { - FindTriggerMetadata( - jp.co.soramitsu.iroha2.generated.FindTriggerMetadata.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindTriggerMetadata, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindTriggerMetadata.write(writer, instance.findTriggerMetadata) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SingularQueryBox = when (val discriminant = reader.readUByte()) { - 0 -> FindAssetQuantityById.read(reader) - 1 -> FindExecutorDataModel.read(reader) - 2 -> FindParameters.read(reader) - 3 -> FindDomainMetadata.read(reader) - 4 -> FindAccountMetadata.read(reader) - 5 -> FindAssetMetadata.read(reader) - 6 -> FindAssetDefinitionMetadata.read(reader) - 7 -> FindTriggerMetadata.read(reader) + 0 -> FindExecutorDataModel.read(reader) + 1 -> FindParameters.read(reader) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } override fun write(writer: ScaleCodecWriter, instance: SingularQueryBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> FindAssetQuantityById.write(writer, instance as FindAssetQuantityById) - 1 -> FindExecutorDataModel.write(writer, instance as FindExecutorDataModel) - 2 -> FindParameters.write(writer, instance as FindParameters) - 3 -> FindDomainMetadata.write(writer, instance as FindDomainMetadata) - 4 -> FindAccountMetadata.write(writer, instance as FindAccountMetadata) - 5 -> FindAssetMetadata.write(writer, instance as FindAssetMetadata) - 6 -> FindAssetDefinitionMetadata.write(writer, instance as FindAssetDefinitionMetadata) - 7 -> FindTriggerMetadata.write(writer, instance as FindTriggerMetadata) + 0 -> FindExecutorDataModel.write(writer, instance as FindExecutorDataModel) + 1 -> FindParameters.write(writer, instance as FindParameters) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SingularQueryOutputBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SingularQueryOutputBox.kt index 87e7f7c62..f3e58e607 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SingularQueryOutputBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SingularQueryOutputBox.kt @@ -23,34 +23,6 @@ public sealed class SingularQueryOutputBox : ModelEnum { */ public abstract fun discriminant(): Int - /** - * 'Numeric' variant - */ - public data class Numeric(public val numeric: jp.co.soramitsu.iroha2.generated.Numeric) : SingularQueryOutputBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 0 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Numeric = try { - Numeric( - jp.co.soramitsu.iroha2.generated.Numeric.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Numeric): Unit = - try { - jp.co.soramitsu.iroha2.generated.Numeric.write(writer, instance.numeric) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - /** * 'ExecutorDataModel' variant */ @@ -61,7 +33,7 @@ public sealed class SingularQueryOutputBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 1 + public const val DISCRIMINANT: Int = 0 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.ExecutorDataModel = try { ExecutorDataModel( @@ -82,62 +54,6 @@ public sealed class SingularQueryOutputBox : ModelEnum { } } - /** - * 'Json' variant - */ - public data class Json(public val json: jp.co.soramitsu.iroha2.generated.Json) : SingularQueryOutputBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 2 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Json = try { - Json( - jp.co.soramitsu.iroha2.generated.Json.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Json): Unit = - try { - jp.co.soramitsu.iroha2.generated.Json.write(writer, instance.json) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Trigger' variant - */ - public data class Trigger(public val trigger: jp.co.soramitsu.iroha2.generated.Trigger) : SingularQueryOutputBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 3 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Trigger = try { - Trigger( - jp.co.soramitsu.iroha2.generated.Trigger.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Trigger): Unit = - try { - jp.co.soramitsu.iroha2.generated.Trigger.write(writer, instance.trigger) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - /** * 'Parameters' variant */ @@ -147,7 +63,7 @@ public sealed class SingularQueryOutputBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 4 + public const val DISCRIMINANT: Int = 1 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Parameters = try { Parameters( @@ -168,90 +84,20 @@ public sealed class SingularQueryOutputBox : ModelEnum { } } - /** - * 'Transaction' variant - */ - public data class Transaction(public val committedTransaction: CommittedTransaction) : SingularQueryOutputBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 5 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Transaction = try { - Transaction( - CommittedTransaction.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Transaction, - ): Unit = try { - CommittedTransaction.write(writer, instance.committedTransaction) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'BlockHeader' variant - */ - public data class BlockHeader(public val blockHeader: jp.co.soramitsu.iroha2.generated.BlockHeader) : SingularQueryOutputBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 6 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.BlockHeader = try { - BlockHeader( - jp.co.soramitsu.iroha2.generated.BlockHeader.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.BlockHeader, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.BlockHeader.write(writer, instance.blockHeader) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SingularQueryOutputBox = when (val discriminant = reader.readUByte()) { - 0 -> Numeric.read(reader) - 1 -> ExecutorDataModel.read(reader) - 2 -> Json.read(reader) - 3 -> Trigger.read(reader) - 4 -> Parameters.read(reader) - 5 -> Transaction.read(reader) - 6 -> BlockHeader.read(reader) + 0 -> ExecutorDataModel.read(reader) + 1 -> Parameters.read(reader) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } override fun write(writer: ScaleCodecWriter, instance: SingularQueryOutputBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Numeric.write(writer, instance as Numeric) - 1 -> ExecutorDataModel.write(writer, instance as ExecutorDataModel) - 2 -> Json.write(writer, instance as Json) - 3 -> Trigger.write(writer, instance as Trigger) - 4 -> Parameters.write(writer, instance as Parameters) - 5 -> Transaction.write(writer, instance as Transaction) - 6 -> BlockHeader.write(writer, instance as BlockHeader) + 0 -> ExecutorDataModel.write(writer, instance as ExecutorDataModel) + 1 -> Parameters.write(writer, instance as Parameters) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfPredicateMarker.kt index 8d12f5f73..57d1aa688 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfPredicateMarker.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfPredicateMarker.kt @@ -84,12 +84,44 @@ public sealed class TriggerProjectionOfPredicateMarker : ModelEnum { } } + /** + * 'Action' variant + */ + public data class Action(public val actionProjectionOfPredicateMarker: ActionProjectionOfPredicateMarker) : + TriggerProjectionOfPredicateMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 2 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerProjectionOfPredicateMarker.Action = try { + Action( + ActionProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TriggerProjectionOfPredicateMarker.Action, + ): Unit = try { + ActionProjectionOfPredicateMarker.write(writer, instance.actionProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): TriggerProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) 1 -> Id.read(reader) + 2 -> Action.read(reader) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } @@ -98,6 +130,7 @@ public sealed class TriggerProjectionOfPredicateMarker : ModelEnum { when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) 1 -> Id.write(writer, instance as Id) + 2 -> Action.write(writer, instance as Action) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfSelectorMarker.kt index cc02809e0..0a0f4e487 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfSelectorMarker.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfSelectorMarker.kt @@ -100,12 +100,44 @@ public sealed class TriggerProjectionOfSelectorMarker : ModelEnum { } } + /** + * 'Action' variant + */ + public data class Action(public val actionProjectionOfSelectorMarker: ActionProjectionOfSelectorMarker) : + TriggerProjectionOfSelectorMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 2 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerProjectionOfSelectorMarker.Action = try { + Action( + ActionProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TriggerProjectionOfSelectorMarker.Action, + ): Unit = try { + ActionProjectionOfSelectorMarker.write(writer, instance.actionProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): TriggerProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) 1 -> Id.read(reader) + 2 -> Action.read(reader) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } @@ -114,6 +146,7 @@ public sealed class TriggerProjectionOfSelectorMarker : ModelEnum { when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) 1 -> Id.write(writer, instance as Id) + 2 -> Action.write(writer, instance as Action) else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Upgrade.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Upgrade.kt index 9c90bfc0c..0b8bd9198 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Upgrade.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Upgrade.kt @@ -8,6 +8,7 @@ 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.generated.InstructionBox import jp.co.soramitsu.iroha2.transaction.Instruction import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit diff --git a/modules/test-tools/src/main/resources/executor.wasm b/modules/test-tools/src/main/resources/executor.wasm index f7aa34b22..11cc0f19f 100644 Binary files a/modules/test-tools/src/main/resources/executor.wasm and b/modules/test-tools/src/main/resources/executor.wasm differ