diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 000000000..fe992aa7b --- /dev/null +++ b/.editorconfig @@ -0,0 +1,20 @@ +root = true + +[{*.kt,*.kts}] +max_line_length = 140 +ktlint_code_style = intellij_idea +ktlint_experimental = disabled +ktlint_standard_final-newline = disabled +ktlint_standard_string-template-indent = disabled +ktlint_standard_multiline-if-else = disabled +ktlint_standard_property-wrapping = disabled +ktlint_standard_parameter-wrapping = disabled +ktlint_standard_multiline-expression-wrapping = disabled +ktlint_standard_function-literal = disabled +ktlint_function_signature_rule_force_multiline_when_parameter_count_greater_or_equal_than = 3 +ktlint_class_signature_rule_force_multiline_when_parameter_count_greater_or_equal_than = 3 +ktlint_standard_binary-expression-wrapping = disabled +# ktlint_function_signature_body_expression_wrapping = multiline + +[libs/contracts/src/main/kotlin/com/fil/fib/contract/Error.kt] +max_line_length = 1000 diff --git a/.gitignore b/.gitignore index d2c8cb243..9bf863099 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ build/ .idea/ +.kotlin/ .gradle/ */*/out diff --git a/build.gradle b/build.gradle index fb4511468..55cbeb021 100644 --- a/build.gradle +++ b/build.gradle @@ -58,7 +58,7 @@ subprojects { java { toolchain { - languageVersion = JavaLanguageVersion.of(8) + languageVersion = JavaLanguageVersion.of(21) } withJavadocJar() diff --git a/docker-compose/docker-compose.yaml b/docker-compose/docker-compose.yaml index c5a73ba4a..0f9005c0a 100644 --- a/docker-compose/docker-compose.yaml +++ b/docker-compose/docker-compose.yaml @@ -1,23 +1,24 @@ services: irohad0: - image: hyperledger/iroha:2.0.0-pre-rc.22.2 + image: hyperledger/iroha:2.0.0-rc.1.0 platform: linux/amd64 environment: CHAIN: 00000000-0000-0000-0000-000000000000 PUBLIC_KEY: ed0120A98BAFB0663CE08D75EBD506FEC38A84E576A7C9B0897693ED4B04FD9EF2D18D PRIVATE_KEY: 802620A4DFC16789FBF9A588525E4AC7F791AC51B12AEE8919EACC03EB2FC31D32C692 + P2P_PUBLIC_ADDRESS: irohad0:1337 P2P_ADDRESS: 0.0.0.0:1337 API_ADDRESS: 0.0.0.0:8080 - TRUSTED_PEERS: '[{"address":"irohad2:1339","public_key":"ed01204EE2FCD53E1730AF142D1E23951198678295047F9314B4006B0CB61850B1DB10"},{"address":"irohad1:1338","public_key":"ed01209897952D14BDFAEA780087C38FF3EB800CB20B882748FC95A575ADB9CD2CB21D"},{"address":"irohad3:1340","public_key":"ed0120CACF3A84B8DC8710CE9D6B968EE95EC7EE4C93C85858F026F3B4417F569592CE"}]' GENESIS_PUBLIC_KEY: ed01204164BF554923ECE1FD412D241036D863A6AE430476C898248B8237D77534CFC4 + TRUSTED_PEERS: '["ed01209897952D14BDFAEA780087C38FF3EB800CB20B882748FC95A575ADB9CD2CB21D@irohad1:1338","ed01204EE2FCD53E1730AF142D1E23951198678295047F9314B4006B0CB61850B1DB10@irohad2:1339","ed0120CACF3A84B8DC8710CE9D6B968EE95EC7EE4C93C85858F026F3B4417F569592CE@irohad3:1340"]' GENESIS_PRIVATE_KEY: 80262082B3BDE54AEBECA4146257DA0DE8D59D8E46D5FE34887DCD8072866792FCB3AD GENESIS: /tmp/genesis.signed.scale - TOPOLOGY: '[{"address":"irohad2:1339","public_key":"ed01204EE2FCD53E1730AF142D1E23951198678295047F9314B4006B0CB61850B1DB10"},{"address":"irohad1:1338","public_key":"ed01209897952D14BDFAEA780087C38FF3EB800CB20B882748FC95A575ADB9CD2CB21D"},{"address":"irohad0:1337","public_key":"ed0120A98BAFB0663CE08D75EBD506FEC38A84E576A7C9B0897693ED4B04FD9EF2D18D"},{"address":"irohad3:1340","public_key":"ed0120CACF3A84B8DC8710CE9D6B968EE95EC7EE4C93C85858F026F3B4417F569592CE"}]' + TOPOLOGY: '["ed0120A98BAFB0663CE08D75EBD506FEC38A84E576A7C9B0897693ED4B04FD9EF2D18D","ed01209897952D14BDFAEA780087C38FF3EB800CB20B882748FC95A575ADB9CD2CB21D","ed01204EE2FCD53E1730AF142D1E23951198678295047F9314B4006B0CB61850B1DB10","ed0120CACF3A84B8DC8710CE9D6B968EE95EC7EE4C93C85858F026F3B4417F569592CE"]' ports: - - 1337:1337 - - 8080:8080 + - 1337:1337 + - 8080:8080 volumes: - - "../modules/test-tools/src/main/resources:/config" + - "../modules/test-tools/src/main/resources:/config" init: true healthcheck: test: test $(curl -s http://127.0.0.1:8080/status/blocks) -gt 0 @@ -29,34 +30,38 @@ services: /bin/sh -c " EXECUTOR_RELATIVE_PATH=$(jq -r '.executor' /config/genesis.json) && \\ EXECUTOR_ABSOLUTE_PATH=$(realpath \"/config/$$EXECUTOR_RELATIVE_PATH\") && \\ + WASM_DIR_RELATIVE_PATH=$(jq -r '.wasm_dir' /config/genesis.json) && \\ + WASM_DIR_ABSOLUTE_PATH=$(realpath \"/config/$$WASM_DIR_RELATIVE_PATH\") && \\ jq \\ --arg executor \"$$EXECUTOR_ABSOLUTE_PATH\" \\ + --arg wasm_dir \"$$WASM_DIR_ABSOLUTE_PATH\" \\ --argjson topology \"$$TOPOLOGY\" \\ - '.executor = $$executor | .topology = $$topology' /config/genesis.json \\ + '.executor = $$executor | .wasm_dir = $$wasm_dir | .topology = $$topology' /config/genesis.json \\ >/tmp/genesis.json && \\ kagami genesis sign /tmp/genesis.json \\ --public-key $$GENESIS_PUBLIC_KEY \\ --private-key $$GENESIS_PRIVATE_KEY \\ --out-file $$GENESIS \\ && \\ - irohad + exec irohad " irohad1: - image: hyperledger/iroha:2.0.0-pre-rc.22.2 + image: hyperledger/iroha:2.0.0-rc.1.0 platform: linux/amd64 environment: CHAIN: 00000000-0000-0000-0000-000000000000 PUBLIC_KEY: ed01209897952D14BDFAEA780087C38FF3EB800CB20B882748FC95A575ADB9CD2CB21D PRIVATE_KEY: 8026203ECA64ADC23DC106C9D703233375EA6AC345AD7299FF3AD45F355DE6CD1B5510 + P2P_PUBLIC_ADDRESS: irohad1:1338 P2P_ADDRESS: 0.0.0.0:1338 API_ADDRESS: 0.0.0.0:8081 GENESIS_PUBLIC_KEY: ed01204164BF554923ECE1FD412D241036D863A6AE430476C898248B8237D77534CFC4 - TRUSTED_PEERS: '[{"address":"irohad2:1339","public_key":"ed01204EE2FCD53E1730AF142D1E23951198678295047F9314B4006B0CB61850B1DB10"},{"address":"irohad0:1337","public_key":"ed0120A98BAFB0663CE08D75EBD506FEC38A84E576A7C9B0897693ED4B04FD9EF2D18D"},{"address":"irohad3:1340","public_key":"ed0120CACF3A84B8DC8710CE9D6B968EE95EC7EE4C93C85858F026F3B4417F569592CE"}]' + TRUSTED_PEERS: '["ed0120A98BAFB0663CE08D75EBD506FEC38A84E576A7C9B0897693ED4B04FD9EF2D18D@irohad0:1337","ed01204EE2FCD53E1730AF142D1E23951198678295047F9314B4006B0CB61850B1DB10@irohad2:1339","ed0120CACF3A84B8DC8710CE9D6B968EE95EC7EE4C93C85858F026F3B4417F569592CE@irohad3:1340"]' ports: - - 1338:1338 - - 8081:8081 + - 1338:1338 + - 8081:8081 volumes: - - "../modules/test-tools/src/main/resources:/config" + - "../modules/test-tools/src/main/resources:/config" init: true healthcheck: test: test $(curl -s http://127.0.0.1:8081/status/blocks) -gt 0 @@ -65,21 +70,22 @@ services: retries: 30 start_period: 4s irohad2: - image: hyperledger/iroha:2.0.0-pre-rc.22.2 + image: hyperledger/iroha:2.0.0-rc.1.0 platform: linux/amd64 environment: CHAIN: 00000000-0000-0000-0000-000000000000 PUBLIC_KEY: ed01204EE2FCD53E1730AF142D1E23951198678295047F9314B4006B0CB61850B1DB10 PRIVATE_KEY: 8026207B1C78F733EDAFD6AF9BAC3A0D6C5A494557DD031609A4FDD9796EEF471D928C + P2P_PUBLIC_ADDRESS: irohad2:1339 P2P_ADDRESS: 0.0.0.0:1339 API_ADDRESS: 0.0.0.0:8082 GENESIS_PUBLIC_KEY: ed01204164BF554923ECE1FD412D241036D863A6AE430476C898248B8237D77534CFC4 - TRUSTED_PEERS: '[{"address":"irohad1:1338","public_key":"ed01209897952D14BDFAEA780087C38FF3EB800CB20B882748FC95A575ADB9CD2CB21D"},{"address":"irohad0:1337","public_key":"ed0120A98BAFB0663CE08D75EBD506FEC38A84E576A7C9B0897693ED4B04FD9EF2D18D"},{"address":"irohad3:1340","public_key":"ed0120CACF3A84B8DC8710CE9D6B968EE95EC7EE4C93C85858F026F3B4417F569592CE"}]' + TRUSTED_PEERS: '["ed0120A98BAFB0663CE08D75EBD506FEC38A84E576A7C9B0897693ED4B04FD9EF2D18D@irohad0:1337","ed01209897952D14BDFAEA780087C38FF3EB800CB20B882748FC95A575ADB9CD2CB21D@irohad1:1338","ed0120CACF3A84B8DC8710CE9D6B968EE95EC7EE4C93C85858F026F3B4417F569592CE@irohad3:1340"]' ports: - - 1339:1339 - - 8082:8082 + - 1339:1339 + - 8082:8082 volumes: - - "../modules/test-tools/src/main/resources:/config" + - "../modules/test-tools/src/main/resources:/config" init: true healthcheck: test: test $(curl -s http://127.0.0.1:8082/status/blocks) -gt 0 @@ -88,21 +94,22 @@ services: retries: 30 start_period: 4s irohad3: - image: hyperledger/iroha:2.0.0-pre-rc.22.2 + image: hyperledger/iroha:2.0.0-rc.1.0 platform: linux/amd64 environment: CHAIN: 00000000-0000-0000-0000-000000000000 PUBLIC_KEY: ed0120CACF3A84B8DC8710CE9D6B968EE95EC7EE4C93C85858F026F3B4417F569592CE PRIVATE_KEY: 8026206C7FF4CA09D395C7B7332C654099406E929C6238942E3CE85155CC1A5E2CF519 + P2P_PUBLIC_ADDRESS: irohad3:1340 P2P_ADDRESS: 0.0.0.0:1340 API_ADDRESS: 0.0.0.0:8083 GENESIS_PUBLIC_KEY: ed01204164BF554923ECE1FD412D241036D863A6AE430476C898248B8237D77534CFC4 - TRUSTED_PEERS: '[{"address":"irohad2:1339","public_key":"ed01204EE2FCD53E1730AF142D1E23951198678295047F9314B4006B0CB61850B1DB10"},{"address":"irohad1:1338","public_key":"ed01209897952D14BDFAEA780087C38FF3EB800CB20B882748FC95A575ADB9CD2CB21D"},{"address":"irohad0:1337","public_key":"ed0120A98BAFB0663CE08D75EBD506FEC38A84E576A7C9B0897693ED4B04FD9EF2D18D"}]' + TRUSTED_PEERS: '["ed0120A98BAFB0663CE08D75EBD506FEC38A84E576A7C9B0897693ED4B04FD9EF2D18D@irohad0:1337","ed01209897952D14BDFAEA780087C38FF3EB800CB20B882748FC95A575ADB9CD2CB21D@irohad1:1338","ed01204EE2FCD53E1730AF142D1E23951198678295047F9314B4006B0CB61850B1DB10@irohad2:1339"]' ports: - - 1340:1340 - - 8083:8083 + - 1340:1340 + - 8083:8083 volumes: - - "../modules/test-tools/src/main/resources:/config" + - "../modules/test-tools/src/main/resources:/config" init: true healthcheck: test: test $(curl -s http://127.0.0.1:8083/status/blocks) -gt 0 diff --git a/examples/tutorial/build.gradle.kts b/examples/tutorial/build.gradle.kts index 1b1e6d7a7..232954406 100644 --- a/examples/tutorial/build.gradle.kts +++ b/examples/tutorial/build.gradle.kts @@ -1,14 +1,19 @@ +val ktorVer = project.properties["ktorVer"] as String + dependencies { - implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.0") - implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.6.0") + implementation(project(":admin-client")) - implementation("net.i2p.crypto:eddsa:0.3.0") - implementation("org.bouncycastle:bcprov-jdk15on:1.65") - implementation("com.github.multiformats:java-multihash:1.3.0") + implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0") + implementation("io.ktor:ktor-client-logging:$ktorVer") +} - implementation(project(":model")) - implementation(project(":block")) - api(project(":admin-client")) +tasks.jacocoTestReport { + mustRunAfter(":admin-client:jacocoTestReport") + mustRunAfter(":block:jacocoTestReport") + mustRunAfter(":client:jacocoTestReport") + mustRunAfter(":codegen:jacocoTestReport") + mustRunAfter(":model:jacocoTestReport") + mustRunAfter(":test-tools:jacocoTestReport") } tasks.jacocoTestReport { diff --git a/examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/Main.kt b/examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/Main.kt index 9bb218039..7d8de60ec 100644 --- a/examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/Main.kt +++ b/examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/Main.kt @@ -5,13 +5,13 @@ import jp.co.soramitsu.iroha2.generated.AssetId import jp.co.soramitsu.iroha2.generated.AssetType import jp.co.soramitsu.iroha2.generated.AssetValue import kotlinx.coroutines.runBlocking -import java.net.URL +import java.math.BigDecimal +import java.net.URI import java.util.UUID -fun main(args: Array): Unit = runBlocking { +fun main(): Unit = runBlocking { val chainId = UUID.fromString("00000000-0000-0000-0000-000000000000") val apiUrl = "http://127.0.0.1:8080" - val peerUrl = "http://127.0.0.1:1337" val admin = AccountId( "wonderland".asDomainId(), publicKeyFromHex("CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03").toIrohaPublicKey(), @@ -20,7 +20,7 @@ fun main(args: Array): Unit = runBlocking { "CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03", "CCF31D85E3B32A4BEA59987CE0C78E3B8E2DB93881468AB2435FE45D5C9DCD53", ) - val client = AdminIroha2Client(URL(apiUrl), URL(peerUrl)) + val client = AdminIroha2Client(listOf(URI(apiUrl).toURL()), chainId, admin, adminKeyPair) val query = Query(client, admin, adminKeyPair) query.findAllDomains() .also { println("ALL DOMAINS: ${it.map { d -> d.id.asString() }}") } @@ -29,7 +29,7 @@ fun main(args: Array): Unit = runBlocking { query.findAllAssets() .also { println("ALL ASSETS: ${it.map { d -> d.id.asString() }}") } - val sendTransaction = SendTransaction(client, admin, adminKeyPair, chainId) + val sendTransaction = SendTransaction(client) val domain = "looking_glass_${System.currentTimeMillis()}" sendTransaction.registerDomain(domain).also { println("DOMAIN $domain CREATED") } @@ -56,12 +56,12 @@ fun main(args: Array): Unit = runBlocking { sendTransaction.registerAsset(whiteRabbitAsset, AssetValue.Numeric(0.asNumeric())) .also { println("ASSET $whiteRabbitAsset CREATED") } - sendTransaction.transferAsset(madHatterAsset, 10, whiteRabbit.asString(), madHatter, madHatterKeyPair) + sendTransaction.transferAsset(madHatterAsset, BigDecimal(10), whiteRabbit.asString()) .also { println("$madHatter TRANSFERRED FROM $madHatterAsset TO $whiteRabbitAsset: 10") } query.getAccountAmount(madHatter, madHatterAsset.definition).also { println("$madHatterAsset BALANCE: $it") } query.getAccountAmount(whiteRabbit, whiteRabbitAsset.definition).also { println("$whiteRabbitAsset BALANCE: $it") } - sendTransaction.burnAssets(madHatterAsset, 10, madHatter, madHatterKeyPair) + sendTransaction.burnAssets(madHatterAsset, BigDecimal(10)) .also { println("$madHatterAsset WAS BURN") } query.getAccountAmount(madHatter, madHatterAsset.definition) diff --git a/examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/Query.kt b/examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/Query.kt index 75e12d25b..4257f91b0 100644 --- a/examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/Query.kt +++ b/examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/Query.kt @@ -1,10 +1,15 @@ package jp.co.soramitsu.iroha2 import jp.co.soramitsu.iroha2.generated.AccountId +import jp.co.soramitsu.iroha2.generated.AccountIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.AssetDefinitionId +import jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.AssetProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.AssetValue -import jp.co.soramitsu.iroha2.generated.GenericPredicateBox -import jp.co.soramitsu.iroha2.generated.QueryOutputPredicate +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccount +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAsset +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain import jp.co.soramitsu.iroha2.query.QueryBuilder import java.math.BigInteger import java.security.KeyPair @@ -15,31 +20,38 @@ open class Query( private val keyPair: KeyPair, ) { - suspend fun findAllDomains(queryFilter: GenericPredicateBox? = null) = QueryBuilder - .findAllDomains(queryFilter) - .account(admin) - .buildSigned(keyPair) - .let { client.sendQuery(it) } + suspend fun findAllDomains(filter: CompoundPredicateOfDomain? = null) = client.submit( + QueryBuilder + .findDomains(filter) + .signAs(admin, keyPair), + ) - suspend fun findAllAccounts(queryFilter: GenericPredicateBox? = null) = QueryBuilder - .findAllAccounts(queryFilter) - .account(admin) - .buildSigned(keyPair) - .let { client.sendQuery(it) } + suspend fun findAllAccounts(filter: CompoundPredicateOfAccount? = null) = client.submit( + QueryBuilder + .findAccounts(filter) + .signAs(admin, keyPair), + ) - suspend fun findAllAssets(queryFilter: GenericPredicateBox? = null) = QueryBuilder - .findAllAssets(queryFilter) - .account(admin) - .buildSigned(keyPair) - .let { client.sendQuery(it) } + suspend fun findAllAssets(filter: CompoundPredicateOfAsset? = null) = client.submit( + QueryBuilder + .findAssets(filter).signAs(admin, keyPair), + ) - suspend fun getAccountAmount(accountId: AccountId, assetDefinitionId: AssetDefinitionId): BigInteger = - QueryBuilder.findAssetsByAccountId(accountId) - .account(admin) - .buildSigned(keyPair) + suspend fun getAccountAmount(accountId: AccountId, assetDefinitionId: AssetDefinitionId): BigInteger { + val byAccountIdFilter = CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Account( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals(accountId), + ), + ), + ), + ) + return client.submit(QueryBuilder.findAssets(byAccountIdFilter).signAs(admin, keyPair)) .let { query -> - client.sendQuery(query).find { it.id.definition == assetDefinitionId }?.value + query.find { it.id.definition == assetDefinitionId }?.value }.let { value -> value?.cast()?.numeric?.mantissa } ?: throw RuntimeException("NOT FOUND") + } } diff --git a/examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/SendTransaction.kt b/examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/SendTransaction.kt index 34aa58dc5..6b3e9588c 100644 --- a/examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/SendTransaction.kt +++ b/examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/SendTransaction.kt @@ -1,52 +1,28 @@ package jp.co.soramitsu.iroha2 -import jp.co.soramitsu.iroha2.generated.AccountId import jp.co.soramitsu.iroha2.generated.AssetId import jp.co.soramitsu.iroha2.generated.AssetType import jp.co.soramitsu.iroha2.generated.AssetValue +import jp.co.soramitsu.iroha2.generated.Json import jp.co.soramitsu.iroha2.generated.Metadata import jp.co.soramitsu.iroha2.generated.Mintable import jp.co.soramitsu.iroha2.generated.Name +import jp.co.soramitsu.iroha2.transaction.Burn +import jp.co.soramitsu.iroha2.transaction.Register +import jp.co.soramitsu.iroha2.transaction.Transfer import kotlinx.coroutines.withTimeout -import java.security.KeyPair -import java.util.UUID +import java.math.BigDecimal -class SendTransaction( - private val client: AdminIroha2Client, - private val admin: AccountId, - private val keyPair: KeyPair, - private val chainUuid: UUID, - private val timeout: Long = 10000, -) { +class SendTransaction(private val client: AdminIroha2Client, private val timeout: Long = 10000) { - suspend fun registerDomain( - id: String, - metadata: Map = mapOf(), - admin: AccountId = this.admin, - keyPair: KeyPair = this.keyPair, - ) { - client.sendTransaction { - account(admin) - chainId(chainUuid) - registerDomain(id.asDomainId(), metadata) - buildSigned(keyPair) - }.also { + suspend fun registerDomain(id: String, metadata: Map = mapOf()) { + client.submit(Register.domain(id.asDomainId(), metadata)).also { withTimeout(timeout) { it.await() } } } - suspend fun registerAccount( - id: String, - metadata: Map = mapOf(), - admin: AccountId = this.admin, - keyPair: KeyPair = this.keyPair, - ) { - client.sendTransaction { - account(admin) - chainId(chainUuid) - registerAccount(id.asAccountId(), Metadata(metadata)) - buildSigned(keyPair) - }.also { + suspend fun registerAccount(id: String, metadata: Map = mapOf()) { + client.submit(Register.account(id.asAccountId(), Metadata(metadata))).also { withTimeout(timeout) { it.await() } } } @@ -54,66 +30,32 @@ class SendTransaction( suspend fun registerAssetDefinition( id: String, type: AssetType = AssetType.Store(), - metadata: Map = mapOf(), + metadata: Map = mapOf(), mintable: Mintable = Mintable.Infinitely(), - admin: AccountId = this.admin, - keyPair: KeyPair = this.keyPair, ) { - client.sendTransaction { - account(admin) - chainId(chainUuid) - registerAssetDefinition(id.asAssetDefinitionId(), type, Metadata(metadata), mintable) - buildSigned(keyPair) - }.also { + client.submit(Register.assetDefinition(id.asAssetDefinitionId(), type, mintable, metadata = Metadata(metadata))).also { withTimeout(timeout) { it.await() } } } - suspend fun registerAsset( - id: AssetId, - value: AssetValue, - admin: AccountId = this.admin, - keyPair: KeyPair = this.keyPair, - ) { - client.sendTransaction { - account(admin) - chainId(chainUuid) - registerAsset(id, value) - buildSigned(keyPair) - }.also { + suspend fun registerAsset(id: AssetId, value: AssetValue) { + client.submit(Register.asset(id, value)).also { withTimeout(timeout) { it.await() } } } suspend fun transferAsset( from: AssetId, - value: Int, + value: BigDecimal, to: String, - admin: AccountId = this.admin, - keyPair: KeyPair = this.keyPair, ) { - client.sendTransaction { - account(admin) - chainId(chainUuid) - transferAsset(from, value, to.asAccountId()) - buildSigned(keyPair) - }.also { + client.submit(Transfer.asset(from, value, to.asAccountId())).also { withTimeout(timeout) { it.await() } } } - suspend fun burnAssets( - assetId: AssetId, - value: Int, - admin: AccountId = this.admin, - keyPair: KeyPair = this.keyPair, - ) { - client.sendTransaction { - account(admin) - chainId(chainUuid) - burnAsset(assetId, value) - buildSigned(keyPair) - }.also { + suspend fun burnAssets(assetId: AssetId, value: BigDecimal) { + client.submit(Burn.asset(assetId, value)).also { withTimeout(timeout) { it.await() } } } diff --git a/gradle.properties b/gradle.properties index ca5442def..e456963a6 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,21 +1,20 @@ # kotlin -kotlinVer=1.8.22 -kotlinLinterVer=3.15.0 -ktorVer=2.3.2 -coroutinesVer=1.7.2 +kotlinVer=2.0.21 +kotlinLinterVer=4.5.0 +ktorVer=3.0.1 +coroutinesVer=1.9.0 # json serde -jacksonKotlinVer=2.15.2 +jacksonKotlinVer=2.18.1 # codegen -kotlinPoetVer=1.14.2 +kotlinPoetVer=2.0.0 # crypto bouncyCastleVer=1.70 i2pCryptoEddsa=0.3.0 -multihashVersion=1.3.0 -googleTinkVer=1.9.0 +multihashVersion=1.3.4 +googleTinkVer=1.15.0 # testing testContainersVer=1.20.3 -junitVersion=5.9.3 # logging -logbackVer=1.2.3 +logbackVer=1.5.12 org.gradle.jvmargs=-XX:MetaspaceSize=128M -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 systemProp.sonar.host.url=https://sonar.katana.soramitsu.co.jp diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar index 033e24c4c..a4b76b953 100644 Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 62f495dfe..94113f200 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.11-bin.zip networkTimeout=10000 validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME diff --git a/gradlew b/gradlew index fcb6fca14..f5feea6d6 100755 --- a/gradlew +++ b/gradlew @@ -15,6 +15,8 @@ # See the License for the specific language governing permissions and # limitations under the License. # +# SPDX-License-Identifier: Apache-2.0 +# ############################################################################## # @@ -55,7 +57,7 @@ # Darwin, MinGW, and NonStop. # # (3) This script is generated from the Groovy template -# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt # within the Gradle project. # # You can find Gradle at https://github.com/gradle/gradle/. @@ -83,7 +85,9 @@ done # This is normally unused # shellcheck disable=SC2034 APP_BASE_NAME=${0##*/} -APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s +' "$PWD" ) || exit # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD=maximum @@ -144,7 +148,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then case $MAX_FD in #( max*) # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. - # shellcheck disable=SC3045 + # shellcheck disable=SC2039,SC3045 MAX_FD=$( ulimit -H -n ) || warn "Could not query maximum file descriptor limit" esac @@ -152,7 +156,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then '' | soft) :;; #( *) # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. - # shellcheck disable=SC3045 + # shellcheck disable=SC2039,SC3045 ulimit -n "$MAX_FD" || warn "Could not set maximum file descriptor limit to $MAX_FD" esac @@ -201,11 +205,11 @@ fi # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' -# Collect all arguments for the java command; -# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of -# shell script including quotes and variable substitutions, so put them in -# double quotes to make sure that they get re-expanded; and -# * put everything else in single quotes, so that it's not re-expanded. +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. set -- \ "-Dorg.gradle.appname=$APP_BASE_NAME" \ diff --git a/gradlew.bat b/gradlew.bat index 93e3f59f1..9d21a2183 100644 --- a/gradlew.bat +++ b/gradlew.bat @@ -13,6 +13,8 @@ @rem See the License for the specific language governing permissions and @rem limitations under the License. @rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem @if "%DEBUG%"=="" @echo off @rem ########################################################################## @@ -43,11 +45,11 @@ set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 if %ERRORLEVEL% equ 0 goto execute -echo. -echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. -echo. -echo Please set the JAVA_HOME variable in your environment to match the -echo location of your Java installation. +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 goto fail @@ -57,11 +59,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe if exist "%JAVA_EXE%" goto execute -echo. -echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% -echo. -echo Please set the JAVA_HOME variable in your environment to match the -echo location of your Java installation. +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 goto fail diff --git a/modules/admin-client/build.gradle b/modules/admin-client/build.gradle index 69c24669c..cedf257c0 100644 --- a/modules/admin-client/build.gradle +++ b/modules/admin-client/build.gradle @@ -2,10 +2,10 @@ dependencies { api project(":model") api project(":client") - //kotlin support - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVer" - implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVer" - implementation "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:$coroutinesVer" + implementation "io.ktor:ktor-client-core:$ktorVer" + implementation "io.ktor:ktor-client-cio:$ktorVer" + implementation "io.ktor:ktor-client-logging:$ktorVer" testApi project(":test-tools") + testImplementation "org.jetbrains.kotlin:kotlin-test-junit5:$kotlinVer" } diff --git a/modules/admin-client/src/main/kotlin/jp/co/soramitsu/iroha2/AdminIroha2AsyncClient.kt b/modules/admin-client/src/main/kotlin/jp/co/soramitsu/iroha2/AdminIroha2AsyncClient.kt index 9e9227abb..7dc6e5d09 100644 --- a/modules/admin-client/src/main/kotlin/jp/co/soramitsu/iroha2/AdminIroha2AsyncClient.kt +++ b/modules/admin-client/src/main/kotlin/jp/co/soramitsu/iroha2/AdminIroha2AsyncClient.kt @@ -1,18 +1,24 @@ package jp.co.soramitsu.iroha2 import io.ktor.client.plugins.logging.LogLevel -import jp.co.soramitsu.iroha2.model.IrohaUrls +import jp.co.soramitsu.iroha2.generated.AccountId import kotlinx.coroutines.future.future +import java.net.URL +import java.security.KeyPair +import java.util.UUID /** * Extension of [AdminIroha2Client] for Java. Functionality for monitoring peers and configuration support */ @Suppress("unused") class AdminIroha2AsyncClient @JvmOverloads constructor( - urls: List, + override val apiURL: List, + override val chain: UUID, + override val authority: AccountId, + override val keyPair: KeyPair, httpLogLevel: LogLevel = LogLevel.NONE, credentials: String? = null, -) : AdminIroha2Client(urls, httpLogLevel, credentials) { +) : AdminIroha2Client(apiURL, chain, authority, keyPair, credentials, httpLogLevel) { /** * Send health check request diff --git a/modules/admin-client/src/main/kotlin/jp/co/soramitsu/iroha2/AdminIroha2Client.kt b/modules/admin-client/src/main/kotlin/jp/co/soramitsu/iroha2/AdminIroha2Client.kt index a8013d19d..72e64d3a4 100644 --- a/modules/admin-client/src/main/kotlin/jp/co/soramitsu/iroha2/AdminIroha2Client.kt +++ b/modules/admin-client/src/main/kotlin/jp/co/soramitsu/iroha2/AdminIroha2Client.kt @@ -6,71 +6,57 @@ import io.ktor.client.request.get import io.ktor.client.request.setBody import io.ktor.client.statement.HttpResponse import io.ktor.http.ContentType -import io.ktor.http.HttpStatusCode import io.ktor.http.contentType import jp.co.soramitsu.iroha2.client.Iroha2Client -import jp.co.soramitsu.iroha2.model.IrohaUrls -import kotlinx.coroutines.runBlocking +import jp.co.soramitsu.iroha2.generated.AccountId +import jp.co.soramitsu.iroha2.generated.Peer import java.net.URL +import java.security.KeyPair +import java.util.* /** * Enhancement of [Iroha2Client] for monitoring peers and configuration support */ @Suppress("unused") open class AdminIroha2Client( - urls: List, - httpLogLevel: LogLevel = LogLevel.NONE, + override val apiURL: List, + override val chain: UUID, + override val authority: AccountId, + override val keyPair: KeyPair, credentials: String? = null, + httpLogLevel: LogLevel = LogLevel.NONE, private val balancingHealthCheck: Boolean = true, -) : Iroha2Client(urls, httpLogLevel, credentials) { - - constructor( - url: IrohaUrls, - httpLogLevel: LogLevel = LogLevel.NONE, - credentials: String? = null, - balancingHealthCheck: Boolean = true, - ) : this(mutableListOf(url), httpLogLevel, credentials, balancingHealthCheck) - - constructor( - apiUrl: URL, - peerUrl: URL, - httpLogLevel: LogLevel = LogLevel.NONE, - credentials: String? = null, - balancingHealthCheck: Boolean = true, - ) : this(IrohaUrls(apiUrl, peerUrl), httpLogLevel, credentials, balancingHealthCheck) - - constructor( - apiUrl: String, - peerUrl: String, - httpLogLevel: LogLevel = LogLevel.NONE, - credentials: String? = null, - balancingHealthCheck: Boolean = true, - ) : this(URL(apiUrl), URL(peerUrl), httpLogLevel, credentials, balancingHealthCheck) +) : Iroha2Client(apiURL, chain, authority, keyPair, credentials, httpLogLevel) { /** * Send metrics request */ - suspend fun metrics(): String = client.get("${getApiUrl()}$METRICS_ENDPOINT").body() + suspend fun metrics(): String = client.get("${getApiURL()}$METRICS_ENDPOINT").body() /** * Send health check request */ - suspend fun health(): Int = client.get("${getApiUrl()}$HEALTH_ENDPOINT").status.value + suspend fun health(): Int = client.get("${getApiURL()}$HEALTH_ENDPOINT").status.value /** * Send health check request */ - suspend fun health(peerUrl: URL): Int = client.get("$peerUrl$HEALTH_ENDPOINT").status.value + private suspend fun health(peerUrl: URL): Int = client.get("$peerUrl$HEALTH_ENDPOINT").status.value /** * Send status check request */ - suspend fun status(): PeerStatus = client.get("${getApiUrl()}$STATUS_ENDPOINT").body() + suspend fun status(): PeerStatus = client.get("${getApiURL()}$STATUS_ENDPOINT").body() + + /** + * Send peers request + */ + suspend fun peers(): List = client.get("${getApiURL()}$PEERS_ENDPOINT").body() /** * Send schema request */ - suspend fun schema(): String = client.get("${getApiUrl()}$SCHEMA_ENDPOINT").body() + suspend fun schema(): String = client.get("${getApiURL()}$SCHEMA_ENDPOINT").body() /** * Request current configuration of the peer @@ -88,29 +74,12 @@ open class AdminIroha2Client( } private suspend inline fun config(body: B): T { - val response: HttpResponse = client.get("${getApiUrl()}$CONFIGURATION_ENDPOINT") { + val response: HttpResponse = client.get("${getApiURL()}$CONFIGURATION_ENDPOINT") { contentType(ContentType.Application.Json) setBody(body) } return response.body() } - override fun getApiUrl(): URL = when (balancingHealthCheck) { - true -> { - var attempt = 0 - var url = super.getApiUrl() - - while (runBlocking { health(url) } != HttpStatusCode.OK.value) { - url = super.getApiUrl() - if (++attempt >= urls.size) { - throw IrohaClientException("All peers are unhealthy") - } - } - url - } - - false -> super.getApiUrl() - } - enum class ConfigurationFieldType { Value, Docs } } diff --git a/modules/admin-client/src/main/kotlin/jp/co/soramitsu/iroha2/PeerStatus.kt b/modules/admin-client/src/main/kotlin/jp/co/soramitsu/iroha2/PeerStatus.kt index 6b5eef1fd..f4cf97b7f 100644 --- a/modules/admin-client/src/main/kotlin/jp/co/soramitsu/iroha2/PeerStatus.kt +++ b/modules/admin-client/src/main/kotlin/jp/co/soramitsu/iroha2/PeerStatus.kt @@ -14,7 +14,7 @@ import java.time.Duration data class PeerStatus( val peers: Int, val blocks: Long, - val txs_accepted: Long, + val txs_approved: Long, val txs_rejected: Long, val uptime: Duration, val view_changes: Long, diff --git a/modules/admin-client/src/test/kotlin/jp/co/soramitsu/iroha2/ClientTest.kt b/modules/admin-client/src/test/kotlin/jp/co/soramitsu/iroha2/ClientTest.kt index 2f1d78d9f..f415d540f 100644 --- a/modules/admin-client/src/test/kotlin/jp/co/soramitsu/iroha2/ClientTest.kt +++ b/modules/admin-client/src/test/kotlin/jp/co/soramitsu/iroha2/ClientTest.kt @@ -45,8 +45,4 @@ class ClientTest : IrohaTest() { val configs = client.getConfigs() assert(configs.isNotEmpty()) } - - companion object { - private const val PEER_AMOUNT = 4 - } } diff --git a/modules/block/build.gradle b/modules/block/build.gradle index fdb17e855..eae47777d 100644 --- a/modules/block/build.gradle +++ b/modules/block/build.gradle @@ -1,11 +1,12 @@ dependencies { - api project(":client") + implementation project(":model") - api "com.fasterxml.jackson.module:jackson-module-kotlin:$jacksonKotlinVer" - api "com.google.crypto.tink:tink:$googleTinkVer" + implementation "com.fasterxml.jackson.module:jackson-module-kotlin:$jacksonKotlinVer" testImplementation "org.jetbrains.kotlin:kotlin-test-junit5:$kotlinVer" testImplementation "org.jetbrains.kotlin:kotlin-test:$kotlinVer" + + testImplementation "com.google.crypto.tink:tink:$googleTinkVer" } jacocoTestReport { diff --git a/modules/block/src/main/kotlin/jp/co/soramitsu/iroha2/Exceptions.kt b/modules/block/src/main/kotlin/jp/co/soramitsu/iroha2/Exceptions.kt deleted file mode 100644 index bc29205af..000000000 --- a/modules/block/src/main/kotlin/jp/co/soramitsu/iroha2/Exceptions.kt +++ /dev/null @@ -1,15 +0,0 @@ -package jp.co.soramitsu.iroha2 - -/** - * Throw if there is an issue with deserialization. - * - * @param message The explanation of the issue - */ -class DeserializationException(message: String) : RuntimeException(message) - -/** - * Throw if there is an issue with serialization - * - * @param message The explanation of the issue - */ -class SerializationException(message: String) : RuntimeException(message) diff --git a/modules/block/src/main/kotlin/jp/co/soramitsu/iroha2/Genesis.kt b/modules/block/src/main/kotlin/jp/co/soramitsu/iroha2/Genesis.kt index 99fe25b95..bcec0f763 100644 --- a/modules/block/src/main/kotlin/jp/co/soramitsu/iroha2/Genesis.kt +++ b/modules/block/src/main/kotlin/jp/co/soramitsu/iroha2/Genesis.kt @@ -6,7 +6,7 @@ import jp.co.soramitsu.iroha2.generated.Metadata import jp.co.soramitsu.iroha2.generated.NewAccount import jp.co.soramitsu.iroha2.generated.NewAssetDefinition import jp.co.soramitsu.iroha2.generated.NewDomain -import jp.co.soramitsu.iroha2.generated.Parameter +import jp.co.soramitsu.iroha2.generated.Parameters import jp.co.soramitsu.iroha2.generated.RawGenesisTransaction import jp.co.soramitsu.iroha2.generated.RegisterBox import jp.co.soramitsu.iroha2.generated.RegisterOfAccount @@ -33,35 +33,43 @@ open class Genesis(open val transaction: RawGenesisTransaction) { /** * Represent genesis as JSON */ - fun asJson(): String = JSON_SERDE.writeValueAsString(this.transaction) + fun asJson(): String = JSON_SERDE.writeValueAsString(this.transaction).also { genesis -> + println("GENESIS: $genesis") + } companion object { - const val EXECUTOR_FILE_NAME = "executor.wasm" + const val EXECUTOR_FILE_NAME = "./executor.wasm" /** * List of genesis blocks to single block with unique instructions */ fun List.toSingle(): Genesis { val uniqueIsi: MutableSet = mutableSetOf() - val uniqueParams: MutableSet = mutableSetOf() + val uniqueParams: MutableSet = mutableSetOf() this.forEach { genesis -> uniqueIsi.addAll(genesis.transaction.instructions) - uniqueParams.addAll(genesis.transaction.parameters) + genesis.transaction.parameters?.also { uniqueParams.add(it) } } return Genesis( RawGenesisTransaction( ChainId("00000000-0000-0000-0000-000000000000"), EXECUTOR_FILE_NAME, - uniqueParams.toList(), - uniqueIsi.mergeMetadata().toList(), + uniqueParams.merge(), + uniqueIsi.merge().toList(), + "libs", + emptyList(), emptyList(), ), ) } - private fun MutableSet.mergeMetadata(): List { + private fun MutableSet.merge(): Parameters? { + return this.firstOrNull() // TODO + } + + private fun MutableSet.merge(): List { // entity id to its metadata val metadataMap = mutableMapOf() @@ -123,10 +131,7 @@ open class Genesis(open val transaction: RawGenesisTransaction) { } private fun MutableMap.putMergedMetadata(idBox: RegisterBox) { - fun MutableMap.putOrMerge( - id: Any, - metadata: Metadata, - ) = when (val value = this[id]) { + fun MutableMap.putOrMerge(id: Any, metadata: Metadata) = when (val value = this[id]) { null -> this[id] = metadata else -> { metadata.sortedMapOfName.forEach { (k, v) -> diff --git a/modules/block/src/test/kotlin/jp/co/soramitsu/iroha2/SerializerTest.kt b/modules/block/src/test/kotlin/jp/co/soramitsu/iroha2/SerializerTest.kt index e0f1b6e1a..0f5a994e9 100644 --- a/modules/block/src/test/kotlin/jp/co/soramitsu/iroha2/SerializerTest.kt +++ b/modules/block/src/test/kotlin/jp/co/soramitsu/iroha2/SerializerTest.kt @@ -1,41 +1,89 @@ package jp.co.soramitsu.iroha2 +import com.google.gson.GsonBuilder import jp.co.soramitsu.iroha2.generated.AssetDefinitionId import jp.co.soramitsu.iroha2.generated.AssetId +import jp.co.soramitsu.iroha2.generated.BlockParameters +import jp.co.soramitsu.iroha2.generated.CanUnregisterAccount import jp.co.soramitsu.iroha2.generated.ChainId +import jp.co.soramitsu.iroha2.generated.EventFilterBox +import jp.co.soramitsu.iroha2.generated.Json import jp.co.soramitsu.iroha2.generated.Metadata import jp.co.soramitsu.iroha2.generated.Name +import jp.co.soramitsu.iroha2.generated.NonZeroOfu64 +import jp.co.soramitsu.iroha2.generated.Parameters import jp.co.soramitsu.iroha2.generated.RawGenesisTransaction import jp.co.soramitsu.iroha2.generated.Repeats +import jp.co.soramitsu.iroha2.generated.SmartContractParameters +import jp.co.soramitsu.iroha2.generated.SumeragiParameters +import jp.co.soramitsu.iroha2.generated.TransactionParameters import jp.co.soramitsu.iroha2.generated.TriggerId import jp.co.soramitsu.iroha2.transaction.EventFilters -import jp.co.soramitsu.iroha2.transaction.Instructions +import jp.co.soramitsu.iroha2.transaction.Grant +import jp.co.soramitsu.iroha2.transaction.Mint +import jp.co.soramitsu.iroha2.transaction.Register +import jp.co.soramitsu.iroha2.transaction.SetKeyValue import org.junit.jupiter.api.Test +import java.math.BigDecimal import java.math.BigInteger import kotlin.test.assertEquals class SerializerTest { @Test fun `should serialize grant permission token genesis block`() { + val account = "ed012004FF5B81046DDCCF19E2E451C45DFB6F53759D4EB30FA2EFA807284D1CC33016${ACCOUNT_ID_DELIMITER}wonderland" + val destination = "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03${ACCOUNT_ID_DELIMITER}wonderland" + val genesis = Genesis( RawGenesisTransaction( ChainId("00000000-0000-0000-0000-000000000000"), Genesis.EXECUTOR_FILE_NAME, + Parameters( + SumeragiParameters(BigInteger.valueOf(1), BigInteger.valueOf(2), BigInteger.valueOf(3)), + BlockParameters(NonZeroOfu64(BigInteger.valueOf(4))), + TransactionParameters(NonZeroOfu64(BigInteger.valueOf(5)), NonZeroOfu64(BigInteger.valueOf(6))), + SmartContractParameters(NonZeroOfu64(BigInteger.valueOf(7)), NonZeroOfu64(BigInteger.valueOf(8))), + SmartContractParameters(NonZeroOfu64(BigInteger.valueOf(9)), NonZeroOfu64(BigInteger.valueOf(10))), + emptyMap(), + ), + listOf( + Grant.accountPermission( + CanUnregisterAccount(account.asAccountId()), + destination.asAccountId(), + ).asInstructionBox(), + ), + "", emptyList(), - Instructions.grantPermissionToken( - Permissions.CanUnregisterAccount, - "ed012004FF5B81046DDCCF19E2E451C45DFB6F53759D4EB30FA2EFA807284D1CC33016${ACCOUNT_ID_DELIMITER}wonderland".asAccountId() - .asJsonString(withPrefix = true), - "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03${ACCOUNT_ID_DELIMITER}wonderland".asAccountId(), - ).let { listOf(it) }, emptyList(), ), ) val expectedJson = """ { "chain": "00000000-0000-0000-0000-000000000000", - "executor": "executor.wasm", - "parameters": [], + "executor": "./executor.wasm", + "parameters": { + "sumeragi": { + "block_time_ms": 1, + "commit_time_ms": 2, + "max_clock_drift_ms": 3 + }, + "block": { + "max_transactions": 4 + }, + "transaction": { + "max_instructions": 5, + "smart_contract_size": 6 + }, + "executor": { + "fuel": 7, + "memory": 8 + }, + "smart_contract": { + "fuel": 9, + "memory": 10 + }, + "custom": {} + }, "instructions": [ { "Grant": { @@ -51,11 +99,13 @@ class SerializerTest { } } ], + "wasm_dir": "", + "wasm_triggers": [], "topology": [] } """.trimIndent() - val json = JSON_SERDE.writeValueAsString(genesis.transaction).trimIndent() + val json = JSON_SERDE.writeValueAsString(genesis.transaction) assertEquals(expectedJson.lowercase(), json.asPrettyJson().lowercase()) } @@ -72,43 +122,76 @@ class SerializerTest { RawGenesisTransaction( ChainId("00000000-0000-0000-0000-000000000000"), Genesis.EXECUTOR_FILE_NAME, - emptyList(), + Parameters( + SumeragiParameters(BigInteger.valueOf(1), BigInteger.valueOf(2), BigInteger.valueOf(3)), + BlockParameters(NonZeroOfu64(BigInteger.valueOf(4))), + TransactionParameters(NonZeroOfu64(BigInteger.valueOf(5)), NonZeroOfu64(BigInteger.valueOf(6))), + SmartContractParameters(NonZeroOfu64(BigInteger.valueOf(7)), NonZeroOfu64(BigInteger.valueOf(8))), + SmartContractParameters(NonZeroOfu64(BigInteger.valueOf(9)), NonZeroOfu64(BigInteger.valueOf(10))), + emptyMap(), + ), listOf( - Instructions.mintAsset(assetId, 100), - Instructions.setKeyValue(assetId, "key".asName(), "value"), - Instructions.registerTrigger( + Mint.asset(assetId, BigDecimal(100)).asInstructionBox(), + SetKeyValue.asset(assetId, "key".asName(), "value").asInstructionBox(), + Register.trigger( triggerId, - listOf(Instructions.mintAsset(assetId, 1)), + listOf(Mint.asset(assetId, BigDecimal(1))), Repeats.Indefinitely(), aliceAccountId, - Metadata(mapOf()), - EventFilters.timeEventFilter( - BigInteger.valueOf(1715676978L), - BigInteger.valueOf(1L), + EventFilterBox.Time( + EventFilters.timeEventFilter( + BigInteger.valueOf(1715676978L), + BigInteger.valueOf(1L), + ), ), - ), + Metadata(mapOf(Pair("key".asName(), Json.writeValue("value")))), + ).asInstructionBox(), ), + "", + emptyList(), emptyList(), ), ) val expectedJson = """ { "chain": "00000000-0000-0000-0000-000000000000", - "executor": "executor.wasm", - "parameters": [], + "executor": "./executor.wasm", + "parameters": { + "sumeragi": { + "block_time_ms": 1, + "commit_time_ms": 2, + "max_clock_drift_ms": 3 + }, + "block": { + "max_transactions": 4 + }, + "transaction": { + "max_instructions": 5, + "smart_contract_size": 6 + }, + "executor": { + "fuel": 7, + "memory": 8 + }, + "smart_contract": { + "fuel": 9, + "memory": 10 + }, + "custom": {} + }, "instructions": [ { "Mint": { "Asset": { "object": "100", - "destination": "xor#wonderland#ed0120ce7fa46c9dce7ea4b125e2e36bdb63ea33073e7590ac92816ae1e861b7048b03@wonderland" + "destination": "xor#wonderland#ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland" } } }, { "SetKeyValue": { "Asset": { - "object": "xor#wonderland#ed0120ce7fa46c9dce7ea4b125e2e36bdb63ea33073e7590ac92816ae1e861b7048b03@wonderland", + "object": "xor#wonderland#ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland", "key": "key", "value": "value" } @@ -120,14 +203,16 @@ class SerializerTest { "id": "time_trigger", "action": { "executable": { - "Instructions": [{ - "Mint": { - "Asset": { - "object": "1", - "destination": "xor#wonderland#ed0120ce7fa46c9dce7ea4b125e2e36bdb63ea33073e7590ac92816ae1e861b7048b03@wonderland" + "Instructions": [ + { + "Mint": { + "Asset": { + "object": "1", + "destination": "xor#wonderland#ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland" + } } } - }] + ] }, "repeats": "Indefinitely", "authority": "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland", @@ -139,16 +224,26 @@ class SerializerTest { } } }, - "metadata": {} + "metadata": { + "key": "value" + } } } } } ], + "wasm_dir": "", + "wasm_triggers": [], "topology": [] } """.trimIndent() - val json = JSON_SERDE.writeValueAsString(genesis.transaction).trimIndent() - assertEquals(expectedJson.asPrettyJson().lowercase(), json.asPrettyJson().lowercase()) + val json = JSON_SERDE.writeValueAsString(genesis.transaction) + assertEquals(expectedJson.lowercase(), json.asPrettyJson().lowercase()) } } + +fun String.asPrettyJson(): String { + val gson = GsonBuilder().setPrettyPrinting().create() + val jsonElement = com.google.gson.JsonParser.parseString(this) + return gson.toJson(jsonElement) +} diff --git a/modules/block/src/test/resources/executor.wasm b/modules/block/src/test/resources/executor.wasm index f51b51123..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/build.gradle b/modules/client/build.gradle index f34788b39..2d65e44a7 100644 --- a/modules/client/build.gradle +++ b/modules/client/build.gradle @@ -5,31 +5,22 @@ plugins { dependencies { api project(":model") - implementation('com.google.code.gson:gson:2.8.9') - - implementation("com.github.docker-java:docker-java:3.3.0") - - // kotlin support - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVer" - implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVer" - implementation "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:$coroutinesVer" - - // crypto - api "org.bouncycastle:bcprov-jdk15on:$bouncyCastleVer" - api "net.i2p.crypto:eddsa:$i2pCryptoEddsa" - api "com.github.multiformats:java-multihash:$multihashVersion" + testImplementation project(":admin-client") + testImplementation project(":block") // http client - api "io.ktor:ktor-client-core:$ktorVer" - api "io.ktor:ktor-client-cio:$ktorVer" - api "io.ktor:ktor-client-websockets:$ktorVer" - api "io.ktor:ktor-client-logging:$ktorVer" - api "io.ktor:ktor-client-jackson:$ktorVer" - api "io.ktor:ktor-client-content-negotiation:$ktorVer" - api "io.ktor:ktor-serialization-jackson:$ktorVer" - api "io.ktor:ktor-client-auth:$ktorVer" + implementation "io.ktor:ktor-client-cio:$ktorVer" + implementation "io.ktor:ktor-client-websockets:$ktorVer" + implementation "io.ktor:ktor-client-logging:$ktorVer" + implementation "io.ktor:ktor-client-content-negotiation:$ktorVer" + implementation "io.ktor:ktor-serialization-jackson:$ktorVer" + implementation "io.ktor:ktor-client-auth:$ktorVer" testApi project(":test-tools") + testImplementation "org.jetbrains.kotlin:kotlin-test-junit5:$kotlinVer" + testImplementation("com.github.docker-java:docker-java:3.4.0") + testImplementation("io.qameta.allure:allure-testng:2.29.0") + testImplementation "org.testcontainers:testcontainers:$testContainersVer" } jacocoTestReport { diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Enums.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Enums.kt deleted file mode 100644 index b30ad3963..000000000 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Enums.kt +++ /dev/null @@ -1,48 +0,0 @@ -package jp.co.soramitsu.iroha2 - -enum class Permissions(val type: String) { - CanBurnUserTrigger("CanBurnUserTrigger"), - CanUnregisterAccount("CanUnregisterAccount"), - CanMintUserPublicKeys("CanMintUserPublicKeys"), - CanBurnUserPublicKeys("CanBurnUserPublicKeys"), - CanMintUserSignatureCheckConditions("CanMintUserSignatureCheckConditions"), - CanSetKeyValueInAccount("CanSetKeyValueInAccount"), - CanRemoveKeyValueInAccount("CanRemoveKeyValueInAccount"), - CanRegisterAssetsWithDefinition("CanRegisterAssetsWithDefinition"), - CanUnregisterAssetsWithDefinition("CanUnregisterAssetsWithDefinition"), - CanUnregisterUserAsset("CanUnregisterUserAsset"), - CanBurnAssetWithDefinition("CanBurnAssetWithDefinition"), - CanBurnUserAssetToken("CanBurnUserAsset"), - CanMintAssetWithDefinition("CanMintAssetWithDefinition"), - CanTransferAssetWithDefinition("CanTransferAssetWithDefinition"), - CanTransferUserAssetsToken("CanTransferUserAsset"), - CanSetKeyValueInUserAsset("CanSetKeyValueInUserAsset"), - CanRemoveKeyValueInUserAsset("CanRemoveKeyValueInUserAsset"), - CanUnregisterAssetDefinition("CanUnregisterAssetDefinition"), - CanSetKeyValueInAssetDefinition("CanSetKeyValueInAssetDefinition"), - CanRemoveKeyValueInAssetDefinition("CanRemoveKeyValueInAssetDefinition"), - CanUnregisterDomain("CanUnregisterDomain"), - CanSetKeyValueInDomain("CanSetKeyValueInDomain"), - CanRemoveKeyValueInDomain("CanRemoveKeyValueInDomain"), - CanGrantPermissionToCreateParameters("CanGrantPermissionToCreateParameters"), - CanRevokePermissionToCreateParameters("CanRevokePermissionToCreateParameters"), - CanCreateParameters("CanCreateParameters"), - CanGrantPermissionToSetParameters("CanGrantPermissionToSetParameters"), - CanRevokePermissionToSetParameters("CanRevokePermissionToSetParameters"), - CanSetParameters("CanSetParameters"), - CanUnregisterAnyPeer("CanUnregisterAnyPeer"), - CanUnregisterAnyRole("CanUnregisterAnyRole"), - CanExecuteUserTrigger("CanExecuteUserTrigger"), - CanUnregisterUserTrigger("CanUnregisterUserTrigger"), - CanMintUserTrigger("CanMintUserTrigger"), - CanUpgradeExecutor("CanUpgradeExecutor"), - CanRemoveKeyValueInTrigger("CanRemoveKeyValueInTrigger"), - CanSetKeyValueInTrigger("CanSetKeyValueInTrigger"), -} - -enum class IdKey(val type: String) { - AccountId("account"), - AssetId("asset"), - AssetDefinitionId("asset_definition"), - DomainId("domain"), -} diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Exceptions.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Exceptions.kt index 37c66baa6..208ffacca 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Exceptions.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Exceptions.kt @@ -5,8 +5,7 @@ import io.ktor.http.HttpStatusCode /** * Throw if query payload can not be extracted */ -class QueryPayloadExtractionException(message: String? = null, cause: Throwable? = null) : - IrohaSdkException(message, cause) +class QueryPayloadExtractionException(message: String? = null, cause: Throwable? = null) : IrohaSdkException(message, cause) /** * Throw if there is an unexpected state during WebSocket interaction @@ -25,15 +24,4 @@ class IrohaClientException( /** * Throw if a transaction was rejected by a peer */ -class TransactionRejectedException(message: String? = null, cause: Throwable? = null) : - IrohaSdkException(message, cause) - -/** - * Throw if there is an exception related to cryptography - */ -class CryptoException(message: String? = null, cause: Throwable? = null) : IrohaSdkException(message, cause) - -/** - * Throw if there is an exception during hex encoding/decoding - */ -class HexCodecException(message: String? = null, cause: Throwable? = null) : IrohaSdkException(message, cause) +class TransactionRejectedException(message: String? = null, cause: Throwable? = null) : IrohaSdkException(message, cause) diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Extractors.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Extractors.kt index 4c8781319..80783de13 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Extractors.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Extractors.kt @@ -3,20 +3,16 @@ package jp.co.soramitsu.iroha2 import jp.co.soramitsu.iroha2.generated.Account import jp.co.soramitsu.iroha2.generated.Asset import jp.co.soramitsu.iroha2.generated.AssetDefinition -import jp.co.soramitsu.iroha2.generated.BatchedResponse import jp.co.soramitsu.iroha2.generated.BlockHeader +import jp.co.soramitsu.iroha2.generated.CommittedTransaction import jp.co.soramitsu.iroha2.generated.Domain -import jp.co.soramitsu.iroha2.generated.ExecutorDataModel -import jp.co.soramitsu.iroha2.generated.IdBox -import jp.co.soramitsu.iroha2.generated.IdentifiableBox -import jp.co.soramitsu.iroha2.generated.Numeric -import jp.co.soramitsu.iroha2.generated.Peer +import jp.co.soramitsu.iroha2.generated.PeerId import jp.co.soramitsu.iroha2.generated.Permission -import jp.co.soramitsu.iroha2.generated.QueryOutputBox +import jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox +import jp.co.soramitsu.iroha2.generated.QueryResponse import jp.co.soramitsu.iroha2.generated.Role import jp.co.soramitsu.iroha2.generated.RoleId import jp.co.soramitsu.iroha2.generated.SignedBlock -import jp.co.soramitsu.iroha2.generated.TransactionQueryOutput import jp.co.soramitsu.iroha2.generated.Trigger import jp.co.soramitsu.iroha2.generated.TriggerId @@ -24,301 +20,209 @@ import jp.co.soramitsu.iroha2.generated.TriggerId * Extractors are used by [QueryBuilder] to extract data from query results */ interface ResultExtractor { - fun extract(result: BatchedResponse): T + fun extract(result: QueryResponse): T } /** - * @return the query result as it is + * Extract a list of accounts from a [QueryResponse] */ -object AsIs : ResultExtractor> { - override fun extract(result: BatchedResponse): BatchedResponse = result +object AccountsExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } /** - * Extract an asset from a query [result] + * Extract an account from a [QueryResponse] */ -object AssetExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): Asset { - return extractIdentifiable(result.cast().batchedResponseV1.batch, IdentifiableBox.Asset::asset) - } +object AccountExtractor : ResultExtractor { + override fun extract(result: QueryResponse): Account = AccountsExtractor.extract(result).first() } /** - * Extract an asset definition from a query [result] + * Extract an account from a [QueryResponse] */ -object AssetDefinitionExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): AssetDefinition { - return extractIdentifiable(result.cast().batchedResponseV1.batch, IdentifiableBox.AssetDefinition::assetDefinition) - } +object AccountOrNullExtractor : ResultExtractor { + override fun extract(result: QueryResponse): Account? = AccountsExtractor.extract(result).firstOrNull() } /** - * Extract an account from a query [result] + * Extract a list of assets from a [QueryResponse] */ -object AccountExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): Account { - return extractIdentifiable(result.cast().batchedResponseV1.batch, IdentifiableBox.Account::account) - } +object AssetsExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } /** - * Extract a list of accounts from a query [result] + * Extract an asset from a [QueryResponse] */ -object AccountsExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractIdentifiable(it, IdentifiableBox.Account::account) - } - } +object AssetExtractor : ResultExtractor { + override fun extract(result: QueryResponse): Asset = AssetsExtractor.extract(result).first() } /** - * Extract a numeric from a query + * Extract an asset from a [QueryResponse] */ -object NumericExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): Numeric { - return result.cast().batchedResponseV1.batch.cast().numeric - } +object AssetOrNullExtractor : ResultExtractor { + override fun extract(result: QueryResponse): Asset? = AssetsExtractor.extract(result).firstOrNull() } /** - * Extract a list of assets from a query [result] + * Extract a list of asset definitions from a [QueryResponse] */ -object AssetsExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractIdentifiable(it, IdentifiableBox.Asset::asset) - } - } +object AssetDefinitionsExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } /** - * Extract a list of asset definitions from a query [result] + * Extract an asset definition from a [QueryResponse] */ -object AssetDefinitionsExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractIdentifiable(it, IdentifiableBox.AssetDefinition::assetDefinition) - } - } +object AssetDefinitionExtractor : ResultExtractor { + override fun extract(result: QueryResponse): AssetDefinition = AssetDefinitionsExtractor.extract(result).first() } /** - * Extract a domain from a query [result] + * Extract an asset definition from a [QueryResponse] */ -object DomainExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): Domain { - return extractIdentifiable(result.cast().batchedResponseV1.batch, IdentifiableBox.Domain::domain) - } +object AssetDefinitionOrNullExtractor : ResultExtractor { + override fun extract(result: QueryResponse): AssetDefinition? = AssetDefinitionsExtractor.extract(result).firstOrNull() } /** - * Extract a list of domains from a query [result] + * Extract a list of domains from a [QueryResponse] */ object DomainsExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractIdentifiable(it, IdentifiableBox.Domain::domain) - } - } + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } /** - * Extract a lost of peers from a query [result] + * Extract a domain from a [QueryResponse] */ -object PeersExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractIdentifiable(it, IdentifiableBox.Peer::peer) - } - } +object DomainExtractor : ResultExtractor { + override fun extract(result: QueryResponse): Domain = DomainsExtractor.extract(result).first() } /** - * Extract a trigger from a query [result] + * Extract a domain from a [QueryResponse] */ -object TriggerBoxExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): Trigger { - return extractIdentifiable( - result.cast().batchedResponseV1.batch, - IdentifiableBox.Trigger::trigger, - ) - } +object DomainOrNullExtractor : ResultExtractor { + override fun extract(result: QueryResponse): Domain? = DomainsExtractor.extract(result).firstOrNull() } /** - * Extract a list of triggers from a query [result] + * Extract a lost of peers from a [QueryResponse] */ -object TriggerBoxesExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractIdentifiable(it, IdentifiableBox.Trigger::trigger) - } - } +object PeersExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } /** - * Extract a list of trigger IDs from a query [result] + * Extract a trigger from a [QueryResponse] */ -object TriggerIdsExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractValue(it, QueryOutputBox.Id::idBox).cast().triggerId - } - } +object TriggerExtractor : ResultExtractor { + override fun extract(result: QueryResponse): Trigger = TriggersExtractor.extract(result).first() } /** - * Extract a list of permission tokens from a query [result] + * Extract a trigger from a [QueryResponse] */ -object PermissionTokensExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractValue(it, QueryOutputBox.Permission::permission) - } - } +object TriggerOrNullExtractor : ResultExtractor { + override fun extract(result: QueryResponse): Trigger? = TriggersExtractor.extract(result).firstOrNull() } /** - * Extract a permission token schema from a query [result] + * Extract a list of triggers from a [QueryResponse] */ -object ExecutorDataModelExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): ExecutorDataModel { - return extractValue(result.cast().batchedResponseV1.batch, QueryOutputBox.ExecutorDataModel::executorDataModel) - } +object TriggersExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } /** -* Extract a list of transaction values from a query [result] -*/ -object TransactionValuesExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractValue(it, QueryOutputBox.Transaction::transactionQueryOutput) - } - } -} - -/** -* Extract a transaction value from a query [result] -*/ -object TransactionValueExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): TransactionQueryOutput { - return extractValue(result.cast().batchedResponseV1.batch, QueryOutputBox.Transaction::transactionQueryOutput) - } -} - -object BlocksValueExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractValue(it, QueryOutputBox.Block::signedBlock) - } - } -} - -object BlockHeadersExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractValue(it, QueryOutputBox.BlockHeader::blockHeader) - } - } -} - -object BlockHeaderExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): BlockHeader { - return extractValue(result.cast().batchedResponseV1.batch, QueryOutputBox.BlockHeader::blockHeader) - } + * Extract a list of trigger IDs from a [QueryResponse] + */ +object TriggerIdsExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } /** - * Extract `String` from a query [result] + * Extract a list of permission tokens from a [QueryResponse] */ -object StringExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): String { - return result.cast().batchedResponseV1.batch - .cast().string - .fromJsonString() - } +object PermissionTokensExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } /** - * Extract a list of roles from a query [result] + * Extract a list of commited transactions from a [QueryResponse] */ -object RolesExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractIdentifiable(it, IdentifiableBox.Role::role) - } - } +object TransactionsExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } -/** - * Extract a role from a query [result] - */ -object RoleExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): Role { - return extractIdentifiable(result.cast().batchedResponseV1.batch, IdentifiableBox.Role::role) - } +object BlocksValueExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } -/** - * Extract a list of role IDs from a query [result] - */ -object RoleIdsExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractValue(it, QueryOutputBox.Id::idBox).cast().roleId - } - } +object BlockHeadersExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } /** - * Extract one of the [IdentifiableBox] objects from value - * - * @param downstream Type to extract + * Extract a list of roles from a [QueryResponse] */ -inline fun extractIdentifiable(value: QueryOutputBox, downstream: (I) -> R): R { - return when (value) { - is QueryOutputBox.Identifiable -> when (val box = value.identifiableBox) { - is I -> downstream(box) - else -> throw QueryPayloadExtractionException( - "Expected `${I::class.qualifiedName}`, but got `${box::class.qualifiedName}`", - ) - } - - else -> throw QueryPayloadExtractionException( - "Expected `${QueryOutputBox.Identifiable::class.qualifiedName}`, but got `${value::class.qualifiedName}`", - ) - } +object RolesExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } /** - * Extract collection from `Value.Vec` - * - * @param downstream Type to extract + * Extract a list of role IDs from a [QueryResponse] */ -inline fun extractVec(value: QueryOutputBox, downstream: (QueryOutputBox) -> R): List { - when (value) { - is QueryOutputBox.Vec -> { - return value.vec.map { downstream(it) } - } - - else -> throw QueryPayloadExtractionException( - "Expected `${QueryOutputBox.Vec::class.qualifiedName}`, but got `${value::class.qualifiedName}`", - ) - } +object RoleIdsExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = extract( + result.cast().queryOutput.batch.tuple.takeIf { it.size == 1 }!!.first(), + ) } /** - * Extract value - * - * @param downstream Type to extract + * Extract collection from `Value.Vec` */ -inline fun extractValue(value: QueryOutputBox, downstream: (V) -> R): R { - return when (value) { - is V -> downstream(value) - else -> throw QueryPayloadExtractionException( - "Expected `${V::class.qualifiedName}`, but got `${value::class.qualifiedName}`", - ) - } +inline fun extract(value: QueryOutputBatchBox): List = when (value) { + is QueryOutputBatchBox.Asset -> value.vec.cast>() + is QueryOutputBatchBox.AssetDefinition -> value.vec.cast>() + is QueryOutputBatchBox.Account -> value.vec.cast>() + is QueryOutputBatchBox.Domain -> value.vec.cast>() + is QueryOutputBatchBox.Peer -> value.vec.cast>() + is QueryOutputBatchBox.Permission -> value.vec.cast>() + is QueryOutputBatchBox.Block -> value.vec.cast>() + is QueryOutputBatchBox.BlockHeader -> value.vec.cast>() + is QueryOutputBatchBox.Trigger -> value.vec.cast>() + is QueryOutputBatchBox.Role -> value.vec.cast>() + is QueryOutputBatchBox.RoleId -> value.vec.cast>() + is QueryOutputBatchBox.TriggerId -> value.vec.cast>() + is QueryOutputBatchBox.CommittedTransaction -> value.vec.cast>() + + else -> throw QueryPayloadExtractionException( + "Unexpected type `${value::class.qualifiedName}`", + ) } diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/Iroha2AsyncClient.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/Iroha2AsyncClient.kt index a3893fc0c..e50c6d190 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/Iroha2AsyncClient.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/Iroha2AsyncClient.kt @@ -1,61 +1,45 @@ package jp.co.soramitsu.iroha2.client import io.ktor.client.plugins.logging.LogLevel +import jp.co.soramitsu.iroha2.generated.AccountId import jp.co.soramitsu.iroha2.generated.SignedTransaction -import jp.co.soramitsu.iroha2.model.IrohaUrls import jp.co.soramitsu.iroha2.query.QueryAndExtractor import kotlinx.coroutines.future.asCompletableFuture import kotlinx.coroutines.future.future import kotlinx.coroutines.runBlocking +import java.net.URL +import java.security.KeyPair +import java.util.UUID import java.util.concurrent.CompletableFuture +import java.util.concurrent.Future /** * Extension of [Iroha2Client] for Java */ @Suppress("unused") class Iroha2AsyncClient @JvmOverloads constructor( - urls: List, + override val apiURL: List, + override val chain: UUID, + override val authority: AccountId, + override val keyPair: KeyPair, httpLogLevel: LogLevel = LogLevel.NONE, credentials: String? = null, eventReadTimeoutInMills: Long = 250, eventReadMaxAttempts: Int = 10, -) : Iroha2Client(urls, httpLogLevel, credentials, eventReadTimeoutInMills, eventReadMaxAttempts) { +) : Iroha2Client(apiURL, chain, authority, keyPair, credentials, httpLogLevel, eventReadTimeoutInMills, eventReadMaxAttempts) { /** * Send a request to Iroha2 and extract payload. * {@see Extractors} */ - fun sendQueryAsync( - queryAndExtractor: QueryAndExtractor, - ): CompletableFuture = future { - sendQuery(queryAndExtractor) + fun sendQueryAsync(queryAndExtractor: QueryAndExtractor): CompletableFuture = future { + submit(queryAndExtractor) } /** * Send a transaction to an Iroha peer and wait until it is committed or rejected. */ - fun sendTransactionAsync( - transaction: SignedTransaction, - ): CompletableFuture = runBlocking { - sendTransaction { transaction }.asCompletableFuture() + fun sendTransactionAsync(transaction: SignedTransaction): Future = runBlocking { + submit(transaction).asCompletableFuture() } - - /** - * Send a transaction to an Iroha peer without waiting for the final transaction status (committed or rejected). - * - * With this method, the state of the transaction is not tracked after the peer responses with 2xx status code, - * which means that the peer accepted the transaction and the transaction passed the stateless validation. - */ - fun fireAndForgetAsync( - transaction: SignedTransaction, - ): CompletableFuture = future { - fireAndForget { transaction } - } - - /** - * Subscribe to track the transaction status - */ - fun subscribeToTransactionStatusAsync( - hash: ByteArray, - ) = subscribeToTransactionStatus(hash).asCompletableFuture() } diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/Iroha2Client.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/Iroha2Client.kt index a438acd5e..09657adbc 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/Iroha2Client.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/Iroha2Client.kt @@ -1,5 +1,3 @@ -@file:Suppress("UNCHECKED_CAST") - package jp.co.soramitsu.iroha2.client import com.fasterxml.jackson.core.JsonParser @@ -31,6 +29,7 @@ import io.ktor.websocket.readBytes import jp.co.soramitsu.iroha2.IrohaClientException import jp.co.soramitsu.iroha2.TransactionRejectedException import jp.co.soramitsu.iroha2.WebSocketProtocolException +import jp.co.soramitsu.iroha2.asHashOf import jp.co.soramitsu.iroha2.cast import jp.co.soramitsu.iroha2.client.balancing.RoundRobinStrategy import jp.co.soramitsu.iroha2.client.blockstream.BlockStreamContext @@ -38,29 +37,33 @@ import jp.co.soramitsu.iroha2.client.blockstream.BlockStreamStorage import jp.co.soramitsu.iroha2.client.blockstream.BlockStreamSubscription import jp.co.soramitsu.iroha2.extract import jp.co.soramitsu.iroha2.extractBlock -import jp.co.soramitsu.iroha2.generated.BatchedResponse -import jp.co.soramitsu.iroha2.generated.BatchedResponseV1 +import jp.co.soramitsu.iroha2.generated.AccountId +import jp.co.soramitsu.iroha2.generated.BlockEventFilter import jp.co.soramitsu.iroha2.generated.BlockMessage +import jp.co.soramitsu.iroha2.generated.BlockStatus import jp.co.soramitsu.iroha2.generated.EventBox +import jp.co.soramitsu.iroha2.generated.EventFilterBox import jp.co.soramitsu.iroha2.generated.EventMessage import jp.co.soramitsu.iroha2.generated.EventSubscriptionRequest import jp.co.soramitsu.iroha2.generated.ForwardCursor import jp.co.soramitsu.iroha2.generated.PipelineEventBox -import jp.co.soramitsu.iroha2.generated.QueryOutputBox +import jp.co.soramitsu.iroha2.generated.PipelineEventFilterBox +import jp.co.soramitsu.iroha2.generated.QueryResponse import jp.co.soramitsu.iroha2.generated.SignedQuery import jp.co.soramitsu.iroha2.generated.SignedTransaction +import jp.co.soramitsu.iroha2.generated.TransactionEventFilter import jp.co.soramitsu.iroha2.generated.TransactionRejectionReason import jp.co.soramitsu.iroha2.generated.TransactionStatus import jp.co.soramitsu.iroha2.hash import jp.co.soramitsu.iroha2.height -import jp.co.soramitsu.iroha2.model.IrohaUrls import jp.co.soramitsu.iroha2.query.QueryAndExtractor -import jp.co.soramitsu.iroha2.toFrame +import jp.co.soramitsu.iroha2.query.QueryBuilder import jp.co.soramitsu.iroha2.toHex -import jp.co.soramitsu.iroha2.transaction.Filters +import jp.co.soramitsu.iroha2.transaction.Instruction import jp.co.soramitsu.iroha2.transaction.TransactionBuilder import kotlinx.coroutines.CompletableDeferred import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Deferred import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.SupervisorJob import kotlinx.coroutines.coroutineScope @@ -71,7 +74,9 @@ import org.slf4j.Logger import org.slf4j.LoggerFactory import java.math.BigInteger import java.net.URL +import java.security.KeyPair import java.time.Duration +import java.util.UUID import kotlin.coroutines.CoroutineContext /** @@ -79,63 +84,27 @@ import kotlin.coroutines.CoroutineContext * * @param credentials : */ -@Suppress("unused") open class Iroha2Client( - open val urls: List, - open val httpLogLevel: LogLevel = LogLevel.NONE, + open val apiURL: List, + open val chain: UUID, + open val authority: AccountId, + open val keyPair: KeyPair, open val credentials: String? = null, + open val httpLogLevel: LogLevel = LogLevel.NONE, open val eventReadTimeoutInMills: Long = 250, open val eventReadMaxAttempts: Int = 10, override val coroutineContext: CoroutineContext = Dispatchers.IO + SupervisorJob(), -) : AutoCloseable, CoroutineScope, RoundRobinStrategy(urls) { - - constructor( - url: IrohaUrls, - httpLogLevel: LogLevel = LogLevel.NONE, - credentials: String? = null, - eventReadTimeoutInMills: Long = 250, - eventReadMaxAttempts: Int = 10, - ) : this(mutableListOf(url), httpLogLevel, credentials, eventReadTimeoutInMills, eventReadMaxAttempts) - - constructor( - apiUrl: URL, - peerUrl: URL, - httpLogLevel: LogLevel = LogLevel.NONE, - credentials: String? = null, - eventReadTimeoutInMills: Long = 250, - eventReadMaxAttempts: Int = 10, - ) : this( - IrohaUrls(apiUrl, peerUrl), - httpLogLevel, - credentials, - eventReadTimeoutInMills, - eventReadMaxAttempts, - ) - - constructor( - apiUrl: String, - peerUrl: String, - httpLogLevel: LogLevel = LogLevel.NONE, - credentials: String? = null, - eventReadTimeoutInMills: Long = 250, - eventReadMaxAttempts: Int = 10, - ) : this( - URL(apiUrl), - URL(peerUrl), - httpLogLevel, - credentials, - eventReadTimeoutInMills, - eventReadMaxAttempts, - ) - +) : RoundRobinStrategy(apiURL), + AutoCloseable, + CoroutineScope { companion object { const val TRANSACTION_ENDPOINT = "/transaction" - const val PENDING_TRANSACTIONS_ENDPOINT = "/pending_transactions" const val QUERY_ENDPOINT = "/query" const val WS_ENDPOINT = "/events" const val WS_ENDPOINT_BLOCK_STREAM = "/block/stream" const val HEALTH_ENDPOINT = "/health" const val STATUS_ENDPOINT = "/status" + const val PEERS_ENDPOINT = "/peers" const val SCHEMA_ENDPOINT = "/schema" const val METRICS_ENDPOINT = "/metrics" const val CONFIGURATION_ENDPOINT = "/configuration" @@ -181,30 +150,34 @@ open class Iroha2Client( } } + suspend fun submit(vararg instructions: Instruction): Deferred = coroutineScope { + submit(TransactionBuilder(chain).addInstructions(*instructions).signAs(authority, keyPair)) + } + suspend fun submit(signedTransaction: SignedTransaction): Deferred = coroutineScope { + val lock = Mutex(locked = true) + subscribeToTransactionStatus(signedTransaction.hash()) { + lock.unlock() // 2. unlock after subscription + }.also { + lock.lock() // 1. waiting for unlock + fireAndForget(signedTransaction) + } + } + + /** + * Send a request to Iroha2 and extract paginated payload + */ + suspend fun submit(query: QueryBuilder): R = submit(query.signAs(authority, keyPair)) + /** * Send a request to Iroha2 and extract paginated payload */ - suspend fun sendQuery( - queryAndExtractor: QueryAndExtractor, - cursor: ForwardCursor? = null, - ): T { + suspend fun submit(queryAndExtractor: QueryAndExtractor, cursor: ForwardCursor? = null): T { logger.debug("Sending query") - val responseDecoded = sendQueryRequest(queryAndExtractor, cursor) - val decodedCursor = responseDecoded.cast().batchedResponseV1.cursor - val finalResult = when (decodedCursor.cursor) { - null -> responseDecoded.let { queryAndExtractor.resultExtractor.extract(it) } - else -> { - val resultList = getQueryResultWithCursor(queryAndExtractor, decodedCursor) - resultList.addAll( - responseDecoded.cast() - .batchedResponseV1.batch.cast().vec, - ) - BatchedResponse.V1( - BatchedResponseV1(QueryOutputBox.Vec(resultList), ForwardCursor()), - ).let { queryAndExtractor.resultExtractor.extract(it) } - } - } - return finalResult + val query = queryAndExtractor.query + val extractor = queryAndExtractor.extractor + + val responseDecoded = sendQueryRequest(query, cursor) + return responseDecoded.let { extractor.extract(it) } } /** @@ -213,11 +186,10 @@ open class Iroha2Client( * With this method, the state of the transaction is not tracked after the peer responses with 2xx status code, * which means that the peer accepted the transaction and the transaction passed the stateless validation. */ - suspend fun fireAndForget(transaction: TransactionBuilder.() -> SignedTransaction): ByteArray { - val signedTransaction = transaction(TransactionBuilder.builder()) + private suspend fun fireAndForget(signedTransaction: SignedTransaction): ByteArray { val hash = signedTransaction.hash() logger.debug("Sending transaction with hash {}", hash.toHex()) - val response: HttpResponse = client.post("${getApiUrl()}$TRANSACTION_ENDPOINT") { + val response: HttpResponse = client.post("${getApiURL()}${TRANSACTION_ENDPOINT}") { setBody(SignedTransaction.encode(signedTransaction)) } response.body() @@ -225,31 +197,116 @@ open class Iroha2Client( } /** - * Send a transaction to an Iroha peer and wait until it is committed or rejected. + * Read the message from the frame */ - suspend fun sendTransaction( - transaction: TransactionBuilder.() -> SignedTransaction, - ): CompletableDeferred = coroutineScope { - val signedTransaction = transaction(TransactionBuilder()) + private fun readMessage(frame: Frame): EventMessage = when (frame) { + is Frame.Binary -> { + frame.readBytes().let { + EventMessage.decode(it) + } + } - val lock = Mutex(locked = true) - subscribeToTransactionStatus(signedTransaction.hash()) { - lock.unlock() // 2. unlock after subscription - }.also { - lock.lock() // 1. waiting for unlock - fireAndForget { signedTransaction } + else -> throw WebSocketProtocolException( + "Expected server will `${Frame.Binary::class.qualifiedName}` frame, but was `${frame::class.qualifiedName}`", + ) + } + + private fun eventSubscriberMessageOf(hash: ByteArray) = EventSubscriptionRequest( + listOf( + EventFilterBox.Pipeline(PipelineEventFilterBox.Transaction(TransactionEventFilter(hash.asHashOf()))), + EventFilterBox.Pipeline(PipelineEventFilterBox.Block(BlockEventFilter(status = BlockStatus.Applied()))), + ), + ) + + /** + * Extract the rejection reason + */ + private fun TransactionRejectionReason.message(): String = when (this) { + is TransactionRejectionReason.InstructionExecution -> this.instructionExecutionFail.reason + is TransactionRejectionReason.WasmExecution -> this.wasmExecutionFail.reason + is TransactionRejectionReason.LimitCheck -> this.transactionLimitError.reason + is TransactionRejectionReason.AccountDoesNotExist -> this.findError.extract() + is TransactionRejectionReason.Validation -> this.validationFail.toString() + } + + /** + * @param hash - Signed transaction hash + * @param afterSubscription - Expression that is invoked after subscription + */ + private fun subscribeToTransactionStatus(hash: ByteArray, afterSubscription: (() -> Unit)? = null): Deferred { + val hexHash = hash.toHex() + logger.debug("Creating subscription to transaction status: {}", hexHash) + + val subscriptionRequest = eventSubscriberMessageOf(hash) + val payload = EventSubscriptionRequest.encode(subscriptionRequest) + val result: CompletableDeferred = CompletableDeferred() + val currApiURL = getApiURL() + + launch { + client.webSocket( + host = currApiURL.host, + port = currApiURL.port, + path = WS_ENDPOINT, + ) { + logger.debug("WebSocket opened") + send(Frame.Binary(true, payload)) + + afterSubscription?.invoke() + logger.debug("Subscription was accepted by peer") + + var blockHeight: BigInteger? = null + for (i in 1..eventReadMaxAttempts) { + try { + val event = (readMessage(incoming.receive()).eventBox as EventBox.Pipeline).pipelineEventBox + + if (event is PipelineEventBox.Block) { + if (event.blockEvent.status is BlockStatus.Applied && blockHeight == event.blockEvent.header.height.u64) { + logger.debug("Transaction {} applied", hexHash) + result.complete(hash) + break + } + } else if (event is PipelineEventBox.Transaction) { + when (val status = event.transactionEvent.status) { + is TransactionStatus.Queued -> logger.debug("Transaction {} is queued", hexHash) + + is TransactionStatus.Rejected -> { + val reason = status.transactionRejectionReason.message() + logger.error("Transaction {} was rejected by reason: `{}`", hexHash, reason) + throw TransactionRejectedException("$hexHash: $reason") + } + + is TransactionStatus.Approved -> { + if (hash.contentEquals(event.transactionEvent.hash.hash.arrayOfU8)) { + blockHeight = event.transactionEvent.blockHeight!!.u64 + logger.debug("Transaction {} approved", hexHash) + } + } + + is TransactionStatus.Expired -> throw TransactionRejectedException("Transaction expired") + } + } + } catch (e: TransactionRejectedException) { + result.completeExceptionally(e) + break + } + + delay(eventReadTimeoutInMills) + } + } } + + return result } /** - * @see subscribeToBlockStream below + * @see blocks below */ @JvmOverloads - fun subscribeToBlockStream( + fun blocks( from: Long = 1, count: Long, autoStart: Boolean = true, - ): Pair, BlockStreamSubscription> = subscribeToBlockStream( + ): Pair, BlockStreamSubscription> = blocks( from, onBlock = { block -> block }, cancelIf = { block -> block.extractBlock().height().u64 == BigInteger.valueOf(from + count - 1) }, @@ -266,7 +323,7 @@ open class Iroha2Client( * @param onClose - the code that will be invoked right before closing */ @JvmOverloads - fun subscribeToBlockStream( + fun blocks( from: Long = 1, onBlock: (block: BlockMessage) -> Any, onFailure: suspend (t: Throwable) -> Unit = { throwable -> @@ -275,7 +332,7 @@ open class Iroha2Client( cancelIf: suspend (block: BlockMessage) -> Boolean = { false }, onClose: () -> Unit = { logger.info("Block stream subscription execution was finished") }, autoStart: Boolean = true, - ): Pair, BlockStreamSubscription> = subscribeToBlockStream( + ): Pair, BlockStreamSubscription> = blocks( from, listOf( BlockStreamStorage( @@ -299,14 +356,14 @@ open class Iroha2Client( * otherwise calling 'start' method required */ @JvmOverloads - fun subscribeToBlockStream( + fun blocks( from: Long = 1, blockStreamStorages: Iterable, onClose: () -> Unit = { logger.info("Block stream subscription execution was finished") }, autoStart: Boolean = true, ): Pair, BlockStreamSubscription> { val context = BlockStreamContext( - getApiUrl(), + getApiURL(), client, from, blockStreamStorages, @@ -316,160 +373,19 @@ open class Iroha2Client( .apply { if (autoStart) start() } } - /** - * Subscribe to track the transaction status - */ - fun subscribeToTransactionStatus(hash: ByteArray) = subscribeToTransactionStatus(hash, null) - - private suspend fun sendQueryRequest( - queryAndExtractor: QueryAndExtractor, - cursor: ForwardCursor? = null, - ): BatchedResponse { - val response: HttpResponse = client.post("${getApiUrl()}$QUERY_ENDPOINT") { + private suspend fun sendQueryRequest(query: SignedQuery, cursor: ForwardCursor? = null): QueryResponse { + val response: HttpResponse = client.post("${getApiURL()}$QUERY_ENDPOINT") { if (cursor != null) { parameter("query", cursor.query) - parameter("cursor", cursor.cursor?.u64) + parameter("cursor", cursor.cursor.u64) } else { - setBody(SignedQuery.encode(queryAndExtractor.query)) - } - } - return response.body().let { BatchedResponse.decode(it) }.cast>() - } - - private suspend fun getQueryResultWithCursor( - queryAndExtractor: QueryAndExtractor, - queryCursor: ForwardCursor? = null, - ): MutableList { - val resultList = mutableListOf() - val responseDecoded = sendQueryRequest(queryAndExtractor, queryCursor) - resultList.addAll( - responseDecoded.cast().batchedResponseV1.batch.cast().vec, - ) - val cursor = responseDecoded.cast().batchedResponseV1.cursor - return when (cursor.cursor) { - null -> resultList - else -> { - resultList.addAll(getQueryResultWithCursor(queryAndExtractor, cursor)) - resultList - } - } - } - - /** - * @param hash - Signed transaction hash - * @param afterSubscription - Expression that is invoked after subscription - */ - private fun subscribeToTransactionStatus( - hash: ByteArray, - afterSubscription: (() -> Unit)? = null, - ): CompletableDeferred { - val hexHash = hash.toHex() - logger.debug("Creating subscription to transaction status: {}", hexHash) - - val subscriptionRequest = eventSubscriberMessageOf(hash) - val payload = EventSubscriptionRequest.encode(subscriptionRequest) - val result: CompletableDeferred = CompletableDeferred() - val apiUrl = getApiUrl() - - launch { - client.webSocket( - host = apiUrl.host, - port = apiUrl.port, - path = WS_ENDPOINT, - ) { - logger.debug("WebSocket opened") - send(payload.toFrame()) - - afterSubscription?.invoke() - logger.debug("Subscription was accepted by peer") - - for (i in 1..eventReadMaxAttempts) { - try { - val income = readMessage(incoming.receive()) - val processed = pipelineEventProcess(income, hash, hexHash) - if (processed != null) { - result.complete(processed) - break - } - } catch (e: TransactionRejectedException) { - result.completeExceptionally(e) - break - } - delay(eventReadTimeoutInMills) - } - } - } - return result - } - - private fun pipelineEventProcess( - eventPublisherMessage: EventMessage, - hash: ByteArray, - hexHash: String, - ): ByteArray? { - when (val event = eventPublisherMessage.eventBox) { - is EventBox.Pipeline -> { - val eventBox = event.pipelineEventBox - if (eventBox is PipelineEventBox.Transaction && hash.contentEquals(eventBox.transactionEvent.hash.hash.arrayOfU8)) { - when (val status = eventBox.transactionEvent.status) { - is TransactionStatus.Approved -> { - logger.debug("Transaction {} approved", hexHash) - return hash - } - - is TransactionStatus.Rejected -> { - val reason = status.transactionRejectionReason.message() - logger.error("Transaction {} was rejected by reason: `{}`", hexHash, reason) - throw TransactionRejectedException("Transaction rejected with reason '$reason'") - } - - is TransactionStatus.Expired -> logger.debug("Transaction {} is expired", hexHash) - is TransactionStatus.Queued -> logger.debug("Transaction {} is queued", hexHash) - } - } - return null + setBody(SignedQuery.encode(query)) } - - else -> throw WebSocketProtocolException( - "Expected message with type ${EventBox.Pipeline::class.qualifiedName}, " + - "but was ${event::class.qualifiedName}", - ) } + return response.body().let { QueryResponse.decode(it) }.cast() } - /** - * Extract the rejection reason - */ - private fun TransactionRejectionReason.message(): String = when (this) { - is TransactionRejectionReason.InstructionExecution -> this.instructionExecutionFail.reason - is TransactionRejectionReason.WasmExecution -> this.wasmExecutionFail.reason - is TransactionRejectionReason.LimitCheck -> this.transactionLimitError.reason - is TransactionRejectionReason.AccountDoesNotExist -> this.findError.extract() - is TransactionRejectionReason.Validation -> this.validationFail.toString() - } - - /** - * Read the message from the frame - */ - private fun readMessage(frame: Frame): EventMessage = when (frame) { - is Frame.Binary -> { - frame.readBytes().let { - EventMessage.decode(it) - } - } - - else -> throw WebSocketProtocolException( - "Expected server will `${Frame.Binary::class.qualifiedName}` frame, but was `${frame::class.qualifiedName}`", - ) - } - - private fun eventSubscriberMessageOf( - hash: ByteArray, - ) = EventSubscriptionRequest( - listOf(Filters.pipelineTransaction(hash)), - ) - - object DurationDeserializer : JsonDeserializer() { + private object DurationDeserializer : JsonDeserializer() { override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Duration { val pairs: Map = p.readValueAs(object : TypeReference>() {}) diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/balancing/BalancingStrategy.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/balancing/BalancingStrategy.kt index ee7748371..af4b2fd95 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/balancing/BalancingStrategy.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/balancing/BalancingStrategy.kt @@ -3,7 +3,5 @@ package jp.co.soramitsu.iroha2.client.balancing import java.net.URL interface BalancingStrategy { - fun getApiUrl(): URL - - fun getPeerUrl(): URL + fun getApiURL(): URL } diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/balancing/RoundRobinStrategy.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/balancing/RoundRobinStrategy.kt index 323a27e66..6d523641c 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/balancing/RoundRobinStrategy.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/balancing/RoundRobinStrategy.kt @@ -1,18 +1,15 @@ package jp.co.soramitsu.iroha2.client.balancing -import jp.co.soramitsu.iroha2.model.IrohaUrls import java.net.URL /** * Round-robin load balancing strategy */ -open class RoundRobinStrategy(private val urls: List) : BalancingStrategy { +open class RoundRobinStrategy(private val urls: List) : BalancingStrategy { private var lastRequestedPeerIdx: Int? = null - override fun getApiUrl(): URL = getUrls().apiUrl - - override fun getPeerUrl(): URL = getUrls().peerUrl + override fun getApiURL(): URL = getUrls() private fun getUrls() = when (lastRequestedPeerIdx) { null -> urls.first().also { lastRequestedPeerIdx = 0 } diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/balancing/WithoutBalancingStrategy.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/balancing/WithoutBalancingStrategy.kt index 4edb430d0..7f6a21f4b 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/balancing/WithoutBalancingStrategy.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/balancing/WithoutBalancingStrategy.kt @@ -4,7 +4,5 @@ import jp.co.soramitsu.iroha2.model.IrohaUrls import java.net.URL open class WithoutBalancingStrategy(private val urls: List) : BalancingStrategy { - override fun getApiUrl(): URL = urls.first().apiUrl - - override fun getPeerUrl(): URL = urls.first().peerUrl + override fun getApiURL(): URL = urls.first().apiUrl } diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/blockstream/BlockStreamSubscription.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/blockstream/BlockStreamSubscription.kt index 314143344..ee343ebd6 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/blockstream/BlockStreamSubscription.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/client/blockstream/BlockStreamSubscription.kt @@ -2,6 +2,7 @@ package jp.co.soramitsu.iroha2.client.blockstream import io.ktor.client.plugins.websocket.webSocket import io.ktor.http.HttpMethod +import io.ktor.websocket.Frame import io.ktor.websocket.close import io.ktor.websocket.readBytes import jp.co.soramitsu.iroha2.IrohaSdkException @@ -11,7 +12,6 @@ import jp.co.soramitsu.iroha2.client.Iroha2Client import jp.co.soramitsu.iroha2.generated.BlockMessage import jp.co.soramitsu.iroha2.generated.BlockSubscriptionRequest import jp.co.soramitsu.iroha2.generated.NonZeroOfu64 -import jp.co.soramitsu.iroha2.toFrame import kotlinx.coroutines.CancellationException import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.DelicateCoroutinesApi @@ -35,9 +35,9 @@ import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.atomic.AtomicBoolean import kotlin.coroutines.CoroutineContext -open class BlockStreamSubscription private constructor( - private val context: BlockStreamContext, -) : CoroutineScope, AutoCloseable { +open class BlockStreamSubscription private constructor(private val context: BlockStreamContext) : + CoroutineScope, + AutoCloseable { override val coroutineContext: CoroutineContext = Dispatchers.IO @@ -114,7 +114,7 @@ open class BlockStreamSubscription private constructor( ) { try { logger.debug("WebSocket opened") - send(BlockSubscriptionRequest.encode(request).toFrame()) + send(Frame.Binary(true, BlockSubscriptionRequest.encode(request))) val idsToRemove = mutableListOf() for (frame in incoming) { diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/model/IrohaUrls.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/model/IrohaUrls.kt index 1f89cd0bc..fece20f72 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/model/IrohaUrls.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/model/IrohaUrls.kt @@ -1,10 +1,11 @@ package jp.co.soramitsu.iroha2.model +import java.net.URI import java.net.URL data class IrohaUrls(val apiUrl: URL, val peerUrl: URL) { constructor( apiUrl: String, peerUrl: String, - ) : this(URL(apiUrl), URL(peerUrl)) + ) : this(URI(apiUrl).toURL(), URI(peerUrl).toURL()) } diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/query/Queries.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/query/Queries.kt index 4535ee41f..253461c8c 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/query/Queries.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/query/Queries.kt @@ -1,318 +1,246 @@ package jp.co.soramitsu.iroha2.query import jp.co.soramitsu.iroha2.generated.AccountId +import jp.co.soramitsu.iroha2.generated.AccountProjectionOfSelectorMarker import jp.co.soramitsu.iroha2.generated.AssetDefinitionId -import jp.co.soramitsu.iroha2.generated.AssetId -import jp.co.soramitsu.iroha2.generated.DomainId -import jp.co.soramitsu.iroha2.generated.FindAccountById -import jp.co.soramitsu.iroha2.generated.FindAccountKeyValueByIdAndKey -import jp.co.soramitsu.iroha2.generated.FindAccountsByDomainId +import jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfSelectorMarker +import jp.co.soramitsu.iroha2.generated.AssetProjectionOfSelectorMarker +import jp.co.soramitsu.iroha2.generated.CommittedTransactionProjectionOfSelectorMarker +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccount +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAsset +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerId +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRole +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleId +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTrigger +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId +import jp.co.soramitsu.iroha2.generated.DomainProjectionOfSelectorMarker +import jp.co.soramitsu.iroha2.generated.FindAccounts import jp.co.soramitsu.iroha2.generated.FindAccountsWithAsset -import jp.co.soramitsu.iroha2.generated.FindAllAccounts -import jp.co.soramitsu.iroha2.generated.FindAllActiveTriggerIds -import jp.co.soramitsu.iroha2.generated.FindAllAssets -import jp.co.soramitsu.iroha2.generated.FindAllAssetsDefinitions -import jp.co.soramitsu.iroha2.generated.FindAllBlockHeaders -import jp.co.soramitsu.iroha2.generated.FindAllBlocks -import jp.co.soramitsu.iroha2.generated.FindAllDomains -import jp.co.soramitsu.iroha2.generated.FindAllParameters -import jp.co.soramitsu.iroha2.generated.FindAllPeers -import jp.co.soramitsu.iroha2.generated.FindAllRoleIds -import jp.co.soramitsu.iroha2.generated.FindAllRoles -import jp.co.soramitsu.iroha2.generated.FindAllTransactions -import jp.co.soramitsu.iroha2.generated.FindAssetById -import jp.co.soramitsu.iroha2.generated.FindAssetDefinitionById -import jp.co.soramitsu.iroha2.generated.FindAssetDefinitionKeyValueByIdAndKey -import jp.co.soramitsu.iroha2.generated.FindAssetKeyValueByIdAndKey -import jp.co.soramitsu.iroha2.generated.FindAssetQuantityById -import jp.co.soramitsu.iroha2.generated.FindAssetsByAccountId -import jp.co.soramitsu.iroha2.generated.FindAssetsByAssetDefinitionId -import jp.co.soramitsu.iroha2.generated.FindAssetsByDomainId -import jp.co.soramitsu.iroha2.generated.FindAssetsByDomainIdAndAssetDefinitionId -import jp.co.soramitsu.iroha2.generated.FindAssetsByName -import jp.co.soramitsu.iroha2.generated.FindBlockHeaderByHash -import jp.co.soramitsu.iroha2.generated.FindDomainById -import jp.co.soramitsu.iroha2.generated.FindDomainKeyValueByIdAndKey +import jp.co.soramitsu.iroha2.generated.FindActiveTriggerIds +import jp.co.soramitsu.iroha2.generated.FindAssets +import jp.co.soramitsu.iroha2.generated.FindAssetsDefinitions +import jp.co.soramitsu.iroha2.generated.FindBlocks +import jp.co.soramitsu.iroha2.generated.FindDomains import jp.co.soramitsu.iroha2.generated.FindExecutorDataModel +import jp.co.soramitsu.iroha2.generated.FindParameters +import jp.co.soramitsu.iroha2.generated.FindPeers import jp.co.soramitsu.iroha2.generated.FindPermissionsByAccountId -import jp.co.soramitsu.iroha2.generated.FindRoleByRoleId +import jp.co.soramitsu.iroha2.generated.FindRoles import jp.co.soramitsu.iroha2.generated.FindRolesByAccountId -import jp.co.soramitsu.iroha2.generated.FindTotalAssetQuantityByAssetDefinitionId -import jp.co.soramitsu.iroha2.generated.FindTransactionByHash -import jp.co.soramitsu.iroha2.generated.FindTransactionsByAccountId -import jp.co.soramitsu.iroha2.generated.FindTriggerById -import jp.co.soramitsu.iroha2.generated.FindTriggerKeyValueByIdAndKey -import jp.co.soramitsu.iroha2.generated.FindTriggersByAuthorityDomainId -import jp.co.soramitsu.iroha2.generated.FindTriggersByAuthorityId -import jp.co.soramitsu.iroha2.generated.Hash -import jp.co.soramitsu.iroha2.generated.HashOf -import jp.co.soramitsu.iroha2.generated.Name +import jp.co.soramitsu.iroha2.generated.FindTransactions +import jp.co.soramitsu.iroha2.generated.FindTriggers +import jp.co.soramitsu.iroha2.generated.PeerIdProjectionOfSelectorMarker +import jp.co.soramitsu.iroha2.generated.PermissionProjectionOfSelectorMarker import jp.co.soramitsu.iroha2.generated.QueryBox -import jp.co.soramitsu.iroha2.generated.RoleId -import jp.co.soramitsu.iroha2.generated.SignedTransaction -import jp.co.soramitsu.iroha2.generated.TriggerId +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindAccounts +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindAccountsWithAsset +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindActiveTriggerIds +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindAssets +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindAssetsDefinitions +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindBlocks +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindDomains +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindPeers +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindPermissionsByAccountId +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindRoles +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindRolesByAccountId +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindTransactions +import jp.co.soramitsu.iroha2.generated.QueryWithFilterOfFindTriggers +import jp.co.soramitsu.iroha2.generated.RoleIdProjectionOfSelectorMarker +import jp.co.soramitsu.iroha2.generated.RoleProjectionOfSelectorMarker +import jp.co.soramitsu.iroha2.generated.SelectorTupleOfAccount +import jp.co.soramitsu.iroha2.generated.SelectorTupleOfAsset +import jp.co.soramitsu.iroha2.generated.SelectorTupleOfAssetDefinition +import jp.co.soramitsu.iroha2.generated.SelectorTupleOfCommittedTransaction +import jp.co.soramitsu.iroha2.generated.SelectorTupleOfDomain +import jp.co.soramitsu.iroha2.generated.SelectorTupleOfPeerId +import jp.co.soramitsu.iroha2.generated.SelectorTupleOfPermission +import jp.co.soramitsu.iroha2.generated.SelectorTupleOfRole +import jp.co.soramitsu.iroha2.generated.SelectorTupleOfRoleId +import jp.co.soramitsu.iroha2.generated.SelectorTupleOfSignedBlock +import jp.co.soramitsu.iroha2.generated.SelectorTupleOfTrigger +import jp.co.soramitsu.iroha2.generated.SelectorTupleOfTriggerId +import jp.co.soramitsu.iroha2.generated.SignedBlockProjectionOfSelectorMarker +import jp.co.soramitsu.iroha2.generated.SingularQueryBox +import jp.co.soramitsu.iroha2.generated.TriggerIdProjectionOfSelectorMarker +import jp.co.soramitsu.iroha2.generated.TriggerProjectionOfSelectorMarker /** * Queries are sent to an Iroha peer and prompt a response with details from the current world state view. */ object Queries { - - /** - * Find all accounts registered globally in the blockchain - */ - fun findAllAccounts() = QueryBox.FindAllAccounts(FindAllAccounts()) - - /** - * Return the full account information corresponding to the given [AccountId] - */ - fun findAccountById(accountId: AccountId) = QueryBox.FindAccountById(FindAccountById(accountId)) - - /** - * Return the value keyed by the provided [Name] for the given [AccountId] - */ - fun findAccountKeyValueByIdAndKey(accountId: AccountId, key: Name) = QueryBox.FindAccountKeyValueByIdAndKey( - FindAccountKeyValueByIdAndKey(accountId, key), - ) - - /** - * Return all the accounts that belong to a specific domain [DomainId] - */ - fun findAccountsByDomainId(domainId: DomainId) = QueryBox.FindAccountsByDomainId( - FindAccountsByDomainId(domainId), - ) - - /** - * Return all the accounts that belong to a specific asset definition [AssetDefinitionId] - */ - fun findAccountsWithAsset(definitionId: AssetDefinitionId) = QueryBox.FindAccountsWithAsset( - FindAccountsWithAsset(definitionId), - ) - - /** - * Return the values of all known assets - */ - fun findAllAssets() = QueryBox.FindAllAssets(FindAllAssets()) - - /** - * Return the aggregated data about the [AssetId] usage across the network - */ - fun findAssetById(assetId: AssetId) = QueryBox.FindAssetById(FindAssetById(assetId)) - - /** - * Return all the assets that are registered in the given domain [DomainId] - */ - fun findAssetsByDomainId(domainId: DomainId) = QueryBox.FindAssetsByDomainId( - FindAssetsByDomainId(domainId), - ) - /** - * Search the network for all assets that match the given [Name] - */ - fun findAssetsByName(name: Name) = QueryBox.FindAssetsByName(FindAssetsByName(name)) - - /** - * Return all the assets that belong to a given [AccountId] - */ - fun findAssetsByAccountId(accountId: AccountId) = QueryBox.FindAssetsByAccountId( - FindAssetsByAccountId(accountId), - ) - - /** - * Search for all the assets that have the given [AssetDefinitionId] - */ - fun findAssetsByAssetDefinitionId(assetDefinition: AssetDefinitionId) = QueryBox.FindAssetsByAssetDefinitionId( - FindAssetsByAssetDefinitionId(assetDefinition), + * Return all peers (peers are identified by their public key) + */ + fun findPeers(predicate: CompoundPredicateOfPeerId? = null) = QueryBox.FindPeers( + QueryWithFilterOfFindPeers( + FindPeers(), + predicate ?: CompoundPredicateOfPeerId.And(emptyList()), + SelectorTupleOfPeerId( + listOf( + PeerIdProjectionOfSelectorMarker.Atom(), + ), + ), + ), ) /** - * Search the domain with the [DomainId] for assets that have the given [AssetDefinitionId] + * Return all domains */ - fun findAssetsByDomainIdAndAssetDefinitionId( - domainId: DomainId, - assetDefinition: AssetDefinitionId, - ) = QueryBox.FindAssetsByDomainIdAndAssetDefinitionId( - FindAssetsByDomainIdAndAssetDefinitionId( - domainId, - assetDefinition, + fun findDomains(predicate: CompoundPredicateOfDomain? = null) = QueryBox.FindDomains( + QueryWithFilterOfFindDomains( + FindDomains(), + predicate ?: CompoundPredicateOfDomain.And(emptyList()), + SelectorTupleOfDomain(listOf(DomainProjectionOfSelectorMarker.Atom())), ), ) /** * Return the values of all known asset definitions */ - fun findAllAssetsDefinitions() = QueryBox.FindAllAssetsDefinitions(FindAllAssetsDefinitions()) - - /** - * Return the asset quantity for the given asset with [AssetId] - */ - fun findAssetQuantityById(assetId: AssetId) = QueryBox.FindAssetQuantityById( - FindAssetQuantityById(assetId), - ) - - /** - * Return the asset quantity for the given asset with [AssetDefinitionId] - */ - fun findTotalAssetQuantityByAssetDefinitionId( - definitionId: AssetDefinitionId, - ) = QueryBox.FindTotalAssetQuantityByAssetDefinitionId( - FindTotalAssetQuantityByAssetDefinitionId(definitionId), - ) - - /** - * Return the value keyed by the given [Name] in the metadata of the asset corresponding to the given [AssetId] - */ - fun findAssetKeyValueByIdAndKey(assetId: AssetId, key: Name) = QueryBox.FindAssetKeyValueByIdAndKey( - FindAssetKeyValueByIdAndKey(assetId, key), - ) - - /** - * Return the value keyed by the given [Name] - * in the metadata of the asset definition corresponding to the given [AssetDefinitionId] - */ - fun findAssetDefinitionKeyValueByIdAndKey( - assetDefinition: AssetDefinitionId, - key: Name, - ) = QueryBox.FindAssetDefinitionKeyValueByIdAndKey( - FindAssetDefinitionKeyValueByIdAndKey( - assetDefinition, - key, + fun findAssetsDefinitions(predicate: CompoundPredicateOfAssetDefinition? = null) = QueryBox.FindAssetsDefinitions( + QueryWithFilterOfFindAssetsDefinitions( + FindAssetsDefinitions(), + predicate ?: CompoundPredicateOfAssetDefinition.And(emptyList()), + SelectorTupleOfAssetDefinition(listOf(AssetDefinitionProjectionOfSelectorMarker.Atom())), ), ) /** - * Return the asset definition corresponding to the given [AssetDefinitionId] + * Return all accounts */ - fun findAssetDefinitionById(definitionId: AssetDefinitionId) = QueryBox.FindAssetDefinitionById( - FindAssetDefinitionById(definitionId), + fun findAccounts(predicate: CompoundPredicateOfAccount? = null) = QueryBox.FindAccounts( + QueryWithFilterOfFindAccounts( + FindAccounts(), + predicate ?: CompoundPredicateOfAccount.And(emptyList()), + SelectorTupleOfAccount(listOf(AccountProjectionOfSelectorMarker.Atom())), + ), ) /** - * Return all known registered domains + * Return all accounts that contain an asset of the given definition */ - fun findAllDomains() = QueryBox.FindAllDomains(FindAllDomains()) + fun findAccountsWithAsset(definitionId: AssetDefinitionId, predicate: CompoundPredicateOfAccount? = null) = + QueryBox.FindAccountsWithAsset( + QueryWithFilterOfFindAccountsWithAsset( + FindAccountsWithAsset(definitionId), + predicate ?: CompoundPredicateOfAccount.And(emptyList()), + SelectorTupleOfAccount(listOf(AccountProjectionOfSelectorMarker.Atom())), + ), + ) /** - * Return the domain corresponding to the given [DomainId] + * Return the all assets */ - fun findDomainById(domainId: DomainId) = QueryBox.FindDomainById(FindDomainById(domainId)) - - /** - * Return all known peers identified by their key and accompanied by the address of their API endpoint - */ - fun findAllPeers() = QueryBox.FindAllPeers(FindAllPeers()) - - /** - * Return the full set of transactions that an account with [AccountId] has submitted throughout the existence of the blockchain - */ - fun findTransactionsByAccountId(accountId: AccountId) = QueryBox.FindTransactionsByAccountId( - FindTransactionsByAccountId(accountId), + fun findAssets(predicate: CompoundPredicateOfAsset? = null) = QueryBox.FindAssets( + QueryWithFilterOfFindAssets( + FindAssets(), + predicate ?: CompoundPredicateOfAsset.And(emptyList()), + SelectorTupleOfAsset(listOf(AssetProjectionOfSelectorMarker.Atom())), + ), ) /** * Return all the permission tokens granted to the specified [AccountId] */ - fun findPermissionsByAccountId(accountId: AccountId) = QueryBox.FindPermissionsByAccountId( - FindPermissionsByAccountId(accountId), - ) - - /** - * Return executor data model - */ - fun findExecutorDataModel() = QueryBox.FindExecutorDataModel( - FindExecutorDataModel(), - ) - - /** - * Return the transaction by [Hash] - */ - fun findTransactionByHash(hash: Hash) = QueryBox.FindTransactionByHash( - FindTransactionByHash(HashOf(hash)), + fun findPermissionsByAccountId(accountId: AccountId, predicate: CompoundPredicateOfPermission? = null) = + QueryBox.FindPermissionsByAccountId( + QueryWithFilterOfFindPermissionsByAccountId( + FindPermissionsByAccountId(accountId), + predicate ?: CompoundPredicateOfPermission.And(emptyList()), + SelectorTupleOfPermission( + listOf( + PermissionProjectionOfSelectorMarker.Atom(), + ), + ), + ), + ) + + /** + * Return the full set of roles + */ + fun findRoles(predicate: CompoundPredicateOfRole? = null) = QueryBox.FindRoles( + QueryWithFilterOfFindRoles( + FindRoles(), + predicate ?: CompoundPredicateOfRole.And(emptyList()), + SelectorTupleOfRole(listOf(RoleProjectionOfSelectorMarker.Atom())), + ), ) /** * Return all the role IDs that are attached to the given [AccountId] */ - fun findRolesByAccountId(accountId: AccountId) = QueryBox.FindRolesByAccountId( - FindRolesByAccountId(accountId), - ) - - /** - * Return all roles - */ - fun findAllRoles() = QueryBox.FindAllRoles(FindAllRoles()) - - /** - * Return the role by [RoleId] - */ - fun findRoleByRoleId(roleId: RoleId) = QueryBox.FindRoleByRoleId(FindRoleByRoleId(roleId)) - - /** - * Return all role IDs - */ - fun findAllRoleIds() = QueryBox.FindAllRoleIds(FindAllRoleIds()) - - /** - * Return the value keyed by the given [Name] in the domain corresponding to the given [DomainId] - */ - fun findDomainKeyValueByIdAndKey(id: DomainId, key: Name) = QueryBox.FindDomainKeyValueByIdAndKey( - FindDomainKeyValueByIdAndKey(id, key), + fun findRolesByAccountId(accountId: AccountId, predicate: CompoundPredicateOfRoleId? = null) = QueryBox.FindRolesByAccountId( + QueryWithFilterOfFindRolesByAccountId( + FindRolesByAccountId(accountId), + predicate ?: CompoundPredicateOfRoleId.And(emptyList()), + SelectorTupleOfRoleId(listOf(RoleIdProjectionOfSelectorMarker.Atom())), + ), ) /** - * Return the value corresponding to the given key [Name] in the metadata of the trigger with the given [TriggerId] + * Return all currently triggers */ - fun findTriggerKeyValueByIdAndKey(id: TriggerId, key: Name) = QueryBox.FindTriggerKeyValueByIdAndKey( - FindTriggerKeyValueByIdAndKey(id, key), + fun findTriggers(predicate: CompoundPredicateOfTrigger? = null) = QueryBox.FindTriggers( + QueryWithFilterOfFindTriggers( + FindTriggers(), + predicate ?: CompoundPredicateOfTrigger.And(emptyList()), + SelectorTupleOfTrigger(listOf(TriggerProjectionOfSelectorMarker.Atom())), + ), ) /** - * Return the trigger with the given [TriggerId] - */ - fun findTriggerById(id: TriggerId) = QueryBox.FindTriggerById(FindTriggerById(id)) - - /** - * Return all currently active triggers, that have not expired at the time of the query - */ - fun findAllActiveTriggerIds() = QueryBox.FindAllActiveTriggerIds(FindAllActiveTriggerIds()) - - /** - * Return a trigger with the given [AccountId] + * Return all active trigger IDs */ - fun findTriggersByAuthorityId(id: AccountId) = QueryBox.FindTriggersByAuthorityId( - FindTriggersByAuthorityId(id), + fun findActiveTriggerIds(predicate: CompoundPredicateOfTriggerId? = null) = QueryBox.FindActiveTriggerIds( + QueryWithFilterOfFindActiveTriggerIds( + FindActiveTriggerIds(), + predicate ?: CompoundPredicateOfTriggerId.And(emptyList()), + SelectorTupleOfTriggerId(listOf(TriggerIdProjectionOfSelectorMarker.Atom())), + ), ) /** - * Return all currently triggers with the given [DomainId] + * Return the full set of transactions */ - fun findTriggersByAuthorityDomainId(domainId: DomainId) = QueryBox.FindTriggersByAuthorityDomainId( - FindTriggersByAuthorityDomainId(domainId), + fun findTransactions(predicate: CompoundPredicateOfCommittedTransaction? = null) = QueryBox.FindTransactions( + QueryWithFilterOfFindTransactions( + FindTransactions(), + predicate ?: CompoundPredicateOfCommittedTransaction.And(emptyList()), + SelectorTupleOfCommittedTransaction( + listOf( + CommittedTransactionProjectionOfSelectorMarker.Atom(), + ), + ), + ), ) /** * Return all blocks */ - fun findAllBlocks() = QueryBox.FindAllBlocks(FindAllBlocks()) - - /** - * Return all block headers - */ - fun findAllBlockHeaders() = QueryBox.FindAllBlockHeaders(FindAllBlockHeaders()) - - /** - * Return the block header corresponding to the given [Hash] - */ - fun findBlockHeaderByHash(hash: Hash) = QueryBox.FindBlockHeaderByHash( - FindBlockHeaderByHash(HashOf(hash)), + fun findBlocks(predicate: CompoundPredicateOfSignedBlock? = null) = QueryBox.FindBlocks( + QueryWithFilterOfFindBlocks( + FindBlocks(), + predicate ?: CompoundPredicateOfSignedBlock.And(emptyList()), + SelectorTupleOfSignedBlock(listOf(SignedBlockProjectionOfSelectorMarker.Atom())), + ), ) /** - * Return all transactions + * Return current executor data model */ - fun findAllTransactions() = QueryBox.FindAllTransactions(FindAllTransactions()) + fun findExecutorDataModel() = SingularQueryBox.FindExecutorDataModel( + FindExecutorDataModel(), + ) /** - * Return all parameters + * Return current parameter values (including custom) */ - fun findAllParameters() = QueryBox.FindAllParameters(FindAllParameters()) + fun findParameters() = SingularQueryBox.FindParameters( + FindParameters(), + ) } diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/query/QueryBuilder.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/query/QueryBuilder.kt index a3a471647..d6d5b7cfd 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/query/QueryBuilder.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/query/QueryBuilder.kt @@ -1,75 +1,85 @@ package jp.co.soramitsu.iroha2.query -import jp.co.soramitsu.iroha2.AccountExtractor +import jp.co.soramitsu.iroha2.AccountOrNullExtractor import jp.co.soramitsu.iroha2.AccountsExtractor -import jp.co.soramitsu.iroha2.AssetDefinitionExtractor +import jp.co.soramitsu.iroha2.AssetDefinitionOrNullExtractor import jp.co.soramitsu.iroha2.AssetDefinitionsExtractor -import jp.co.soramitsu.iroha2.AssetExtractor +import jp.co.soramitsu.iroha2.AssetOrNullExtractor import jp.co.soramitsu.iroha2.AssetsExtractor -import jp.co.soramitsu.iroha2.BlockHeaderExtractor -import jp.co.soramitsu.iroha2.BlockHeadersExtractor import jp.co.soramitsu.iroha2.BlocksValueExtractor -import jp.co.soramitsu.iroha2.DomainExtractor +import jp.co.soramitsu.iroha2.DomainOrNullExtractor import jp.co.soramitsu.iroha2.DomainsExtractor -import jp.co.soramitsu.iroha2.ExecutorDataModelExtractor -import jp.co.soramitsu.iroha2.NumericExtractor import jp.co.soramitsu.iroha2.PeersExtractor import jp.co.soramitsu.iroha2.PermissionTokensExtractor import jp.co.soramitsu.iroha2.ResultExtractor -import jp.co.soramitsu.iroha2.RoleExtractor import jp.co.soramitsu.iroha2.RoleIdsExtractor import jp.co.soramitsu.iroha2.RolesExtractor -import jp.co.soramitsu.iroha2.StringExtractor -import jp.co.soramitsu.iroha2.TransactionValueExtractor -import jp.co.soramitsu.iroha2.TransactionValuesExtractor -import jp.co.soramitsu.iroha2.TriggerBoxExtractor -import jp.co.soramitsu.iroha2.TriggerBoxesExtractor +import jp.co.soramitsu.iroha2.TransactionsExtractor import jp.co.soramitsu.iroha2.TriggerIdsExtractor +import jp.co.soramitsu.iroha2.TriggerOrNullExtractor +import jp.co.soramitsu.iroha2.TriggersExtractor import jp.co.soramitsu.iroha2.asName import jp.co.soramitsu.iroha2.asSignatureOf -import jp.co.soramitsu.iroha2.fromHex +import jp.co.soramitsu.iroha2.generated.Account import jp.co.soramitsu.iroha2.generated.AccountId +import jp.co.soramitsu.iroha2.generated.AccountIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.AccountProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.Asset +import jp.co.soramitsu.iroha2.generated.AssetDefinition import jp.co.soramitsu.iroha2.generated.AssetDefinitionId +import jp.co.soramitsu.iroha2.generated.AssetDefinitionIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.AssetDefinitionIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.AssetId -import jp.co.soramitsu.iroha2.generated.ClientQueryPayload +import jp.co.soramitsu.iroha2.generated.AssetIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.AssetProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccount +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAsset +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerId +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRole +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleId +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTrigger +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId +import jp.co.soramitsu.iroha2.generated.Domain import jp.co.soramitsu.iroha2.generated.DomainId +import jp.co.soramitsu.iroha2.generated.DomainIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.DomainIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.DomainProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.FetchSize -import jp.co.soramitsu.iroha2.generated.GenericPredicateBox -import jp.co.soramitsu.iroha2.generated.Hash import jp.co.soramitsu.iroha2.generated.Name -import jp.co.soramitsu.iroha2.generated.NonZeroOfu32 import jp.co.soramitsu.iroha2.generated.NonZeroOfu64 import jp.co.soramitsu.iroha2.generated.Pagination -import jp.co.soramitsu.iroha2.generated.PublicKey import jp.co.soramitsu.iroha2.generated.QueryBox -import jp.co.soramitsu.iroha2.generated.QueryOutputPredicate +import jp.co.soramitsu.iroha2.generated.QueryParams +import jp.co.soramitsu.iroha2.generated.QueryRequest +import jp.co.soramitsu.iroha2.generated.QueryRequestWithAuthority import jp.co.soramitsu.iroha2.generated.QuerySignature -import jp.co.soramitsu.iroha2.generated.RoleId +import jp.co.soramitsu.iroha2.generated.QueryWithParams import jp.co.soramitsu.iroha2.generated.Signature import jp.co.soramitsu.iroha2.generated.SignedQuery import jp.co.soramitsu.iroha2.generated.SignedQueryV1 import jp.co.soramitsu.iroha2.generated.Sorting +import jp.co.soramitsu.iroha2.generated.Trigger import jp.co.soramitsu.iroha2.generated.TriggerId -import jp.co.soramitsu.iroha2.hash -import jp.co.soramitsu.iroha2.sign -import jp.co.soramitsu.iroha2.toIrohaHash +import jp.co.soramitsu.iroha2.generated.TriggerIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.TriggerIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.TriggerProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.signAs import java.math.BigInteger import java.security.KeyPair -class QueryBuilder( - private val query: QueryBox, - private val resultExtractor: ResultExtractor, - private val queryFilter: GenericPredicateBox? = null, -) { - private var accountId: AccountId? = null +class QueryBuilder(val query: QueryBox, val extractor: ResultExtractor) { private var sorting: Sorting? = null private var pagination: Pagination? = null private var fetchSize: FetchSize? = null - fun account(accountId: AccountId) = this.apply { this.accountId = accountId } - - fun account(signatory: PublicKey, domainId: DomainId) = this.account(AccountId(domainId, signatory)) - fun sorting(key: String) = this.apply { this.sorting = Sorting(key.asName()) } @@ -78,370 +88,218 @@ class QueryBuilder( this.sorting = Sorting(key) } - fun pagination(limit: Long? = null, start: BigInteger? = null) = this.apply { - this.pagination = Pagination(limit?.let { NonZeroOfu32(limit) }, start?.let { NonZeroOfu64(start) }) + fun pagination(limit: BigInteger? = null, offset: BigInteger? = null) = this.apply { + this.pagination = Pagination(limit?.let { NonZeroOfu64(limit) }, offset ?: BigInteger.ZERO) } - fun fetchSize(value: Long) = this.apply { - this.fetchSize = FetchSize(NonZeroOfu32(value)) + fun fetchSize(value: BigInteger) = this.apply { + this.fetchSize = FetchSize(NonZeroOfu64(value)) } - fun buildSigned(keyPair: KeyPair): QueryAndExtractor { - val filter = queryFilter ?: GenericPredicateBox.Raw(QueryOutputPredicate.Pass()) - val payload = ClientQueryPayload( - checkNotNull(accountId) { "Account ID of the sender is mandatory" }, - query, - filter, - sorting ?: Sorting(null), - this.pagination ?: Pagination(null, null), - this.fetchSize ?: FetchSize(null), + fun signAs(accountId: AccountId, keyPair: KeyPair): QueryAndExtractor { + val request = QueryRequest.Start( + QueryWithParams( + query, + QueryParams( + this.pagination ?: Pagination(null, BigInteger.ZERO), + this.sorting ?: Sorting(null), + this.fetchSize ?: FetchSize(null), + ), + ), ) - val encodedPayload = ClientQueryPayload.encode(payload) - val signature = QuerySignature(Signature(keyPair.private.sign(encodedPayload)).asSignatureOf()) + val payload = QueryRequestWithAuthority( + accountId, + request, + ) + val encodedPayload = QueryRequestWithAuthority.encode(payload) + val signature = QuerySignature(Signature(keyPair.private.signAs(encodedPayload)).asSignatureOf()) val query = SignedQuery.V1(SignedQueryV1(signature, payload)) - return QueryAndExtractor(query, resultExtractor) + return QueryAndExtractor(query, extractor) } companion object { @JvmStatic - @JvmOverloads - fun findAllAccounts(queryFilter: GenericPredicateBox? = null) = QueryBuilder( - Queries.findAllAccounts(), - AccountsExtractor, - queryFilter, + fun findPeers(predicate: CompoundPredicateOfPeerId? = null) = QueryBuilder( + Queries.findPeers(predicate), + PeersExtractor, ) + /** + * Return all domains + */ @JvmStatic - fun findAccountKeyValueByIdAndKey(accountId: AccountId, key: Name) = QueryBuilder( - Queries.findAccountKeyValueByIdAndKey(accountId, key), - StringExtractor, + fun findDomains(predicate: CompoundPredicateOfDomain? = null) = QueryBuilder( + Queries.findDomains( + predicate, + ), + DomainsExtractor, ) + /** + * Return domain with the given id + */ @JvmStatic - fun findAccountKeyValueByIdAndKey( - accountId: AccountId, - key: String, - ) = findAccountKeyValueByIdAndKey(accountId, key.asName()) - - @JvmStatic - @JvmOverloads - fun findAccountsByDomainId( - domainId: DomainId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder(Queries.findAccountsByDomainId(domainId), AccountsExtractor, queryFilter) - - @JvmStatic - @JvmOverloads - fun findAccountsWithAsset( - definitionId: AssetDefinitionId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder(Queries.findAccountsWithAsset(definitionId), AccountsExtractor, queryFilter) - - @JvmStatic - @JvmOverloads - fun findAllAssets(queryFilter: GenericPredicateBox? = null) = QueryBuilder( - Queries.findAllAssets(), - AssetsExtractor, - queryFilter, - ) + fun findDomainById(domainId: DomainId): QueryBuilder { + val byDomainIdFilter = CompoundPredicateOfDomain.Atom( + DomainProjectionOfPredicateMarker.Id( + DomainIdProjectionOfPredicateMarker.Atom( + DomainIdPredicateAtom.Equals(domainId), + ), + ), + ) + return QueryBuilder( + Queries.findDomains(byDomainIdFilter), + DomainOrNullExtractor, + ) + } @JvmStatic - @JvmOverloads - fun findAllAssetsDefinitions( - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findAllAssetsDefinitions(), + fun findAssetsDefinitions(predicate: CompoundPredicateOfAssetDefinition? = null) = QueryBuilder( + Queries.findAssetsDefinitions(predicate), AssetDefinitionsExtractor, - queryFilter, ) @JvmStatic - @JvmOverloads - fun findAssetsByName( - name: Name, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findAssetsByName(name), - AssetsExtractor, - queryFilter, - ) + fun findAssetDefinitionById(assetDefinitionId: AssetDefinitionId): QueryBuilder { + val byAssetDefinitionIdFilter = CompoundPredicateOfAssetDefinition.Atom( + AssetDefinitionProjectionOfPredicateMarker.Id( + AssetDefinitionIdProjectionOfPredicateMarker.Atom( + AssetDefinitionIdPredicateAtom.Equals(assetDefinitionId), + ), + ), + ) + return QueryBuilder( + Queries.findAssetsDefinitions(byAssetDefinitionIdFilter), + AssetDefinitionOrNullExtractor, + ) + } + /** + * Return the values of all known accounts + */ @JvmStatic - @JvmOverloads - fun findAssetsByAccountId( - accountId: AccountId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findAssetsByAccountId(accountId), - AssetsExtractor, - queryFilter, + fun findAccounts(predicate: CompoundPredicateOfAccount? = null) = QueryBuilder( + Queries.findAccounts(predicate), + AccountsExtractor, ) @JvmStatic - fun findAccountById(accountId: AccountId) = QueryBuilder(Queries.findAccountById(accountId), AccountExtractor) - - @JvmStatic - fun findAssetById(assetId: AssetId) = QueryBuilder(Queries.findAssetById(assetId), AssetExtractor) - - @JvmStatic - @JvmOverloads - fun findAssetsByDomainId( - domainId: DomainId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findAssetsByDomainId(domainId), - AssetsExtractor, - queryFilter, + fun findAccountsWithAsset(definitionId: AssetDefinitionId, predicate: CompoundPredicateOfAccount? = null) = QueryBuilder( + Queries.findAccountsWithAsset( + definitionId, + predicate, + ), + AccountsExtractor, ) @JvmStatic - fun findAssetsByAssetDefinitionId(assetDefinition: AssetDefinitionId) = QueryBuilder( - Queries.findAssetsByAssetDefinitionId(assetDefinition), - AssetsExtractor, - ) + fun findAccountById(accountId: AccountId): QueryBuilder { + val byAccountIdFilter = CompoundPredicateOfAccount.Atom( + AccountProjectionOfPredicateMarker.Id( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals(accountId), + ), + ), + ) - @JvmStatic - @JvmOverloads - fun findAllAssetsDefinitions( - assetDefinition: AssetDefinitionId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findAssetsByAssetDefinitionId(assetDefinition), - AssetDefinitionsExtractor, - queryFilter, - ) + return QueryBuilder(Queries.findAccounts(byAccountIdFilter), AccountOrNullExtractor) + } @JvmStatic - @JvmOverloads - fun findAssetsByDomainIdAndAssetDefinitionId( - domainId: DomainId, - assetDefinition: AssetDefinitionId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findAssetsByDomainIdAndAssetDefinitionId(domainId, assetDefinition), + fun findAssets(predicate: CompoundPredicateOfAsset? = null) = QueryBuilder( + Queries.findAssets(predicate), AssetsExtractor, - queryFilter, - ) - - @JvmStatic - fun findAssetQuantityById(assetId: AssetId) = QueryBuilder( - Queries.findAssetQuantityById(assetId), - NumericExtractor, - ) - - @JvmStatic - fun findTotalAssetQuantityByAssetDefinitionId(definitionId: AssetDefinitionId) = QueryBuilder( - Queries.findTotalAssetQuantityByAssetDefinitionId(definitionId), - NumericExtractor, ) @JvmStatic - fun findAssetKeyValueByIdAndKey(assetId: AssetId, key: Name) = QueryBuilder( - Queries.findAssetKeyValueByIdAndKey(assetId, key), - StringExtractor, - ) - - @JvmStatic - fun findAssetKeyValueByIdAndKey( - assetId: AssetId, - key: String, - ) = findAssetKeyValueByIdAndKey(assetId, key.asName()) - - @JvmStatic - fun findAssetDefinitionKeyValueByIdAndKey(id: AssetDefinitionId, key: Name) = QueryBuilder( - Queries.findAssetDefinitionKeyValueByIdAndKey(id, key), - StringExtractor, - ) - - @JvmStatic - fun findAssetDefinitionKeyValueByIdAndKey( - id: AssetDefinitionId, - key: String, - ) = findAssetDefinitionKeyValueByIdAndKey(id, key.asName()) - - @JvmStatic - fun findDomainKeyValueByIdAndKey(id: DomainId, key: String) = findDomainKeyValueByIdAndKey(id, key.asName()) - - @JvmStatic - fun findDomainKeyValueByIdAndKey(id: DomainId, key: Name) = QueryBuilder( - Queries.findDomainKeyValueByIdAndKey(id, key), - StringExtractor, - ) - - @JvmStatic - @JvmOverloads - fun findAllDomains( - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder(Queries.findAllDomains(), DomainsExtractor, queryFilter) - - @JvmStatic - fun findDomainById(domainId: DomainId) = QueryBuilder(Queries.findDomainById(domainId), DomainExtractor) - - @JvmStatic - @JvmOverloads - fun findAllPeers(queryFilter: GenericPredicateBox? = null) = - QueryBuilder(Queries.findAllPeers(), PeersExtractor, queryFilter) + fun findAssetById(assetId: AssetId): QueryBuilder { + val byAssetIdFilter = CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Atom( + AssetIdPredicateAtom.Equals(assetId), + ), + ), + ) - @JvmStatic - fun findTransactionsByAccountId( - accountId: AccountId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findTransactionsByAccountId(accountId), - TransactionValuesExtractor, - queryFilter, - ) + return QueryBuilder(Queries.findAssets(byAssetIdFilter), AssetOrNullExtractor) + } @JvmStatic - @JvmOverloads - fun findPermissionsByAccountId( - accountId: AccountId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findPermissionsByAccountId(accountId), + fun findPermissionsByAccountId(accountId: AccountId, predicate: CompoundPredicateOfPermission? = null) = QueryBuilder( + Queries.findPermissionsByAccountId( + accountId, + predicate, + ), PermissionTokensExtractor, - queryFilter, - ) - - @JvmStatic - fun findExecutorDataModel( - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findExecutorDataModel(), - ExecutorDataModelExtractor, - queryFilter, ) @JvmStatic - @JvmOverloads - fun findRolesByAccountId(accountId: AccountId, queryFilter: GenericPredicateBox? = null) = - QueryBuilder( - Queries.findRolesByAccountId(accountId), - RoleIdsExtractor, - queryFilter, - ) - - @JvmStatic - @JvmOverloads - fun findAllRoleIds(queryFilter: GenericPredicateBox? = null) = QueryBuilder( - Queries.findAllRoleIds(), - RoleIdsExtractor, - queryFilter, - ) - - @JvmStatic - @JvmOverloads - fun findAllRoles(queryFilter: GenericPredicateBox? = null) = QueryBuilder( - Queries.findAllRoles(), + fun findRoles(predicate: CompoundPredicateOfRole? = null) = QueryBuilder( + Queries.findRoles(predicate ?: CompoundPredicateOfRole.And(emptyList())), RolesExtractor, - queryFilter, ) @JvmStatic - @JvmOverloads - fun findRoleByRoleId(roleId: RoleId, queryFilter: GenericPredicateBox? = null) = - QueryBuilder( - Queries.findRoleByRoleId(roleId), - RoleExtractor, - queryFilter, - ) - - @JvmStatic - fun findTransactionByHash(hash: Hash) = QueryBuilder( - Queries.findTransactionByHash(hash), - TransactionValueExtractor, - ) - - @JvmStatic - fun findTransactionByHash(bytes: ByteArray) = findTransactionByHash(bytes.toIrohaHash()) - - @JvmStatic - fun findTransactionByHash(hex: String) = findTransactionByHash(hex.fromHex().hash().toIrohaHash()) - - @JvmStatic - fun findAllTransactions(queryFilter: GenericPredicateBox? = null) = QueryBuilder( - Queries.findAllTransactions(), - TransactionValuesExtractor, - queryFilter, - ) - - @JvmStatic - @JvmOverloads - fun findAllBlocks(queryFilter: GenericPredicateBox? = null) = QueryBuilder( - Queries.findAllBlocks(), - BlocksValueExtractor, - queryFilter, - ) - - @JvmStatic - @JvmOverloads - fun findAllBlockHeaders(queryFilter: GenericPredicateBox? = null) = QueryBuilder( - Queries.findAllBlockHeaders(), - BlockHeadersExtractor, - queryFilter, - ) - - @JvmStatic - fun findBlockHeaderByHash(hash: Hash) = QueryBuilder( - Queries.findBlockHeaderByHash(hash), - BlockHeaderExtractor, + fun findRoleById(predicate: CompoundPredicateOfRole? = null) = QueryBuilder( + Queries.findRoles(predicate ?: CompoundPredicateOfRole.And(emptyList())), + RoleIdsExtractor, ) @JvmStatic - fun findAssetDefinitionById(definitionId: AssetDefinitionId) = QueryBuilder( - Queries.findAssetDefinitionById(definitionId), - AssetDefinitionExtractor, + fun findRolesByAccountId(accountId: AccountId, predicate: CompoundPredicateOfRoleId? = null) = QueryBuilder( + Queries.findRolesByAccountId( + accountId, + predicate, + ), + RoleIdsExtractor, ) @JvmStatic - fun findTriggerById(id: TriggerId) = QueryBuilder( - Queries.findTriggerById(id), - TriggerBoxExtractor, + fun findTriggers(predicate: CompoundPredicateOfTrigger? = null) = QueryBuilder( + Queries.findTriggers( + predicate, + ), + TriggersExtractor, ) @JvmStatic - fun findTriggerKeyValueByIdAndKey(id: TriggerId, key: Name) = QueryBuilder( - Queries.findTriggerKeyValueByIdAndKey(id, key), - StringExtractor, - ) + fun findTriggerById(triggerId: TriggerId): QueryBuilder { + val byTriggerIdFilter = CompoundPredicateOfTrigger.Atom( + TriggerProjectionOfPredicateMarker.Id( + TriggerIdProjectionOfPredicateMarker.Atom( + TriggerIdPredicateAtom.Equals(triggerId), + ), + ), + ) + return QueryBuilder( + Queries.findTriggers(byTriggerIdFilter), + TriggerOrNullExtractor, + ) + } @JvmStatic - @JvmOverloads - fun findAllActiveTriggerIds(queryFilter: GenericPredicateBox? = null) = QueryBuilder( - Queries.findAllActiveTriggerIds(), + fun findActiveTriggerIds(predicate: CompoundPredicateOfTriggerId? = null) = QueryBuilder( + Queries.findActiveTriggerIds( + predicate, + ), TriggerIdsExtractor, - queryFilter, - ) - - @JvmStatic - @JvmOverloads - fun findTriggersByAuthorityId( - id: AccountId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findTriggersByAuthorityId(id), - TriggerBoxExtractor, - queryFilter, ) @JvmStatic - @JvmOverloads - fun findTriggersByAuthorityDomainId( - domainId: DomainId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findTriggersByAuthorityDomainId(domainId), - TriggerBoxesExtractor, - queryFilter, + fun findTransactions(predicate: CompoundPredicateOfCommittedTransaction? = null) = QueryBuilder( + Queries.findTransactions( + predicate, + ), + TransactionsExtractor, ) @JvmStatic - @JvmOverloads - fun findAllParameters(queryFilter: GenericPredicateBox? = null) = QueryBuilder( - Queries.findAllParameters(), - StringExtractor, - queryFilter, + fun findBlocks(predicate: CompoundPredicateOfSignedBlock? = null) = QueryBuilder( + Queries.findBlocks( + predicate, + ), + BlocksValueExtractor, ) } } @@ -451,4 +309,4 @@ class QueryBuilder( * * [R] is a type of extracted value as a result of query execution */ -class QueryAndExtractor(val query: SignedQuery, val resultExtractor: ResultExtractor) +class QueryAndExtractor(val query: SignedQuery, val extractor: ResultExtractor) diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Instructions.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Instructions.kt deleted file mode 100644 index 7b6134f4b..000000000 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Instructions.kt +++ /dev/null @@ -1,412 +0,0 @@ -package jp.co.soramitsu.iroha2.transaction - -import jp.co.soramitsu.iroha2.Permissions -import jp.co.soramitsu.iroha2.asJsonString -import jp.co.soramitsu.iroha2.asName -import jp.co.soramitsu.iroha2.asNumeric -import jp.co.soramitsu.iroha2.generated.* // ktlint-disable no-wildcard-imports -import java.math.BigDecimal - -/** - * Iroha Special Instructions cover all possible actions within a blockchain - * @see [Iroha2 Tutorial on Iroha Special Instructions](https://hyperledger.github.io/iroha-2-docs/guide/advanced/isi.html) - */ -object Instructions { - - /** - * Register a role that has the specified permissions - */ - fun registerRole( - roleId: RoleId, - vararg tokens: Permission, - ) = InstructionBox.Register( - RegisterBox.Role(RegisterOfRole(Role(roleId, tokens.toList()))), - ) - - /** - * Register an account - */ - @JvmOverloads - fun registerAccount( - id: AccountId, - metadata: Metadata = Metadata(mapOf()), - ) = InstructionBox.Register( - RegisterBox.Account(RegisterOfAccount(NewAccount(id, metadata))), - ) - - /** - * Register a WASM trigger - */ - fun registerTrigger( - triggerId: TriggerId, - wasm: ByteArray, - repeats: Repeats, - accountId: AccountId, - metadata: Metadata, - filter: EventFilterBox, - ) = InstructionBox.Register( - RegisterBox.Trigger( - RegisterOfTrigger( - Trigger( - triggerId, - Action(Executable.Wasm(WasmSmartContract(wasm)), repeats, accountId, filter, metadata), - ), - ), - ), - ) - - /** - * Register a instructions trigger to run after every transaction - */ - fun registerTrigger( - triggerId: TriggerId, - isi: List, - repeats: Repeats, - accountId: AccountId, - metadata: Metadata, - filter: TimeEventFilter, - ) = registerTrigger( - triggerId, - isi, - repeats, - accountId, - metadata, - EventFilterBox.Time(TimeEventFilter(filter.executionTime)), - ) - - /** - * Register a instructions trigger to run after every transaction - */ - fun registerTrigger( - triggerId: TriggerId, - isi: List, - repeats: Repeats, - accountId: AccountId, - metadata: Metadata, - filter: EventFilterBox = EventFilterBox.ExecuteTrigger( - ExecuteTriggerEventFilter(triggerId, accountId), - ), - ) = InstructionBox.Register( - RegisterBox.Trigger( - RegisterOfTrigger( - Trigger( - triggerId, - Action(Executable.Instructions(isi), repeats, accountId, filter, metadata), - ), - ), - ), - ) - - /** - * Unregister a trigger - */ - fun unregisterTrigger(id: TriggerId) = InstructionBox.Unregister( - UnregisterBox.Trigger(UnregisterOfTrigger(id)), - ) - - /** - * Unregister a trigger - */ - fun unregisterTrigger( - triggerName: String, - domainId: DomainId? = null, - ) = unregisterTrigger(TriggerId(triggerName.asName())) - - /** - * Unregister an asset - */ - fun unregisterAsset(id: AssetId) = InstructionBox.Unregister(UnregisterBox.Asset(UnregisterOfAsset(id))) - - /** - * Unregister an asset definition - */ - fun unregisterAssetDefinition(id: AssetDefinitionId) = InstructionBox.Unregister( - UnregisterBox.AssetDefinition( - UnregisterOfAssetDefinition(id), - ), - ) - - /** - * Unregister an account - */ - fun unregisterAccount(id: AccountId) = InstructionBox.Unregister(UnregisterBox.Account(UnregisterOfAccount(id))) - - /** - * Unregister a domain - */ - fun unregisterDomain(id: DomainId) = InstructionBox.Unregister(UnregisterBox.Domain(UnregisterOfDomain(id))) - - /** - * Unregister a role - */ - fun unregisterRole(id: RoleId) = InstructionBox.Unregister(UnregisterBox.Role(UnregisterOfRole(id))) - - /** - * Register an asset - */ - @JvmOverloads - fun registerAssetDefinition( - id: AssetDefinitionId, - assetType: AssetType, - metadata: Metadata = Metadata(mapOf()), - mintable: Mintable = Mintable.Infinitely(), - logo: IpfsPath? = null, - ) = InstructionBox.Register( - RegisterBox.AssetDefinition( - RegisterOfAssetDefinition( - NewAssetDefinition(id, assetType, mintable, logo, metadata), - ), - ), - ) - - /** - * Register an asset - */ - fun registerAsset(id: AssetId, assetValue: AssetValue) = InstructionBox.Register( - RegisterBox.Asset(RegisterOfAsset(Asset(id, assetValue))), - ) - - /** - * Register a domain - */ - @JvmOverloads - fun registerDomain( - domainId: DomainId, - metadata: Map = mapOf(), - logo: IpfsPath? = null, - ) = InstructionBox.Register( - RegisterBox.Domain(RegisterOfDomain(NewDomain(domainId, logo, Metadata(metadata)))), - ) - - /** - * Register a peer - */ - fun registerPeer( - peerId: PeerId, - ) = InstructionBox.Register( - RegisterBox.Peer(RegisterOfPeer(Peer(peerId))), - ) - - /** - * Unregister a peer - */ - fun unregisterPeer(peerId: PeerId) = InstructionBox.Unregister( - UnregisterBox.Peer(UnregisterOfPeer(peerId)), - ) - - /** - * Set key/value for a given asset - */ - fun setKeyValue( - assetId: AssetId, - key: Name, - value: String, - ) = InstructionBox.SetKeyValue( - SetKeyValueBox.Asset( - SetKeyValueOfAsset(assetId, key, value), - ), - ) - - /** - * Set key/value for a given trigger - */ - fun setKeyValue( - triggerId: TriggerId, - key: Name, - value: String, - ) = InstructionBox.SetKeyValue( - SetKeyValueBox.Trigger( - SetKeyValueOfTrigger(triggerId, key, value), - ), - ) - - /** - * Set key/value for a given asset definition - */ - fun setKeyValue( - definitionId: AssetDefinitionId, - key: Name, - value: String, - ) = InstructionBox.SetKeyValue( - SetKeyValueBox.AssetDefinition( - SetKeyValueOfAssetDefinition(definitionId, key, value), - ), - ) - - /** - * Set key/value in the metadata of a given domain - */ - fun setKeyValue( - domainId: DomainId, - key: Name, - value: String, - ) = InstructionBox.SetKeyValue( - SetKeyValueBox.Domain(SetKeyValueOfDomain(domainId, key, value)), - ) - - /** - * Set key/value in the metadata of a given account - */ - fun setKeyValue( - accountId: AccountId, - key: Name, - value: String, - ) = InstructionBox.SetKeyValue( - SetKeyValueBox.Account(SetKeyValueOfAccount(accountId, key, value)), - ) - - /** - * Remove key/value from a given asset - */ - fun removeKeyValue(assetId: AssetId, key: Name) = InstructionBox.RemoveKeyValue( - RemoveKeyValueBox.Asset(RemoveKeyValueOfAsset(assetId, key)), - ) - - /** - * Execute a trigger - */ - fun executeTrigger(triggerId: TriggerId) = InstructionBox.ExecuteTrigger(ExecuteTrigger(triggerId)) - - /** - * Mint an asset of the [AssetType.Quantity] asset value type - */ - fun mintAsset(assetId: AssetId, quantity: Int) = InstructionBox.Mint( - MintBox.Asset(MintOfNumericAndAsset(quantity.asNumeric(), assetId)), - ) - - /** - * Mint an asset of the [AssetType.Fixed] asset value type - */ - fun mintAsset(assetId: AssetId, quantity: BigDecimal) = InstructionBox.Mint( - MintBox.Asset(MintOfNumericAndAsset(quantity.asNumeric(), assetId)), - ) - - /** - * Burn an asset of the [AssetType.Quantity] asset value type - */ - fun burnAsset(assetId: AssetId, value: Int) = InstructionBox.Burn( - BurnBox.Asset(BurnOfNumericAndAsset(value.asNumeric(), assetId)), - ) - - /** - * Burn an asset of the [AssetType.Fixed] asset value type - */ - fun burnAsset(assetId: AssetId, value: BigDecimal) = InstructionBox.Burn( - BurnBox.Asset(BurnOfNumericAndAsset(value.asNumeric(), assetId)), - ) - - /** - * Grant an account the custom permission - */ - fun grantPermissionToken( - permission: Permissions, - payload: String = "null", - destinationId: AccountId, - ) = InstructionBox.Grant( - GrantBox.Permission( - GrantOfPermissionAndAccount( - Permission(permission.type, payload), - destinationId, - ), - ), - ) - - /** - * Grant an account a given role. - */ - fun grantRole(roleId: RoleId, destinationId: AccountId) = InstructionBox.Grant( - GrantBox.Role(GrantOfRoleIdAndAccount(roleId, destinationId)), - ) - - /** - * Transfer an asset from the identifiable source. - */ - fun transferAsset(sourceId: AssetId, value: Int, destinationId: AccountId) = InstructionBox.Transfer( - TransferBox.Asset( - AssetTransferBox.Numeric( - TransferOfAssetAndNumericAndAccount(sourceId, value.asNumeric(), destinationId), - ), - ), - ) - - /** - * Transfer domain ownership. - */ - fun transferDomainOwnership(sourceId: AccountId, domainId: DomainId, destinationId: AccountId) = - InstructionBox.Transfer( - TransferBox.Domain( - TransferOfAccountAndDomainIdAndAccount(sourceId, domainId, destinationId), - ), - ) - - /** - * Revoke an account the [Permissions.CanSetKeyValueInUserAsset] permission - */ - fun revokeSetKeyValueAsset(assetId: AssetId, target: AccountId): InstructionBox { - return revokeSome(target) { - Permission( - name = Permissions.CanSetKeyValueInUserAsset.type, - payload = assetId.asJsonString(), - ) - } - } - - /** - * Revoke an account the [Permissions.CanSetKeyValueInAccount] permission - */ - fun revokeSetKeyValueAccount(accountId: AccountId, target: AccountId): InstructionBox { - return revokeSome(target) { - Permission( - name = Permissions.CanSetKeyValueInAccount.type, - payload = accountId.asJsonString(), - ) - } - } - - /** - * Revoke an account the [Permissions.CanSetKeyValueInDomain] permission - */ - fun grantSetKeyValueDomain(domainId: DomainId, target: AccountId): InstructionBox { - return InstructionBox.Grant( - GrantBox.Permission( - GrantOfPermissionAndAccount( - Permission( - name = Permissions.CanSetKeyValueInDomain.type, - payload = domainId.asJsonString(), - ), - target, - ), - ), - ) - } - - /** - * Revoke an account the [Permissions.CanSetKeyValueInDomain] permission - */ - fun revokeSetKeyValueDomain(domainId: DomainId, target: AccountId): InstructionBox { - return revokeSome(target) { - Permission( - name = Permissions.CanSetKeyValueInDomain.type, - payload = domainId.asJsonString(), - ) - } - } - - /** - * Revoke an account a given role. - */ - fun revokeRole(roleId: RoleId, accountId: AccountId): InstructionBox { - return InstructionBox.Revoke( - RevokeBox.Role(RevokeOfRoleIdAndAccount(roleId, accountId)), - ) - } - - private inline fun revokeSome( - accountId: AccountId, - permission: () -> Permission, - ) = InstructionBox.Revoke( - RevokeBox.Permission( - RevokeOfPermissionAndAccount(permission(), accountId), - ), - ) -} diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/TransactionBuilder.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/TransactionBuilder.kt deleted file mode 100644 index 26a8f4c15..000000000 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/TransactionBuilder.kt +++ /dev/null @@ -1,390 +0,0 @@ -package jp.co.soramitsu.iroha2.transaction - -import jp.co.soramitsu.iroha2.IrohaClientException -import jp.co.soramitsu.iroha2.Permissions -import jp.co.soramitsu.iroha2.U32_MAX_VALUE -import jp.co.soramitsu.iroha2.asName -import jp.co.soramitsu.iroha2.asSignatureOf -import jp.co.soramitsu.iroha2.generated.* // ktlint-disable no-wildcard-imports -import jp.co.soramitsu.iroha2.sign -import java.math.BigDecimal -import java.math.BigInteger -import java.security.KeyPair -import java.time.Duration -import java.time.Instant -import java.util.UUID -import kotlin.random.Random -import kotlin.random.nextLong - -class TransactionBuilder(builder: TransactionBuilder.() -> Unit = {}) { - - var chainId: ChainId? - var accountId: AccountId? - val instructions: Lazy> - var creationTimeMillis: BigInteger? - var timeToLiveMillis: BigInteger? - var nonce: Long? - var metadata: Lazy> - - init { - chainId = ChainId("00000000-0000-0000-0000-000000000000") - accountId = null - instructions = lazy { ArrayList() } - creationTimeMillis = null - timeToLiveMillis = null - nonce = Random.nextLong(0..U32_MAX_VALUE) // UInt32 max value - metadata = lazy { HashMap() } - builder(this) - } - - fun chainId(uuid: UUID) = this.apply { chainId = ChainId(uuid.toString()) } - - fun account(accountId: AccountId) = this.apply { this.accountId = accountId } - - fun account(signatory: PublicKey, domainId: DomainId) = this.account(AccountId(domainId, signatory)) - - fun instructions(vararg instructions: InstructionBox) = this.apply { this.instructions.value.addAll(instructions) } - - fun instructions(instructions: Iterable) = - this.apply { this.instructions.value.addAll(instructions) } - - fun instruction(instruction: InstructionBox) = this.apply { this.instructions.value.add(instruction) } - - fun creationTime(creationTimeMillis: BigInteger) = this.apply { this.creationTimeMillis = creationTimeMillis } - - fun creationTime(creationTime: Instant) = this.apply { this.creationTime(creationTime.toEpochMilli()) } - - fun creationTime(creationTimeMillis: Long) = this.apply { this.creationTime(creationTimeMillis.toBigInteger()) } - - fun timeToLive(ttlMillis: BigInteger) = this.apply { this.timeToLiveMillis = ttlMillis } - - fun timeToLive(ttl: Duration) = this.apply { this.timeToLive(ttl.toMillis()) } - - fun timeToLive(ttlMillis: Long) = this.apply { this.timeToLive(ttlMillis.toBigInteger()) } - - fun buildSigned(keyPair: KeyPair): SignedTransaction { - val payload = TransactionPayload( - checkNotNull(chainId) { "Chain ID is required" }, - checkNotNull(accountId) { "Account Id is required" }, - creationTimeMillis ?: fallbackCreationTime(), - Executable.Instructions(instructions.value), - NonZeroOfu64(timeToLiveMillis ?: DURATION_OF_24_HOURS_IN_MILLIS), - NonZeroOfu32(nonce ?: throw IrohaClientException("Nonce must not be null")), - Metadata(metadata.value), - ) - val encodedPayload = TransactionPayload.encode(payload) - val signature = Signature(keyPair.private.sign(encodedPayload)).asSignatureOf() - - return SignedTransaction.V1( - SignedTransactionV1(TransactionSignature(signature), payload), - ) - } - - @JvmOverloads - fun registerTimeTrigger( - triggerId: TriggerId, - isi: List, - repeats: Repeats, - accountId: AccountId, - filter: TimeEventFilter, - metadata: Metadata = Metadata(mapOf()), - ) = this.apply { - instructions.value.add( - Instructions.registerTrigger( - triggerId, - isi, - repeats, - accountId, - metadata, - filter, - ), - ) - } - - @JvmOverloads - fun registerExecutableTrigger( - triggerId: TriggerId, - isi: List, - repeats: Repeats, - accountId: AccountId, - metadata: Metadata = Metadata(mapOf()), - ) = this.apply { - instructions.value.add( - Instructions.registerTrigger( - triggerId, - isi, - repeats, - accountId, - metadata, - ), - ) - } - - @JvmOverloads - fun registerEventTrigger( - triggerId: TriggerId, - isi: List, - repeats: Repeats, - accountId: AccountId, - metadata: Metadata = Metadata(mapOf()), - filter: EventFilterBox, - ) = this.apply { - instructions.value.add( - Instructions.registerTrigger( - triggerId, - isi, - repeats, - accountId, - metadata, - filter, - ), - ) - } - - @JvmOverloads - fun registerWasmTrigger( - triggerId: TriggerId, - wasm: ByteArray, - repeats: Repeats, - accountId: AccountId, - metadata: Metadata = Metadata(mapOf()), - filter: EventFilterBox, - ) = this.apply { - instructions.value.add( - Instructions.registerTrigger( - triggerId, - wasm, - repeats, - accountId, - metadata, - filter, - ), - ) - } - - @JvmOverloads - fun registerPreCommitTrigger( - triggerId: TriggerId, - isi: List, - repeats: Repeats, - accountId: AccountId, - metadata: Metadata = Metadata(mapOf()), - filter: EventFilterBox = EventFilterBox.Time(TimeEventFilter(ExecutionTime.PreCommit())), - ) = this.apply { - instructions.value.add( - Instructions.registerTrigger( - triggerId, - isi, - repeats, - accountId, - metadata, - filter, - ), - ) - } - - fun unregisterAsset(id: AssetId) = this.apply { - instructions.value.add(Instructions.unregisterAsset(id)) - } - - fun unregisterAssetDefinition(id: AssetDefinitionId) = this.apply { - instructions.value.add(Instructions.unregisterAssetDefinition(id)) - } - - fun unregisterTrigger(id: TriggerId) = this.apply { - instructions.value.add( - Instructions.unregisterTrigger(id), - ) - } - - fun unregisterTrigger(triggerName: String, domainId: DomainId? = null) = this.apply { - instructions.value.add( - Instructions.unregisterTrigger(triggerName, domainId), - ) - } - - fun unregisterAccount(id: AccountId) = this.apply { - instructions.value.add( - Instructions.unregisterAccount(id), - ) - } - - fun unregisterDomain(id: DomainId) = this.apply { - instructions.value.add( - Instructions.unregisterDomain(id), - ) - } - - fun grantRole( - roleId: RoleId, - accountId: AccountId, - ) = this.apply { instructions.value.add(Instructions.grantRole(roleId, accountId)) } - - fun registerRole( - id: RoleId, - vararg tokens: Permission, - ) = this.apply { instructions.value.add(Instructions.registerRole(id, *tokens)) } - - fun unregisterRole( - id: RoleId, - ) = this.apply { instructions.value.add(Instructions.unregisterRole(id)) } - - @JvmOverloads - fun registerAccount( - id: AccountId, - metadata: Metadata = Metadata(mapOf()), - ) = this.apply { instructions.value.add(Instructions.registerAccount(id, metadata)) } - - @JvmOverloads - fun registerAssetDefinition( - id: AssetDefinitionId, - assetValueType: AssetType, - metadata: Metadata = Metadata(mapOf()), - mintable: Mintable = Mintable.Infinitely(), - ) = this.apply { - instructions.value.add( - Instructions.registerAssetDefinition(id, assetValueType, metadata, mintable), - ) - } - - @JvmOverloads - fun registerAssetDefinition( - name: Name, - domainId: DomainId, - assetValueType: AssetType, - metadata: Metadata = Metadata(mapOf()), - mintable: Mintable = Mintable.Infinitely(), - ) = this.apply { - instructions.value.add( - Instructions.registerAssetDefinition(AssetDefinitionId(domainId, name), assetValueType, metadata, mintable), - ) - } - - fun registerAsset( - id: AssetId, - assetValue: AssetValue, - ) = this.apply { instructions.value.add(Instructions.registerAsset(id, assetValue)) } - - fun setKeyValue( - assetId: AssetId, - key: String, - value: String, - ) = this.apply { instructions.value.add(Instructions.setKeyValue(assetId, key.asName(), value)) } - - fun setKeyValue( - assetId: AssetId, - key: Name, - value: String, - ) = this.apply { instructions.value.add(Instructions.setKeyValue(assetId, key, value)) } - - fun setKeyValue( - accountId: AccountId, - key: Name, - value: String, - ) = this.apply { instructions.value.add(Instructions.setKeyValue(accountId, key, value)) } - - fun setKeyValue( - definitionId: AssetDefinitionId, - key: Name, - value: String, - ) = this.apply { instructions.value.add(Instructions.setKeyValue(definitionId, key, value)) } - - fun setKeyValue( - triggerId: TriggerId, - key: Name, - value: String, - ) = this.apply { instructions.value.add(Instructions.setKeyValue(triggerId, key, value)) } - - fun setKeyValue( - domainId: DomainId, - key: Name, - value: String, - ) = this.apply { instructions.value.add(Instructions.setKeyValue(domainId, key, value)) } - - fun removeKeyValue( - assetId: AssetId, - key: Name, - ) = this.apply { instructions.value.add(Instructions.removeKeyValue(assetId, key)) } - - fun removeKeyValue( - assetId: AssetId, - key: String, - ) = removeKeyValue(assetId, key.asName()) - - fun executeTrigger( - triggerId: TriggerId, - ) = this.apply { instructions.value.add(Instructions.executeTrigger(triggerId)) } - - fun mintAsset( - assetId: AssetId, - quantity: Int, - ) = this.apply { instructions.value.add(Instructions.mintAsset(assetId, quantity)) } - - fun mintAsset( - assetId: AssetId, - quantity: BigDecimal, - ) = this.apply { instructions.value.add(Instructions.mintAsset(assetId, quantity)) } - - @JvmOverloads - fun registerDomain( - domainId: DomainId, - metadata: Map = mapOf(), - logo: IpfsPath? = null, - ) = this.apply { - instructions.value.add( - Instructions.registerDomain( - domainId, - metadata, - logo, - ), - ) - } - - fun registerPeer(peerId: PeerId) = this.apply { instructions.value.add(Instructions.registerPeer(peerId)) } - - fun unregisterPeer( - peerId: PeerId, - ) = this.apply { instructions.value.add(Instructions.unregisterPeer(peerId)) } - - fun grantPermissionToken(permission: Permissions, payload: String, target: AccountId) = this.apply { - instructions.value.add(Instructions.grantPermissionToken(permission, payload, target)) - } - - fun burnAsset(assetId: AssetId, value: Int) = this.apply { - instructions.value.add(Instructions.burnAsset(assetId, value)) - } - - fun burnAsset(assetId: AssetId, value: BigDecimal) = this.apply { - instructions.value.add(Instructions.burnAsset(assetId, value)) - } - - fun transferAsset(sourceId: AssetId, value: Int, destinationId: AccountId) = this.apply { - instructions.value.add(Instructions.transferAsset(sourceId, value, destinationId)) - } - - fun transferDomainOwnership(sourceId: AccountId, value: DomainId, destinationId: AccountId) = this.apply { - instructions.value.add(Instructions.transferDomainOwnership(sourceId, value, destinationId)) - } - - fun revokeSetKeyValueAsset(assetId: AssetId, target: AccountId) = - this.apply { instructions.value.add(Instructions.revokeSetKeyValueAsset(assetId, target)) } - - fun revokeSetKeyValueAccount(accountId: AccountId, target: AccountId) = - this.apply { instructions.value.add(Instructions.revokeSetKeyValueAccount(accountId, target)) } - - fun revokeSetKeyValueDomain(domainId: DomainId, target: AccountId) = - this.apply { instructions.value.add(Instructions.revokeSetKeyValueDomain(domainId, target)) } - - fun revokeRole( - roleId: RoleId, - accountId: AccountId, - ) = this.apply { instructions.value.add(Instructions.revokeRole(roleId, accountId)) } - - private fun fallbackCreationTime() = System.currentTimeMillis().toBigInteger() - - companion object { - fun builder() = TransactionBuilder() - - val DURATION_OF_24_HOURS_IN_MILLIS = Duration.ofHours(24).toMillis().toBigInteger() - } -} diff --git a/modules/client/src/test/java/jp/co/soramitsu/iroha2/JavaTest.java b/modules/client/src/test/java/jp/co/soramitsu/iroha2/JavaTest.java index 870a46071..add54a4be 100644 --- a/modules/client/src/test/java/jp/co/soramitsu/iroha2/JavaTest.java +++ b/modules/client/src/test/java/jp/co/soramitsu/iroha2/JavaTest.java @@ -1,210 +1,210 @@ -package jp.co.soramitsu.iroha2; - -import java.security.*; -import java.time.*; -import java.util.*; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; -import static jp.co.soramitsu.iroha2.CryptoUtils.generateKeyPair; -import static jp.co.soramitsu.iroha2.ExtensionsKt.toIrohaPublicKey; -import jp.co.soramitsu.iroha2.client.Iroha2AsyncClient; -import jp.co.soramitsu.iroha2.client.blockstream.*; -import jp.co.soramitsu.iroha2.generated.*; -import jp.co.soramitsu.iroha2.generated.Metadata; -import jp.co.soramitsu.iroha2.query.QueryAndExtractor; -import jp.co.soramitsu.iroha2.query.QueryBuilder; -import jp.co.soramitsu.iroha2.testengine.DefaultGenesis; -import jp.co.soramitsu.iroha2.testengine.IrohaTest; -import jp.co.soramitsu.iroha2.testengine.WithIroha; -import jp.co.soramitsu.iroha2.transaction.TransactionBuilder; -import kotlin.*; -import kotlin.Pair; -import kotlin.coroutines.*; -import kotlinx.coroutines.flow.*; -import org.jetbrains.annotations.*; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Test; - -import static jp.co.soramitsu.iroha2.testengine.TestConstsKt.ALICE_ACCOUNT_ID; -import static jp.co.soramitsu.iroha2.testengine.TestConstsKt.ALICE_KEYPAIR; -import static jp.co.soramitsu.iroha2.testengine.TestConstsKt.DEFAULT_ASSET_DEFINITION_ID; -import static jp.co.soramitsu.iroha2.testengine.TestConstsKt.DEFAULT_ASSET_ID; -import static jp.co.soramitsu.iroha2.testengine.TestConstsKt.DEFAULT_DOMAIN_ID; -import org.junit.jupiter.api.parallel.*; -import static org.testcontainers.shaded.org.apache.commons.lang3.RandomStringUtils.randomAlphabetic; - -public class JavaTest extends IrohaTest { - - @Test - @WithIroha(sources = DefaultGenesis.class) - public void registerDomain() throws ExecutionException, InterruptedException, TimeoutException { - final DomainId domainId = new DomainId(new Name("new_domain_name")); - final SignedTransaction transaction = TransactionBuilder.Companion.builder() - .account(ALICE_ACCOUNT_ID) - .registerDomain(domainId) - .buildSigned(ALICE_KEYPAIR); - client.sendTransactionAsync(transaction).get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); - - final QueryAndExtractor query = QueryBuilder.findDomainById(domainId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR); - final CompletableFuture future = client.sendQueryAsync(query); - final Domain domain = future.get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); - Assertions.assertEquals(domain.getId(), domainId); - } - - @Test - @WithIroha(sources = DefaultGenesis.class) - public void registerAccount() throws Exception { - final KeyPair keyPair = generateKeyPair(); - final AccountId accountId = new AccountId(DEFAULT_DOMAIN_ID, toIrohaPublicKey(keyPair.getPublic())); - final SignedTransaction transaction = TransactionBuilder.Companion.builder() - .account(ALICE_ACCOUNT_ID) - .registerAccount(accountId, new Metadata(Collections.emptyMap())) - .buildSigned(ALICE_KEYPAIR); - client.sendTransactionAsync(transaction).get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); - - final QueryAndExtractor query = QueryBuilder.findAccountById(accountId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR); - final CompletableFuture future = client.sendQueryAsync(query); - final Account account = future.get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); - Assertions.assertEquals(account.getId(), accountId); - } - - @Test - @WithIroha(sources = DefaultGenesis.class) - public void mintAsset() throws Exception { - final SignedTransaction registerAssetTx = TransactionBuilder.Companion.builder() - .account(ALICE_ACCOUNT_ID) - .registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, new AssetType.Numeric(new NumericSpec())) - .buildSigned(ALICE_KEYPAIR); - client.sendTransactionAsync(registerAssetTx).get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); - - final SignedTransaction mintAssetTx = TransactionBuilder.Companion.builder() - .account(ALICE_ACCOUNT_ID) - .mintAsset(DEFAULT_ASSET_ID, 5) - .buildSigned(ALICE_KEYPAIR); - client.sendTransactionAsync(mintAssetTx).get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); - - final QueryAndExtractor> query = QueryBuilder.findAssetsByAccountId(ALICE_ACCOUNT_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR); - final CompletableFuture> future = client.sendQueryAsync(query); - final List assets = future.get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); - Assertions.assertEquals(5, ((AssetValue.Numeric) assets.stream().findFirst().get().getValue()).getNumeric().getMantissa().intValue()); - } - - @Test - @WithIroha(sources = DefaultGenesis.class) - public void updateKeyValue() throws Exception { - final Name assetMetadataKey = new Name("asset_metadata_key"); - final String assetMetadataValue = "some string value"; - final String assetMetadataValue2 = "some string value 2"; - final Metadata metadata = new Metadata(new HashMap() {{ - put(assetMetadataKey, assetMetadataValue); - }}); - - final SignedTransaction registerAssetTx = TransactionBuilder.Companion.builder() - .account(ALICE_ACCOUNT_ID) - .registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, new AssetType.Store(), metadata, new Mintable.Infinitely()) - .buildSigned(ALICE_KEYPAIR); - client.sendTransactionAsync(registerAssetTx).get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); - - final AssetId assetId = new AssetId(ALICE_ACCOUNT_ID, DEFAULT_ASSET_DEFINITION_ID); - final SignedTransaction keyValueTx = TransactionBuilder.Companion.builder() - .account(ALICE_ACCOUNT_ID) - .setKeyValue(assetId, assetMetadataKey, assetMetadataValue2) - .buildSigned(ALICE_KEYPAIR); - client.sendTransactionAsync(keyValueTx).get(30, TimeUnit.SECONDS); - - final QueryAndExtractor assetDefinitionValueQuery = QueryBuilder - .findAssetKeyValueByIdAndKey(assetId, assetMetadataKey) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR); - final CompletableFuture future = client.sendQueryAsync(assetDefinitionValueQuery); - - final String value = future.get(30, TimeUnit.SECONDS); - Assertions.assertEquals(value, assetMetadataValue2); - } - - @Test - @WithIroha(sources = DefaultGenesis.class) - public void setKeyValue() throws Exception { - final String assetValue = "some string value"; - final Name assetKey = new Name("asset_metadata_key"); - - final SignedTransaction registerAssetTx = TransactionBuilder.Companion.builder() - .account(ALICE_ACCOUNT_ID) - .registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, new AssetType.Store()) - .buildSigned(ALICE_KEYPAIR); - client.sendTransactionAsync(registerAssetTx).get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); - - final SignedTransaction keyValueTx = TransactionBuilder.Companion.builder() - .account(ALICE_ACCOUNT_ID) - .setKeyValue(DEFAULT_ASSET_DEFINITION_ID, assetKey, assetValue) - .buildSigned(ALICE_KEYPAIR); - client.sendTransactionAsync(keyValueTx).get(10, TimeUnit.SECONDS); - - final QueryAndExtractor assetDefinitionValueQuery = QueryBuilder - .findAssetDefinitionKeyValueByIdAndKey(DEFAULT_ASSET_DEFINITION_ID, assetKey) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR); - final CompletableFuture future = client.sendQueryAsync(assetDefinitionValueQuery); - - final String value = future.get(10, TimeUnit.SECONDS); - Assertions.assertEquals(value, assetValue); - } - - @Test - @WithIroha(sources = DefaultGenesis.class) - @ResourceLock("blockStream") - public void blockStreaming() throws ExecutionException, InterruptedException { - int count = 5; - Pair, BlockStreamSubscription> idToSubscription = - client.subscribeToBlockStream(1, count); - UUID actionId = idToSubscription.component1().iterator().next().getId(); - BlockStreamSubscription subscription = idToSubscription.component2(); - - List blocks = new ArrayList<>(); - subscription.receive(actionId, new BlockMessageCollector(blocks)); - - for (int i = 0; i <= count + 1; i++) { - final SignedTransaction transaction = TransactionBuilder.Companion.builder() - .account(ALICE_ACCOUNT_ID) - .setKeyValue(ALICE_ACCOUNT_ID, new Name(randomAlphabetic(10)), new String(randomAlphabetic(10))) - .buildSigned(ALICE_KEYPAIR); - client.sendTransactionAsync(transaction); - } - - QueryAndExtractor> query = QueryBuilder.findAllBlocks() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR); - Integer blocksSize = client.sendQueryAsync(query).get().size(); - - Assertions.assertEquals(blocksSize, blocks.size()); - - subscription.close(); - } - - static class BlockMessageCollector implements FlowCollector { - - List blocks; - - public BlockMessageCollector(List blocks) { - this.blocks = blocks; - } - - @Nullable - @Override - public Object emit( - BlockMessage blockMessage, - @NotNull Continuation continuation - ) { - blocks.add(blockMessage); - return null; - } - } -} +//package jp.co.soramitsu.iroha2; +// +//import java.security.*; +//import java.time.*; +//import java.util.*; +//import java.util.concurrent.CompletableFuture; +//import java.util.concurrent.ExecutionException; +//import java.util.concurrent.TimeUnit; +//import java.util.concurrent.TimeoutException; +//import static jp.co.soramitsu.iroha2.CryptoUtils.generateKeyPair; +//import static jp.co.soramitsu.iroha2.ExtensionsKt.toIrohaPublicKey; +//import jp.co.soramitsu.iroha2.client.Iroha2AsyncClient; +//import jp.co.soramitsu.iroha2.client.blockstream.*; +//import jp.co.soramitsu.iroha2.generated.*; +//import jp.co.soramitsu.iroha2.generated.Metadata; +//import jp.co.soramitsu.iroha2.query.QueryAndExtractor; +//import jp.co.soramitsu.iroha2.query.QueryBuilder; +//import jp.co.soramitsu.iroha2.testengine.DefaultGenesis; +//import jp.co.soramitsu.iroha2.testengine.IrohaTest; +//import jp.co.soramitsu.iroha2.testengine.WithIroha; +//import jp.co.soramitsu.iroha2.transaction.TransactionBuilder; +//import kotlin.*; +//import kotlin.Pair; +//import kotlin.coroutines.*; +//import kotlinx.coroutines.flow.*; +//import org.jetbrains.annotations.*; +//import org.junit.jupiter.api.Assertions; +//import org.junit.jupiter.api.Test; +// +//import static jp.co.soramitsu.iroha2.testengine.TestConstsKt.ALICE_ACCOUNT_ID; +//import static jp.co.soramitsu.iroha2.testengine.TestConstsKt.ALICE_KEYPAIR; +//import static jp.co.soramitsu.iroha2.testengine.TestConstsKt.DEFAULT_ASSET_DEFINITION_ID; +//import static jp.co.soramitsu.iroha2.testengine.TestConstsKt.DEFAULT_ASSET_ID; +//import static jp.co.soramitsu.iroha2.testengine.TestConstsKt.DEFAULT_DOMAIN_ID; +//import org.junit.jupiter.api.parallel.*; +//import static org.testcontainers.shaded.org.apache.commons.lang3.RandomStringUtils.randomAlphabetic; +// +//public class JavaTest extends IrohaTest { +// +// @Test +// @WithIroha(sources = DefaultGenesis.class) +// public void registerDomain() throws ExecutionException, InterruptedException, TimeoutException { +// final DomainId domainId = new DomainId(new Name("new_domain_name")); +// final SignedTransaction transaction = TransactionBuilder.Companion.builder() +// .account(ALICE_ACCOUNT_ID) +// .registerDomain(domainId) +// .buildSigned(ALICE_KEYPAIR); +// client.sendTransactionAsync(transaction).get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); +// +// final QueryAndExtractor query = QueryBuilder.findDomainById(domainId) +// .account(ALICE_ACCOUNT_ID) +// .buildSigned(ALICE_KEYPAIR); +// final CompletableFuture future = client.sendQueryAsync(query); +// final Domain domain = future.get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); +// Assertions.assertEquals(domain.getId(), domainId); +// } +// +// @Test +// @WithIroha(sources = DefaultGenesis.class) +// public void registerAccount() throws Exception { +// final KeyPair keyPair = generateKeyPair(); +// final AccountId accountId = new AccountId(DEFAULT_DOMAIN_ID, toIrohaPublicKey(keyPair.getPublic())); +// final SignedTransaction transaction = TransactionBuilder.Companion.builder() +// .account(ALICE_ACCOUNT_ID) +// .registerAccount(accountId, new Metadata(Collections.emptyMap())) +// .buildSigned(ALICE_KEYPAIR); +// client.sendTransactionAsync(transaction).get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); +// +// final QueryAndExtractor query = QueryBuilder.findAccountById(accountId) +// .account(ALICE_ACCOUNT_ID) +// .buildSigned(ALICE_KEYPAIR); +// final CompletableFuture future = client.sendQueryAsync(query); +// final Account account = future.get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); +// Assertions.assertEquals(account.getId(), accountId); +// } +// +// @Test +// @WithIroha(sources = DefaultGenesis.class) +// public void mintAsset() throws Exception { +// final SignedTransaction registerAssetTx = TransactionBuilder.Companion.builder() +// .account(ALICE_ACCOUNT_ID) +// .registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, new AssetType.Numeric(new NumericSpec())) +// .buildSigned(ALICE_KEYPAIR); +// client.sendTransactionAsync(registerAssetTx).get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); +// +// final SignedTransaction mintAssetTx = TransactionBuilder.Companion.builder() +// .account(ALICE_ACCOUNT_ID) +// .mintAsset(DEFAULT_ASSET_ID, 5) +// .buildSigned(ALICE_KEYPAIR); +// client.sendTransactionAsync(mintAssetTx).get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); +// +// final QueryAndExtractor> query = QueryBuilder.findAssetsByAccountId(ALICE_ACCOUNT_ID) +// .account(ALICE_ACCOUNT_ID) +// .buildSigned(ALICE_KEYPAIR); +// final CompletableFuture> future = client.sendQueryAsync(query); +// final List assets = future.get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); +// Assertions.assertEquals(5, ((AssetValue.Numeric) assets.stream().findFirst().get().getValue()).getNumeric().getMantissa().intValue()); +// } +// +// @Test +// @WithIroha(sources = DefaultGenesis.class) +// public void updateKeyValue() throws Exception { +// final Name assetMetadataKey = new Name("asset_metadata_key"); +// final String assetMetadataValue = "some string value"; +// final String assetMetadataValue2 = "some string value 2"; +// final Metadata metadata = new Metadata(new HashMap() {{ +// put(assetMetadataKey, assetMetadataValue); +// }}); +// +// final SignedTransaction registerAssetTx = TransactionBuilder.Companion.builder() +// .account(ALICE_ACCOUNT_ID) +// .registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, new AssetType.Store(), metadata, new Mintable.Infinitely()) +// .buildSigned(ALICE_KEYPAIR); +// client.sendTransactionAsync(registerAssetTx).get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); +// +// final AssetId assetId = new AssetId(ALICE_ACCOUNT_ID, DEFAULT_ASSET_DEFINITION_ID); +// final SignedTransaction keyValueTx = TransactionBuilder.Companion.builder() +// .account(ALICE_ACCOUNT_ID) +// .setKeyValue(assetId, assetMetadataKey, assetMetadataValue2) +// .buildSigned(ALICE_KEYPAIR); +// client.sendTransactionAsync(keyValueTx).get(30, TimeUnit.SECONDS); +// +// final QueryAndExtractor assetDefinitionValueQuery = QueryBuilder +// .findAssetKeyValueByIdAndKey(assetId, assetMetadataKey) +// .account(ALICE_ACCOUNT_ID) +// .buildSigned(ALICE_KEYPAIR); +// final CompletableFuture future = client.sendQueryAsync(assetDefinitionValueQuery); +// +// final String value = future.get(30, TimeUnit.SECONDS); +// Assertions.assertEquals(value, assetMetadataValue2); +// } +// +// @Test +// @WithIroha(sources = DefaultGenesis.class) +// public void setKeyValue() throws Exception { +// final String assetValue = "some string value"; +// final Name assetKey = new Name("asset_metadata_key"); +// +// final SignedTransaction registerAssetTx = TransactionBuilder.Companion.builder() +// .account(ALICE_ACCOUNT_ID) +// .registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, new AssetType.Store()) +// .buildSigned(ALICE_KEYPAIR); +// client.sendTransactionAsync(registerAssetTx).get(getTxTimeout().getSeconds(), TimeUnit.SECONDS); +// +// final SignedTransaction keyValueTx = TransactionBuilder.Companion.builder() +// .account(ALICE_ACCOUNT_ID) +// .setKeyValue(DEFAULT_ASSET_DEFINITION_ID, assetKey, assetValue) +// .buildSigned(ALICE_KEYPAIR); +// client.sendTransactionAsync(keyValueTx).get(10, TimeUnit.SECONDS); +// +// final QueryAndExtractor assetDefinitionValueQuery = QueryBuilder +// .findAssetDefinitionKeyValueByIdAndKey(DEFAULT_ASSET_DEFINITION_ID, assetKey) +// .account(ALICE_ACCOUNT_ID) +// .buildSigned(ALICE_KEYPAIR); +// final CompletableFuture future = client.sendQueryAsync(assetDefinitionValueQuery); +// +// final String value = future.get(10, TimeUnit.SECONDS); +// Assertions.assertEquals(value, assetValue); +// } +// +// @Test +// @WithIroha(sources = DefaultGenesis.class) +// @ResourceLock("blockStream") +// public void blockStreaming() throws ExecutionException, InterruptedException { +// int count = 5; +// Pair, BlockStreamSubscription> idToSubscription = +// client.subscribeToBlockStream(1, count); +// UUID actionId = idToSubscription.component1().iterator().next().getId(); +// BlockStreamSubscription subscription = idToSubscription.component2(); +// +// List blocks = new ArrayList<>(); +// subscription.receive(actionId, new BlockMessageCollector(blocks)); +// +// for (int i = 0; i <= count + 1; i++) { +// final SignedTransaction transaction = TransactionBuilder.Companion.builder() +// .account(ALICE_ACCOUNT_ID) +// .setKeyValue(ALICE_ACCOUNT_ID, new Name(randomAlphabetic(10)), new String(randomAlphabetic(10))) +// .buildSigned(ALICE_KEYPAIR); +// client.sendTransactionAsync(transaction); +// } +// +// QueryAndExtractor> query = QueryBuilder.findAllBlocks() +// .account(ALICE_ACCOUNT_ID) +// .buildSigned(ALICE_KEYPAIR); +// Integer blocksSize = client.sendQueryAsync(query).get().size(); +// +// Assertions.assertEquals(blocksSize, blocks.size()); +// +// subscription.close(); +// } +// +// static class BlockMessageCollector implements FlowCollector { +// +// List blocks; +// +// public BlockMessageCollector(List blocks) { +// this.blocks = blocks; +// } +// +// @Nullable +// @Override +// public Object emit( +// BlockMessage blockMessage, +// @NotNull Continuation continuation +// ) { +// blocks.add(blockMessage); +// return null; +// } +// } +//} diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/BlockStreamTest.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/BlockStreamTest.kt index 8f0d0bca2..af58e4a0e 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/BlockStreamTest.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/BlockStreamTest.kt @@ -7,6 +7,7 @@ import io.qameta.allure.Story import jp.co.soramitsu.iroha2.annotations.Sdk import jp.co.soramitsu.iroha2.annotations.SdkTestId import jp.co.soramitsu.iroha2.client.blockstream.BlockStreamStorage +import jp.co.soramitsu.iroha2.generated.AssetDefinitionId import jp.co.soramitsu.iroha2.generated.AssetType import jp.co.soramitsu.iroha2.generated.BlockMessage import jp.co.soramitsu.iroha2.generated.BlockPayload @@ -27,7 +28,11 @@ import jp.co.soramitsu.iroha2.testengine.GENESIS_DOMAIN import jp.co.soramitsu.iroha2.testengine.IrohaTest import jp.co.soramitsu.iroha2.testengine.NewAccountWithMetadata import jp.co.soramitsu.iroha2.testengine.WithIroha +import jp.co.soramitsu.iroha2.transaction.Register +import jp.co.soramitsu.iroha2.transaction.SetKeyValue +import jp.co.soramitsu.iroha2.transaction.Transfer import kotlinx.coroutines.runBlocking +import kotlinx.coroutines.time.withTimeout import org.junit.jupiter.api.Test import org.junit.jupiter.api.parallel.ResourceLock import org.testcontainers.shaded.org.apache.commons.lang3.RandomStringUtils.randomAlphabetic @@ -48,29 +53,34 @@ class BlockStreamTest : IrohaTest() { @Issue("https://app.zenhub.com/workspaces/iroha-v2-60ddb820813b9100181fc060/issues/gh/hyperledger/iroha-java/361") @ResourceLock("blockStream") fun `subscription to block stream`(): Unit = runBlocking { - val idToSubscription = client.subscribeToBlockStream(from = 1, count = 3) + val idToSubscription = client.blocks(count = 3) val actionId = idToSubscription.first.first().id val subscription = idToSubscription.second val newAssetName = "rox" - client.tx { - transferDomainOwnership(ALICE_ACCOUNT_ID, DEFAULT_DOMAIN_ID, BOB_ACCOUNT_ID) + client.submit(Transfer.domain(ALICE_ACCOUNT_ID, DEFAULT_DOMAIN_ID, BOB_ACCOUNT_ID)).also { d -> + withTimeout(txTimeout) { d.await() } } - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - registerAssetDefinition(newAssetName.asName(), DEFAULT_DOMAIN_ID, AssetType.Store()) + client.submitAs( + BOB_ACCOUNT_ID, + BOB_KEYPAIR, + Register.assetDefinition(AssetDefinitionId(DEFAULT_DOMAIN_ID, newAssetName.asName()), AssetType.Store()), + ).also { d -> + withTimeout(txTimeout) { d.await() } } val blocks = mutableListOf() subscription.receive(actionId).collect { block -> blocks.add(block) } - val expectedSize = NewAccountWithMetadata().transaction.instructions.count() + 2 // + wasm + peer register + // upgrade executor + set parameters + isi + set topology + val expectedSize = NewAccountWithMetadata().transaction.instructions.count() + 12 var isi = blocks[0].validate(1, GENESIS_DOMAIN, GENESIS_ADDRESS, expectedSize) - val registerDomain = isi[0].cast().extractDomain().id.name.string + val registerDomain = isi[1].cast().extractDomain().id.name.string assertEquals(DEFAULT_DOMAIN_ID.asString(), registerDomain) - assertEquals(ALICE_ACCOUNT_ID, isi[1].extractAccount().id) - assertEquals(BOB_ACCOUNT_ID, isi[2].extractAccount().id) - assertEquals(NewAccountWithMetadata.ACCOUNT_ID, isi[3].extractAccount().id) + assertEquals(ALICE_ACCOUNT_ID, isi[2].extractAccount().id) + assertEquals(BOB_ACCOUNT_ID, isi[3].extractAccount().id) + assertEquals(NewAccountWithMetadata.ACCOUNT_ID, isi[4].extractAccount().id) isi = blocks[2].validate(3, DEFAULT_DOMAIN, BOB_PUBLIC_KEY.payload.toHex(true), 1) val newAssetDefinition = isi[0].cast().extractAssetDefinition() @@ -89,7 +99,7 @@ class BlockStreamTest : IrohaTest() { fun `subscription to endless block stream`(): Unit = runBlocking { val repeatTimes = 5 val shift = 1 // to test not to take more than was ordered - val idToSubscription = client.subscribeToBlockStream( + val idToSubscription = client.blocks( onBlock = { block -> block.extractBlock().height() }, cancelIf = { block -> block.extractBlock().height().u64 == BigInteger.valueOf(repeatTimes.toLong()) }, ) @@ -100,14 +110,16 @@ class BlockStreamTest : IrohaTest() { subscription.receive(initialActionId) { heightSum += it.u64 } repeat(repeatTimes + shift) { - client.tx { setKeyValue(ALICE_ACCOUNT_ID, randomAlphabetic(16).asName(), randomAlphabetic(16)) } + client.submit(SetKeyValue.account(ALICE_ACCOUNT_ID, randomAlphabetic(16).asName(), randomAlphabetic(16))).also { d -> + withTimeout(txTimeout) { d.await() } + } } assertEquals((1..repeatTimes.toLong()).sum(), heightSum.toLong()) val isi = mutableListOf() subscription.subscribeAndReceive( BlockStreamStorage( - onBlock = { it.extractBlock().transactions.first().value.extractInstruction() }, + onBlock = { it.extractBlock().transactions.first().extractInstruction() }, ), collector = { isi.add(it) }, ) @@ -115,18 +127,20 @@ class BlockStreamTest : IrohaTest() { lateinit var lastValue: String repeat(repeatTimes * 2) { lastValue = randomAlphabetic(16) - client.tx { setKeyValue(ALICE_ACCOUNT_ID, randomAlphabetic(16).asName(), lastValue) } + client.submit(SetKeyValue.account(ALICE_ACCOUNT_ID, randomAlphabetic(16).asName(), lastValue)).also { d -> + withTimeout(txTimeout) { d.await() } + } } Thread.sleep(5000) val actual = isi.last().cast().setKeyValueBox .cast().setKeyValueOfAccount.value - assertEquals(lastValue, actual) + assertEquals(lastValue, actual.readValue()) subscription.stop() } private fun BlockPayload.payloads(): List = this.transactions.map { tx -> - tx.value + tx .cast() .signedTransactionV1 .payload diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/ExampleTest.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/ExampleTest.kt index 99233d001..b28a31181 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/ExampleTest.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/ExampleTest.kt @@ -1,46 +1,38 @@ package jp.co.soramitsu.iroha2 import jp.co.soramitsu.iroha2.client.Iroha2Client +import jp.co.soramitsu.iroha2.generated.AssetType import jp.co.soramitsu.iroha2.query.QueryBuilder import jp.co.soramitsu.iroha2.testengine.ALICE_ACCOUNT_ID import jp.co.soramitsu.iroha2.testengine.ALICE_KEYPAIR import jp.co.soramitsu.iroha2.testengine.DefaultGenesis import jp.co.soramitsu.iroha2.testengine.IrohaContainer +import jp.co.soramitsu.iroha2.transaction.Register import kotlinx.coroutines.runBlocking import kotlinx.coroutines.time.withTimeout -import org.junit.jupiter.api.Disabled import org.junit.jupiter.api.Test import java.time.Duration -import kotlin.test.assertEquals +import kotlin.test.assertNotNull -@Disabled class ExampleTest { /** * Test with manual Iroha2Client initialization */ @Test - fun `register domain instruction committed`(): Unit = runBlocking { + fun `register asset definition instruction committed`(): Unit = runBlocking { val container = IrohaContainer { this.alias = "iroha$DEFAULT_P2P_PORT" this.genesis = DefaultGenesis() }.also { it.start() } - val client = Iroha2Client(container.getApiUrl(), container.getP2pUrl()) + val client = Iroha2Client(listOf(container.getApiUrl()), container.config.chain, ALICE_ACCOUNT_ID, ALICE_KEYPAIR) - val domainId = "new_domain_name".asDomainId() - client.sendTransaction { - account(ALICE_ACCOUNT_ID) - registerDomain(domainId) - buildSigned(ALICE_KEYPAIR) - }.also { d -> + val newAssetDefinitionId = "new_asset_definition#wonderland".asAssetDefinitionId() + client.submit(Register.assetDefinition(newAssetDefinitionId, AssetType.Store())).also { d -> withTimeout(Duration.ofSeconds(10)) { d.await() } } - QueryBuilder.findDomainById(domainId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .also { result -> assertEquals(result.id, domainId) } + assertNotNull(client.submit(QueryBuilder.findAssetDefinitionById(newAssetDefinitionId))) } } diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/GenesisTest.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/GenesisTest.kt index e42c3b2c8..f65e059ce 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/GenesisTest.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/GenesisTest.kt @@ -13,8 +13,11 @@ import jp.co.soramitsu.iroha2.testengine.IROHA_CONFIG_DELIMITER import jp.co.soramitsu.iroha2.testengine.IrohaContainer import jp.co.soramitsu.iroha2.testengine.IrohaTest import jp.co.soramitsu.iroha2.testengine.WithIroha +import jp.co.soramitsu.iroha2.transaction.Register import kotlinx.coroutines.runBlocking +import kotlinx.coroutines.time.withTimeout import org.junit.jupiter.api.Test +import java.time.Duration import kotlin.test.assertEquals class GenesisTest : IrohaTest() { @@ -35,7 +38,7 @@ class GenesisTest : IrohaTest() { this.genesisPath = path }.also { it.start() } - val client = Iroha2Client(container.getApiUrl(), container.getP2pUrl()) + val client = Iroha2Client(listOf(container.getApiUrl()), container.config.chain, ALICE_ACCOUNT_ID, ALICE_KEYPAIR) client.checkAliceAndBobExists() } @@ -43,20 +46,17 @@ class GenesisTest : IrohaTest() { @WithIroha([DefaultGenesis::class], executorSource = "src/test/resources/executor.wasm") fun `custom executor path`(): Unit = runBlocking { val definitionId = AssetDefinitionId(DEFAULT_DOMAIN_ID, "XSTUSD".asName()) - client.tx { registerAssetDefinition(definitionId, AssetType.numeric()) } + client.submit(Register.assetDefinition(definitionId, AssetType.numeric())).also { d -> + withTimeout(Duration.ofSeconds(10)) { d.await() } + } - QueryBuilder.findAssetDefinitionById(definitionId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findAssetsDefinitions()) + .first { it.id == definitionId } .also { assetDefinition -> assertEquals(assetDefinition.id, definitionId) } } private suspend fun Iroha2Client.checkAliceAndBobExists() { - QueryBuilder.findAllAccounts() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> this.sendQuery(query) } + submit(QueryBuilder.findAccounts()) .also { accounts -> assert(accounts.any { it.id == ALICE_ACCOUNT_ID }) } .also { accounts -> assert(accounts.any { it.id == BOB_ACCOUNT_ID }) } } diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/InstructionsTest.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/InstructionsTest.kt index 01d7623a5..747c25628 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/InstructionsTest.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/InstructionsTest.kt @@ -8,12 +8,26 @@ import jp.co.soramitsu.iroha2.annotations.Sdk import jp.co.soramitsu.iroha2.annotations.SdkTestId import jp.co.soramitsu.iroha2.client.Iroha2Client import jp.co.soramitsu.iroha2.generated.AccountId +import jp.co.soramitsu.iroha2.generated.AccountIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.Asset import jp.co.soramitsu.iroha2.generated.AssetDefinitionId +import jp.co.soramitsu.iroha2.generated.AssetDefinitionIdProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.AssetId +import jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.AssetProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.AssetType import jp.co.soramitsu.iroha2.generated.AssetValue +import jp.co.soramitsu.iroha2.generated.CanBurnAssetWithDefinition +import jp.co.soramitsu.iroha2.generated.CanModifyAccountMetadata +import jp.co.soramitsu.iroha2.generated.CanModifyAssetMetadata +import jp.co.soramitsu.iroha2.generated.CanModifyDomainMetadata +import jp.co.soramitsu.iroha2.generated.CanTransferAsset +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAsset import jp.co.soramitsu.iroha2.generated.DomainId +import jp.co.soramitsu.iroha2.generated.DomainIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.DomainIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.Json import jp.co.soramitsu.iroha2.generated.Metadata import jp.co.soramitsu.iroha2.generated.RoleId import jp.co.soramitsu.iroha2.query.QueryBuilder @@ -21,12 +35,14 @@ import jp.co.soramitsu.iroha2.testengine.ALICE_ACCOUNT_ID import jp.co.soramitsu.iroha2.testengine.ALICE_KEYPAIR import jp.co.soramitsu.iroha2.testengine.AliceAndBobEachHave100Xor import jp.co.soramitsu.iroha2.testengine.AliceHas100XorAndPermissionToMintAndBurn +import jp.co.soramitsu.iroha2.testengine.AliceHasPermissionToRegisterDomain import jp.co.soramitsu.iroha2.testengine.AliceHasPermissionToUnregisterDomain import jp.co.soramitsu.iroha2.testengine.AliceHasRoleWithAccessToBobsMetadata import jp.co.soramitsu.iroha2.testengine.AliceWithTestAssets import jp.co.soramitsu.iroha2.testengine.BOB_ACCOUNT_ID import jp.co.soramitsu.iroha2.testengine.BOB_KEYPAIR -import jp.co.soramitsu.iroha2.testengine.BobCanUnregisterAnyRole +import jp.co.soramitsu.iroha2.testengine.BobCanManageRoles +import jp.co.soramitsu.iroha2.testengine.BobHasPermissionToRegisterDomain import jp.co.soramitsu.iroha2.testengine.DEFAULT_ASSET_DEFINITION_ID import jp.co.soramitsu.iroha2.testengine.DEFAULT_ASSET_ID import jp.co.soramitsu.iroha2.testengine.DEFAULT_DOMAIN_ID @@ -42,10 +58,18 @@ import jp.co.soramitsu.iroha2.testengine.WithDomainTransferredToBob import jp.co.soramitsu.iroha2.testengine.WithIroha import jp.co.soramitsu.iroha2.testengine.WithIrohaManual import jp.co.soramitsu.iroha2.testengine.XorAndValAssets +import jp.co.soramitsu.iroha2.transaction.Burn +import jp.co.soramitsu.iroha2.transaction.Grant +import jp.co.soramitsu.iroha2.transaction.Mint +import jp.co.soramitsu.iroha2.transaction.Register +import jp.co.soramitsu.iroha2.transaction.RemoveKeyValue +import jp.co.soramitsu.iroha2.transaction.Revoke +import jp.co.soramitsu.iroha2.transaction.SetKeyValue +import jp.co.soramitsu.iroha2.transaction.Transfer +import jp.co.soramitsu.iroha2.transaction.Unregister import kotlinx.coroutines.runBlocking import kotlinx.coroutines.time.withTimeout import org.apache.commons.lang3.RandomStringUtils.randomAlphabetic -import org.junit.jupiter.api.Assertions import org.junit.jupiter.api.Disabled import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertThrows @@ -56,37 +80,30 @@ import java.security.SecureRandom import java.util.UUID import kotlin.test.assertEquals import kotlin.test.assertFailsWith -import kotlin.test.assertFalse +import kotlin.test.assertNotNull +import kotlin.test.assertNull import kotlin.test.assertTrue import kotlin.test.fail @Owner("akostyuchenko") @Sdk("Java/Kotlin") class InstructionsTest : IrohaTest() { - @Test @Disabled // EXAMPLE @WithIrohaManual( ["http://localhost:8080", "http://localhost:8081", "http://localhost:8082", "http://localhost:8083"], - ["http://localhost:1337", "http://localhost:1338", "http://localhost:1339", "http://localhost:1340"], account = "7233bfc89dcbd68c19fde6ce6158225298ec1131b6a130d1aeb454c1ab5183c0${ACCOUNT_ID_DELIMITER}wonderland", "7233bfc89dcbd68c19fde6ce6158225298ec1131b6a130d1aeb454c1ab5183c0", "9ac47abf59b356e0bd7dcbbbb4dec080e302156a48ca907e47cb6aea1d32719e", ) fun `register domain with manual initialized Iroha`(): Unit = runBlocking { val domainId = "new_domain_name".asDomainId() - client.sendTransaction { - account(super.account) - registerDomain(domainId) - buildSigned(super.keyPair) - }.also { d -> + + client.submit(Register.domain(domainId)).also { d -> withTimeout(txTimeout) { d.await() } } - QueryBuilder.findDomainById(domainId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findDomainById(domainId))!! .also { result -> assertEquals(result.id, domainId) } } @@ -100,18 +117,12 @@ class InstructionsTest : IrohaTest() { ) fun `register domain with manual initialized Iroha via docker-compose`(): Unit = runBlocking { val domainId = "new_domain_name".asDomainId() - client.sendTransaction { - account(super.account) - registerDomain(domainId) - buildSigned(super.keyPair) - }.also { d -> + + client.submit(Register.domain(domainId)).also { d -> withTimeout(txTimeout) { d.await() } } - QueryBuilder.findDomainById(domainId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findDomainById(domainId))!! .also { result -> assertEquals(result.id, domainId) } } @@ -120,7 +131,7 @@ class InstructionsTest : IrohaTest() { */ // #region java_register_domain @Test - @WithIroha([DefaultGenesis::class]) + @WithIroha([AliceHasPermissionToRegisterDomain::class]) @Feature("Domains") @Story("Account registers a domain") @Permission("no_permission_required") @@ -128,18 +139,11 @@ class InstructionsTest : IrohaTest() { fun `register domain`(): Unit = runBlocking { val domainId = "new_domain_name".asDomainId() - client.sendTransaction { - account(super.account) - registerDomain(domainId) - buildSigned(super.keyPair) - }.also { d -> + client.submit(Register.domain(domainId)).also { d -> withTimeout(txTimeout) { d.await() } } - QueryBuilder.findDomainById(domainId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findDomainById(domainId))!! .also { result -> assertEquals(result.id, domainId) } } // #endregion java_register_domain @@ -155,20 +159,14 @@ class InstructionsTest : IrohaTest() { @Permission("no_permission_required") @SdkTestId("register_account") fun `register account`(): Unit = runBlocking { - val newAccountId = AccountId(DEFAULT_DOMAIN_ID, generatePublicKey()) - client.sendTransaction { - account(super.account) - registerAccount(newAccountId) - buildSigned(super.keyPair) - }.also { d -> + val accountId = AccountId(DEFAULT_DOMAIN_ID, generatePublicKey()) + + client.submit(Register.account(accountId)).also { d -> withTimeout(txTimeout) { d.await() } } - QueryBuilder.findAccountById(newAccountId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .also { account -> assertEquals(account.id, newAccountId) } + client.submit(QueryBuilder.findAccountById(accountId))!! + .also { account -> assertEquals(account.id, accountId) } } // #endregion java_register_account @@ -183,30 +181,18 @@ class InstructionsTest : IrohaTest() { fun `register and unregister account`(): Unit = runBlocking { val joeKeyPair = generateKeyPair() val joeId = AccountId(DEFAULT_DOMAIN_ID, joeKeyPair.public.toIrohaPublicKey()) - client.tx { registerAccount(joeId) } + client.submit(Register.account(joeId)).also { d -> + withTimeout(txTimeout) { d.await() } + } - QueryBuilder.findAccountById(joeId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findAccountById(joeId))!! .also { account -> assertEquals(account.id, joeId) } - client.tx(joeId, joeKeyPair) { - grantPermissionToken( - Permissions.CanUnregisterAccount, - joeId.asJsonString(true), - ALICE_ACCOUNT_ID, - ) - unregisterAccount(joeId) - } - assertThrows { - runBlocking { - QueryBuilder.findAccountById(joeId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - } + client.submitAs(joeId, joeKeyPair, Unregister.account(joeId)).also { d -> + withTimeout(txTimeout) { d.await() } } + client.submit(QueryBuilder.findAccountById(joeId)) + .also { account -> assertNull(account) } } @Test @@ -218,37 +204,36 @@ class InstructionsTest : IrohaTest() { @SdkTestId("register_asset_definition") @SdkTestId("unregister_asset_definition") fun `register and unregister asset`(): Unit = runBlocking { - val definitionId = AssetDefinitionId(DEFAULT_DOMAIN_ID, "XSTUSD".asName()) - client.tx { registerAssetDefinition(definitionId, AssetType.numeric()) } + val assetDefinitionId = AssetDefinitionId(DEFAULT_DOMAIN_ID, "XSTUSD".asName()) + client.submit(Register.assetDefinition(assetDefinitionId, AssetType.numeric())) + .also { d -> + withTimeout(txTimeout) { d.await() } + } - val assetId = AssetId(ALICE_ACCOUNT_ID, definitionId) - client.tx { registerAsset(assetId, AssetValue.Numeric(0.asNumeric())) } + val assetId = AssetId(ALICE_ACCOUNT_ID, assetDefinitionId) + client.submit(Register.asset(assetId, AssetValue.Numeric(0.asNumeric()))) + .also { d -> + withTimeout(txTimeout) { d.await() } + } - QueryBuilder.findAssetById(assetId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findAssetById(assetId))!! .also { asset -> assertEquals(asset.id, assetId) } - client.tx { unregisterAsset(assetId) } - assertThrows { - runBlocking { - QueryBuilder.findAssetById(assetId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } + client.submit(Unregister.asset(assetId)) + .also { d -> + withTimeout(txTimeout) { d.await() } } - } + client.submit(QueryBuilder.findAssetById(assetId)) + .also { asset -> assertNull(asset) } - client.tx { unregisterAssetDefinition(definitionId) } - assertThrows { - runBlocking { - QueryBuilder.findAssetDefinitionById(definitionId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } + client.submit(Unregister.assetDefinition(assetDefinitionId)) + .also { d -> + withTimeout(txTimeout) { d.await() } } - } + client.submit( + QueryBuilder.findAssetDefinitionById(assetDefinitionId), + ) + .also { definition -> assertNull(definition) } } @Test @@ -258,16 +243,14 @@ class InstructionsTest : IrohaTest() { @Permission("CanUnregisterDomain") @SdkTestId("unregister_domain") fun `unregister domain`(): Unit = runBlocking { - client.tx { unregisterDomain(AliceHasPermissionToUnregisterDomain.NEW_DOMAIN_ID) } - - assertThrows { - runBlocking { - QueryBuilder.findDomainById(AliceHasPermissionToUnregisterDomain.NEW_DOMAIN_ID) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } + client.submit(Unregister.domain(AliceHasPermissionToUnregisterDomain.NEW_DOMAIN_ID)) + .also { d -> + withTimeout(txTimeout) { d.await() } } - } + client.submit( + QueryBuilder.findDomainById(AliceHasPermissionToUnregisterDomain.NEW_DOMAIN_ID), + ) + .also { domain -> assertNull(domain) } } @Test @@ -287,32 +270,28 @@ class InstructionsTest : IrohaTest() { val cityValue = "city" val metadata = Metadata( mapOf( - Pair(addressKey, addressValue), - Pair(phoneKey, phoneValue), - Pair(emailKey, emailValue), - Pair(cityKey, cityValue), + Pair(addressKey, Json.writeValue(addressValue)), + Pair(phoneKey, Json.writeValue(phoneValue)), + Pair(emailKey, Json.writeValue(emailValue)), + Pair(cityKey, Json.writeValue(cityValue)), ), ) val newAccountId = AccountId(DEFAULT_DOMAIN_ID, generatePublicKey()) - client.sendTransaction { - account(super.account) - registerAccount(newAccountId, metadata) - buildSigned(super.keyPair) - }.also { d -> + client.submit(Register.account(newAccountId, metadata)).also { d -> withTimeout(txTimeout) { d.await() } } - val accountMetadata = QueryBuilder.findAccountById(newAccountId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .also { account -> assertEquals(account.id, newAccountId) } - .metadata + val accountMetadata = + client.submit( + QueryBuilder.findAccountById(newAccountId), + )!! + .also { account -> assertEquals(account.id, newAccountId) } + .metadata assertEquals(4, accountMetadata.sortedMapOfName.size) - assertEquals(addressValue, accountMetadata.sortedMapOfName[addressKey]) - assertEquals(phoneValue, accountMetadata.sortedMapOfName[phoneKey]) - assertEquals(emailValue, accountMetadata.sortedMapOfName[emailKey]) - assertEquals(cityValue, accountMetadata.sortedMapOfName[cityKey]) + assertEquals(addressValue, accountMetadata.sortedMapOfName[addressKey]!!.readValue()) + assertEquals(phoneValue, accountMetadata.sortedMapOfName[phoneKey]!!.readValue()) + assertEquals(emailValue, accountMetadata.sortedMapOfName[emailKey]!!.readValue()) + assertEquals(cityValue, accountMetadata.sortedMapOfName[cityKey]!!.readValue()) } /** @@ -326,21 +305,18 @@ class InstructionsTest : IrohaTest() { @Permission("no_permission_required") @SdkTestId("DEPRECATE CANDIDATE") fun `register asset`(): Unit = runBlocking { - client.sendTransaction { - account(super.account) - registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()) - buildSigned(super.keyPair) - }.also { d -> + client.submit(Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric())).also { d -> withTimeout(txTimeout) { d.await() } } - val assetDefinitions = QueryBuilder.findAllAssetsDefinitions() - .account(super.account) - .buildSigned(super.keyPair) - .let { q -> client.sendQuery(q) } + val assetDefinitions = + client.submit( + QueryBuilder.findAssetsDefinitions(), + ) - assertFalse { assetDefinitions.isEmpty() } - assetDefinitions.find { it.id == DEFAULT_ASSET_DEFINITION_ID } - ?: fail("Expected query response contains assetDefinition $DEFAULT_ASSET_DEFINITION_ID, but it is not. Response was $assetDefinitions") + assetDefinitions.find { it.id == DEFAULT_ASSET_DEFINITION_ID } ?: fail( + "Expected query response contains assetDefinition $DEFAULT_ASSET_DEFINITION_ID, " + + "but it is not. Response was $assetDefinitions", + ) } // #endregion java_register_asset @@ -352,38 +328,50 @@ class InstructionsTest : IrohaTest() { @SdkTestId("register_asset_definition_with_store_value_type") fun `store asset`(): Unit = runBlocking { val pair1 = "key1".asName() to "bar" - val pair2 = "key2".asName() to "true" - val pair3 = "key3".asName() to "12345" - - client.tx { - registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.Store()) - setKeyValue(DEFAULT_ASSET_ID, pair1.first, pair1.second) - setKeyValue(DEFAULT_ASSET_ID, pair2.first, pair2.second) - setKeyValue(DEFAULT_ASSET_ID, pair3.first, pair3.second) + val pair2 = "key2".asName() to true + val pair3 = "key3".asName() to 12345 + + client.submit( + Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.Store()), + SetKeyValue.asset(DEFAULT_ASSET_ID, pair1.first, pair1.second), + SetKeyValue.asset(DEFAULT_ASSET_ID, pair2.first, pair2.second), + SetKeyValue.asset(DEFAULT_ASSET_ID, pair3.first, pair3.second), + ).also { d -> + withTimeout(txTimeout) { d.await() } } - val findAssetByIdQry = QueryBuilder.findAssetById(DEFAULT_ASSET_ID) - .account(super.account) - .buildSigned(super.keyPair) - val asset = client.sendQuery(findAssetByIdQry) + val asset = + client.submit( + QueryBuilder.findAssetById(DEFAULT_ASSET_ID), + ) - assertEquals(DEFAULT_ASSET_ID.definition.name, asset.id.definition.name) - assertEquals(DEFAULT_ASSET_ID.definition.domain, asset.id.definition.domain) - when (val value = asset.value) { + assertEquals(DEFAULT_ASSET_ID.definition.name, asset?.id?.definition?.name) + assertEquals(DEFAULT_ASSET_ID.definition.domain, asset?.id?.definition?.domain) + when (val value = asset?.value) { is AssetValue.Store -> { - assertEquals(pair1.second, value.metadata.sortedMapOfName[pair1.first]) - assertEquals(pair2.second, value.metadata.sortedMapOfName[pair2.first]) - assertEquals(pair3.second, value.metadata.sortedMapOfName[pair3.first]) + assertEquals(pair1.second, value.metadata.sortedMapOfName[pair1.first]!!.readValue()) + assertEquals(pair2.second, value.metadata.sortedMapOfName[pair2.first]!!.readValue()) + assertEquals(pair3.second, value.metadata.sortedMapOfName[pair3.first]!!.readValue()) } - else -> fail("Expected result asset value has type `AssetValue.Store`, but it was `${asset.value::class.simpleName}`") + else -> fail("Expected result asset value has type `AssetValue.Store`, but it was `${asset!!.value::class.simpleName}`") } // try to find saved assets by domain name - val findAssetsByDomainNameQry = QueryBuilder.findAssetsByDomainId(DEFAULT_DOMAIN_ID) - .account(super.account) - .buildSigned(super.keyPair) - val assetsByDomainName = client.sendQuery(findAssetsByDomainNameQry) + val domainPredicate = + CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Definition( + AssetDefinitionIdProjectionOfPredicateMarker.Domain( + DomainIdProjectionOfPredicateMarker.Atom( + DomainIdPredicateAtom.Equals(DEFAULT_DOMAIN_ID), + ), + ), + ), + ), + ) + + val assetsByDomainName = client.submit(QueryBuilder.findAssets(domainPredicate)) assertEquals(1, assetsByDomainName.size) assertEquals(asset.id, assetsByDomainName.first().id) } @@ -398,31 +386,36 @@ class InstructionsTest : IrohaTest() { @Permission("no_permission_required") @SdkTestId("account_metadata_limit_increased") fun `account metadata limit increased`(): Unit = runBlocking { - client.tx { - // 5000 characters string would be rejected by Iroha with default WSV_ACCOUNT_METADATA_LIMITS config - setKeyValue(ALICE_ACCOUNT_ID, "key".asName(), randomAlphabetic(5000)) - } + val key = "key".asName() + val value = randomAlphabetic(5000) + + // 5000 characters string would be rejected by Iroha with default WSV_ACCOUNT_METADATA_LIMITS config + client.submit(SetKeyValue.account(ALICE_ACCOUNT_ID, key, Json.writeValue(value))) + .also { d -> + withTimeout(txTimeout) { d.await() } + } } @Test @Feature("Accounts") @Story("Account sets key value pair") - @Permission("CanSetKeyValueInDomain") - @SdkTestId("set_key_value_pair_for_another_account_domain_defenition") - @WithIroha([DefaultGenesis::class]) + @Permission("CanModifyDomainMetadata") + @SdkTestId("modify_metadata_for_another_account_domain_definition") + @WithIroha([BobHasPermissionToRegisterDomain::class]) fun `domain metadata set key value with permissions`(): Unit = runBlocking { val domainId = DomainId(randomAlphabetic(10).asName()) - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - registerDomain(domainId) - grantPermissionToken( - Permissions.CanSetKeyValueInDomain, - domainId.asJsonString(), - ALICE_ACCOUNT_ID, - ) + + client.submitAs( + BOB_ACCOUNT_ID, + BOB_KEYPAIR, + Register.domain(domainId), + Grant.accountPermission(CanModifyDomainMetadata(domainId), ALICE_ACCOUNT_ID), + ).also { d -> + withTimeout(txTimeout) { d.await() } } - client.tx(ALICE_ACCOUNT_ID, ALICE_KEYPAIR) { - setKeyValue(domainId, randomAlphabetic(10).asName(), randomAlphabetic(10)) + client.submit(SetKeyValue.domain(domainId, randomAlphabetic(10).asName(), Json.writeValue(randomAlphabetic(10)))).also { d -> + withTimeout(txTimeout) { d.await() } } } @@ -430,43 +423,41 @@ class InstructionsTest : IrohaTest() { @WithIroha([DefaultGenesis::class]) @Feature("Accounts") @Story("Account sets key value pair") - @Permission("CanSetKeyValueInUserAsset") - @SdkTestId("set_key_value_pair_for_another_account_asset_definition") + @Permission("CanModifyAssetMetadata") + @SdkTestId("modify_metadata_for_another_account_asset_definition") fun `grant access to asset key-value and then revoke`(): Unit = runBlocking { val aliceAssetId = DEFAULT_ASSET_ID + val permission = CanModifyAssetMetadata(aliceAssetId) - client.tx { - registerAssetDefinition(aliceAssetId.definition, AssetType.Store()) + client.submit( + Register.assetDefinition(aliceAssetId.definition, AssetType.Store()), // grant by Alice to Bob permissions to set key value in Asset.Store - grantPermissionToken( - Permissions.CanSetKeyValueInUserAsset, - aliceAssetId.asJsonString(true), + Grant.accountPermission( + permission, BOB_ACCOUNT_ID, - ) + ), + ).also { d -> + withTimeout(txTimeout) { d.await() } } - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - setKeyValue(aliceAssetId, "foo".asName(), "bar") + client.submitAs(BOB_ACCOUNT_ID, BOB_KEYPAIR, SetKeyValue.asset(aliceAssetId, "foo".asName(), "bar")).also { d -> + withTimeout(txTimeout) { d.await() } } - val query = QueryBuilder.findAssetById(aliceAssetId) - .account(super.account) - .buildSigned(super.keyPair) - val asset = client.sendQuery(query) + val asset = client.submit(QueryBuilder.findAssetById(aliceAssetId)) - assertEquals(aliceAssetId.definition.name, asset.id.definition.name) - assertEquals(aliceAssetId.definition.domain, asset.id.definition.domain) - when (val value = asset.value) { - is AssetValue.Store -> assertEquals("bar", value.metadata.sortedMapOfName["foo".asName()]) - else -> fail("Expected result asset value has type `AssetValue.Store`, but it was `${asset.value::class.simpleName}`") + assertEquals(aliceAssetId.definition.name, asset?.id?.definition?.name) + assertEquals(aliceAssetId.definition.domain, asset?.id?.definition?.domain) + when (val value = asset?.value) { + is AssetValue.Store -> assertEquals("bar", value.metadata.sortedMapOfName["foo".asName()]!!.readValue()) + else -> fail("Expected result asset value has type `AssetValue.Store`, but it was `${asset!!.value::class.simpleName}`") } - client.tx { - revokeSetKeyValueAsset(aliceAssetId, BOB_ACCOUNT_ID) + client.submit(Revoke.accountPermission(permission, BOB_ACCOUNT_ID)).also { d -> + withTimeout(txTimeout) { d.await() } } - QueryBuilder.findPermissionsByAccountId(BOB_ACCOUNT_ID) - .account(BOB_ACCOUNT_ID) - .buildSigned(BOB_KEYPAIR) - .let { client.sendQuery(it) } + client.submit( + QueryBuilder.findPermissionsByAccountId(BOB_ACCOUNT_ID).signAs(BOB_ACCOUNT_ID, BOB_KEYPAIR), + ) .also { permissions -> assertTrue { permissions.isEmpty() } } } @@ -481,22 +472,27 @@ class InstructionsTest : IrohaTest() { @Permission("no_permission_required") @SdkTestId("mint_asset_for_account_in_same_domain") fun `mint asset`(): Unit = runBlocking { - client.sendTransaction { - account(super.account) - registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()) - mintAsset(DEFAULT_ASSET_ID, 5) - buildSigned(super.keyPair) - }.also { d -> + client.submit( + Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()), + Mint.asset(DEFAULT_ASSET_ID, BigDecimal(5)), + ).also { d -> withTimeout(txTimeout) { d.await() } } - QueryBuilder.findAssetsByAccountId(ALICE_ACCOUNT_ID) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .also { result -> - assertEquals(5, result.get(DEFAULT_ASSET_ID)?.value?.cast()?.numeric?.asInt()) - } + val byAccountIdFilter = CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Account( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals( + ALICE_ACCOUNT_ID, + ), + ), + ), + ), + ) + client.submit(QueryBuilder.findAssets(byAccountIdFilter)).also { result -> + assertEquals(5, result.get(DEFAULT_ASSET_ID)!!.value.cast().numeric.asInt()) + } } // #endregion java_mint_asset @@ -507,18 +503,30 @@ class InstructionsTest : IrohaTest() { @Permission("no_permission_required") @SdkTestId("burn_asset_for_account_in_same_domain") fun `burn asset`(): Unit = runBlocking { + val byAccountIdFilter = CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Account( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals( + ALICE_ACCOUNT_ID, + ), + ), + ), + ), + ) // check balance before burn - val query = QueryBuilder.findAssetsByAccountId(ALICE_ACCOUNT_ID) - .account(super.account) - .buildSigned(super.keyPair) - var result = client.sendQuery(query) - assertEquals(100, result.get(DEFAULT_ASSET_ID)?.value?.cast()?.numeric?.asInt()) + val query = QueryBuilder.findAssets(byAccountIdFilter) + .signAs(client.authority, client.keyPair) + var result = client.submit(query) + assertEquals(100, result.get(DEFAULT_ASSET_ID)!!.value.cast().numeric.asInt()) - client.tx { burnAsset(DEFAULT_ASSET_ID, 50) } + client.submit(Burn.asset(DEFAULT_ASSET_ID, BigDecimal(50))).also { d -> + withTimeout(txTimeout) { d.await() } + } // check balance after burn - result = client.sendQuery(query) - assertEquals(50, result.get(DEFAULT_ASSET_ID)?.value?.cast()?.numeric?.asInt()) + result = client.submit(query) + assertEquals(50, result.get(DEFAULT_ASSET_ID)!!.value.cast().numeric.asInt()) } @Test @@ -528,22 +536,34 @@ class InstructionsTest : IrohaTest() { @Permission("CanBurnAssetsWithDefinition") @SdkTestId("burn_other_user_xasset") fun `burn other user asset`(): Unit = runBlocking { - client.tx { - registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()) - mintAsset(DEFAULT_ASSET_ID, 100) - grantPermissionToken( - Permissions.CanBurnAssetWithDefinition, - DEFAULT_ASSET_DEFINITION_ID.asJsonString(), + client.submit( + Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()), + Mint.asset(DEFAULT_ASSET_ID, BigDecimal(100)), + Grant.accountPermission( + CanBurnAssetWithDefinition(DEFAULT_ASSET_DEFINITION_ID), BOB_ACCOUNT_ID, - ) + ), + ).also { d -> + withTimeout(txTimeout) { d.await() } } - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { burnAsset(DEFAULT_ASSET_ID, 50) } - val result = QueryBuilder.findAssetsByAccountId(ALICE_ACCOUNT_ID) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - assertEquals(50, result.get(DEFAULT_ASSET_ID)?.value?.cast()?.numeric?.asInt()) + client.submit(Burn.asset(DEFAULT_ASSET_ID, BigDecimal(50))).also { d -> + withTimeout(txTimeout) { d.await() } + } + + val byAccountIdFilter = CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Account( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals( + ALICE_ACCOUNT_ID, + ), + ), + ), + ), + ) + val result = client.submit(QueryBuilder.findAssets(byAccountIdFilter)) + assertEquals(50, result.get(DEFAULT_ASSET_ID)!!.value.cast().numeric.asInt()) } @Test @@ -556,32 +576,31 @@ class InstructionsTest : IrohaTest() { val saltKey = "salt" // grant permission to Alice to change Bob's account metadata - client.sendTransaction { - account(BOB_ACCOUNT_ID) - grantPermissionToken( - Permissions.CanSetKeyValueInAccount, - BOB_ACCOUNT_ID.asJsonString(true), + client.submitAs( + BOB_ACCOUNT_ID, + BOB_KEYPAIR, + Grant.accountPermission( + CanModifyAccountMetadata(BOB_ACCOUNT_ID), ALICE_ACCOUNT_ID, - ) - buildSigned(BOB_KEYPAIR) - }.also { d -> + ), + ).also { d -> withTimeout(txTimeout) { d.await() } } // add/update salt value in Bob's account metadata val salt = randomAlphabetic(10) - client.tx { setKeyValue(BOB_ACCOUNT_ID, saltKey.asName(), salt) } + client.submit(SetKeyValue.account(BOB_ACCOUNT_ID, saltKey.asName(), salt)) + .also { d -> + withTimeout(txTimeout) { d.await() } + } // check new metadata in Bob's account - val saltQuery = QueryBuilder.findAccountById(BOB_ACCOUNT_ID) - .account(super.account) - .buildSigned(super.keyPair) - val bobAccountMetadata = client.sendQuery(saltQuery).metadata - assertEquals(salt, bobAccountMetadata.sortedMapOfName["salt".asName()]) + val bobAccountMetadata = client.submit(QueryBuilder.findAccountById(BOB_ACCOUNT_ID))!!.metadata.sortedMapOfName + assertEquals(salt, bobAccountMetadata["salt".asName()]!!.readValue()) } @Test - @WithIroha([AliceAndBobEachHave100Xor::class]) + @WithIroha([AliceAndBobEachHave100Xor::class, AliceHasPermissionToRegisterDomain::class]) @Feature("Assets") @Story("Account transfers assets") @Permission("CanTransferUserAsset") @@ -593,26 +612,34 @@ class InstructionsTest : IrohaTest() { assertEquals(100, getAccountAmount(aliceAssetId)) assertEquals(100, getAccountAmount(bobAssetId)) - client.tx { transferAsset(aliceAssetId, 40, BOB_ACCOUNT_ID) } + client.submit(Transfer.asset(aliceAssetId, BigDecimal(40), BOB_ACCOUNT_ID)).also { d -> + withTimeout(txTimeout) { d.await() } + } assertEquals(60, getAccountAmount(aliceAssetId)) assertEquals(140, getAccountAmount(bobAssetId)) - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { transferAsset(bobAssetId, 40, ALICE_ACCOUNT_ID) } + client.submitAs(BOB_ACCOUNT_ID, BOB_KEYPAIR, Transfer.asset(bobAssetId, BigDecimal(40), ALICE_ACCOUNT_ID)).also { d -> + withTimeout(txTimeout) { d.await() } + } assertEquals(100, getAccountAmount(aliceAssetId)) assertEquals(100, getAccountAmount(bobAssetId)) val joeDomain = "joe_domain".asDomainId() - client.tx { registerDomain(joeDomain) } + client.submit(Register.domain(joeDomain)).also { d -> + withTimeout(txTimeout) { d.await() } + } val joeKeyPair = generateKeyPair() val joeId = AccountId(joeDomain, joeKeyPair.public.toIrohaPublicKey()) - registerAccount(joeId) + client.submit(Register.account(joeId)).also { d -> + withTimeout(txTimeout) { d.await() } + } - client.tx { - grantPermissionToken(Permissions.CanTransferUserAssetsToken, aliceAssetId.asJsonString(true), joeId) + client.submit(Grant.accountPermission(CanTransferAsset(aliceAssetId), joeId)).also { d -> + withTimeout(txTimeout) { d.await() } } - client.tx(account = joeId, joeKeyPair) { - transferAsset(aliceAssetId, 40, BOB_ACCOUNT_ID) + client.submitAs(BOB_ACCOUNT_ID, BOB_KEYPAIR, Transfer.asset(aliceAssetId, BigDecimal(40), BOB_ACCOUNT_ID)).also { d -> + withTimeout(txTimeout) { d.await() } } assertEquals(60, getAccountAmount(aliceAssetId)) assertEquals(140, getAccountAmount(bobAssetId)) @@ -629,9 +656,11 @@ class InstructionsTest : IrohaTest() { val assetKey = StoreAssetWithMetadata.ASSET_KEY val assetBefore = getAsset(assetId) - val value = assetBefore.value.cast().metadata.sortedMapOfName[assetKey]?.fromJsonString() - assertEquals(StoreAssetWithMetadata.ASSET_VALUE, value) - client.tx { removeKeyValue(assetId, assetKey) } + val value = assetBefore.value.cast().metadata.sortedMapOfName[assetKey]!! + assertEquals(StoreAssetWithMetadata.ASSET_VALUE, value.readValue()) + client.submit(RemoveKeyValue.asset(assetId, assetKey)).also { d -> + withTimeout(txTimeout) { d.await() } + } val assetAfter = getAsset(assetId) assert(assetAfter.value.cast().metadata.sortedMapOfName.isEmpty()) @@ -648,7 +677,9 @@ class InstructionsTest : IrohaTest() { @Permission("no_permission_required") @SdkTestId("burn_fixed_asset") fun `check assets with type Fixed are properly minted and burned`(): Unit = runBlocking { - client.tx { registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()) } + client.submit(Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric())).also { d -> + withTimeout(txTimeout) { d.await() } + } // counter to track all changes in balance var counter = BigDecimal.ZERO @@ -664,22 +695,34 @@ class InstructionsTest : IrohaTest() { .setScale(random.nextInt(DEFAULT_SCALE), RoundingMode.DOWN) } val mintAsset: suspend (BigDecimal) -> Unit = { - client.tx { mintAsset(DEFAULT_ASSET_ID, it) } + client.submit(Mint.asset(DEFAULT_ASSET_ID, it)).also { d -> + withTimeout(txTimeout) { d.await() } + } counter += it } val burnAsset: suspend (BigDecimal) -> Unit = { - client.tx { burnAsset(DEFAULT_ASSET_ID, it) } + client.submit(Burn.asset(DEFAULT_ASSET_ID, it)).also { d -> + withTimeout(txTimeout) { d.await() } + } counter -= it } + val byAccountIdFilter = CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Account( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals( + ALICE_ACCOUNT_ID, + ), + ), + ), + ), + ) val assertBalance: suspend (BigDecimal) -> Unit = { expectedBalance -> - QueryBuilder.findAssetsByAccountId(ALICE_ACCOUNT_ID) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .let { account -> account.get(DEFAULT_ASSET_ID)?.value } - .let { value -> - value?.cast()?.numeric?.asBigDecimal() ?: BigDecimal.ZERO - }.also { actualBalance -> + val asset = client.submit(QueryBuilder.findAssets(byAccountIdFilter)) + .get(DEFAULT_ASSET_ID) + + asset?.value?.cast()?.numeric?.asBigDecimal() ?: BigDecimal.ZERO + .also { actualBalance -> assertTrue("expected value `$expectedBalance`, but was `$actualBalance`") { expectedBalance.compareTo(actualBalance) == 0 } @@ -707,37 +750,37 @@ class InstructionsTest : IrohaTest() { fun `register asset with metadata`(): Unit = runBlocking { val assetKey = "asset_metadata_key".asName() val assetValue = "some string value" - val metadata = Metadata(mapOf(assetKey to assetValue)) + val metadata = Metadata(mapOf(assetKey to Json.writeValue(assetValue))) - client.tx { - registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.Store(), metadata) + client.submit(Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.Store(), metadata = metadata)).also { d -> + withTimeout(txTimeout) { d.await() } } - QueryBuilder.findAssetDefinitionKeyValueByIdAndKey(DEFAULT_ASSET_DEFINITION_ID, assetKey) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .also { value -> - Assertions.assertEquals(value, assetValue) - } + client.submit(QueryBuilder.findAssetDefinitionById(DEFAULT_ASSET_DEFINITION_ID))!! + .also { assertEquals(assetValue, it.metadata.sortedMapOfName[assetKey]!!.readValue()) } } @Test - @WithIroha([DefaultGenesis::class]) + @WithIroha([DefaultGenesis::class, AliceHasPermissionToRegisterDomain::class]) @Feature("Domains") @Story("Account registers a domain") @Permission("no_permission_required") @SdkTestId("register_existence_domain") fun `double domain registration should fail`(): Unit = runBlocking { val domainId = UUID.randomUUID().toString().asDomainId() - client.tx { registerDomain(domainId) } + client.submit(Register.domain(domainId)).also { d -> + withTimeout(txTimeout) { d.await() } + } assertThrows { - runBlocking { client.tx { registerDomain(domainId) } } + runBlocking { client.submit(Register.domain(domainId)) } + .also { d -> + withTimeout(txTimeout) { d.await() } + } } } @Test - @WithIroha([BobCanUnregisterAnyRole::class]) + @WithIroha([BobCanManageRoles::class, BobHasPermissionToRegisterDomain::class]) @Feature("Assets") @Story("Account registers an asset definition") @SdkTestId("register_asset_definition_with_store_value_type") @@ -751,58 +794,61 @@ class InstructionsTest : IrohaTest() { @Feature("Accounts") @SdkTestId("set_key_value_in_foreign_asset_after_granting_role") fun `register and grant role to account and then revoke it`(): Unit = runBlocking { - val assetId = AssetId(BOB_ACCOUNT_ID, DEFAULT_ASSET_DEFINITION_ID) - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.Store()) + val domainId = "Kingdom".asDomainId() + val assetDefinitionName = AssetDefinitionId(domainId, "kita".asName()) + client.submitAs( + BOB_ACCOUNT_ID, + BOB_KEYPAIR, + Register.domain(domainId), + Register.assetDefinition(assetDefinitionName, AssetType.Store()), + ).also { d -> + withTimeout(txTimeout) { d.await() } } + val assetId = AssetId(BOB_ACCOUNT_ID, assetDefinitionName) val roleId = RoleId("BOB_ASSET_ACCESS".asName()) - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - registerRole(roleId) - grantRole(roleId, ALICE_ACCOUNT_ID) - setKeyValue(assetId, "key".asName(), "value") + client.submitAs( + BOB_ACCOUNT_ID, + BOB_KEYPAIR, + Register.role(BOB_ACCOUNT_ID, roleId), + Grant.accountRole(roleId, ALICE_ACCOUNT_ID), + SetKeyValue.asset(assetId, "key".asName(), "value"), + ).also { d -> + withTimeout(txTimeout) { d.await() } } - QueryBuilder.findAssetById(assetId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findAssetById(assetId)) .also { asset -> - assertTrue( - asset.value.cast() - .metadata.sortedMapOfName - .containsValue("value"), + assertEquals( + asset!!.value.cast().metadata.sortedMapOfName["key".asName()]!!.readValue(), + "value", ) } - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - revokeRole(roleId, ALICE_ACCOUNT_ID) + client.submitAs(BOB_ACCOUNT_ID, BOB_KEYPAIR, Revoke.accountRole(roleId, ALICE_ACCOUNT_ID)).also { d -> + withTimeout(txTimeout) { d.await() } } - QueryBuilder.findRolesByAccountId(ALICE_ACCOUNT_ID) - .account(BOB_ACCOUNT_ID) - .buildSigned(BOB_KEYPAIR) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findRolesByAccountId(ALICE_ACCOUNT_ID).signAs(BOB_ACCOUNT_ID, BOB_KEYPAIR)) .also { roles -> assertTrue( roles.isEmpty(), ) } - QueryBuilder.findAllRoles() - .account(BOB_ACCOUNT_ID) - .buildSigned(BOB_KEYPAIR) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findRoles().signAs(BOB_ACCOUNT_ID, BOB_KEYPAIR)) .firstOrNull { it.id == roleId } - .also { Assertions.assertNotNull(it) } + .also { assertNotNull(it) } - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - unregisterRole(roleId) - } - QueryBuilder.findAllRoles() - .account(BOB_ACCOUNT_ID) - .buildSigned(BOB_KEYPAIR) - .let { query -> client.sendQuery(query) } + client.submitAs( + BOB_ACCOUNT_ID, + BOB_KEYPAIR, + Unregister.role(roleId), + ) + .also { d -> + withTimeout(txTimeout) { d.await() } + } + client.submit(QueryBuilder.findRoles().signAs(BOB_ACCOUNT_ID, BOB_KEYPAIR)) .firstOrNull { it.id == roleId } - .also { Assertions.assertNull(it) } + .also { assertNull(it) } } @Test @@ -829,36 +875,27 @@ class InstructionsTest : IrohaTest() { val assetBefore = getAsset(assetId) assertEquals( StoreAssetWithMetadata.ASSET_VALUE, - assetBefore.value.cast().metadata.sortedMapOfName[assetKey]?.fromJsonString(), + assetBefore.value.cast().metadata.sortedMapOfName[assetKey]!!.readValue(), ) - QueryBuilder.findAccountById(ALICE_ACCOUNT_ID) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findAccountById(ALICE_ACCOUNT_ID).signAs(BOB_ACCOUNT_ID, BOB_KEYPAIR)) .also { alice -> assertEquals( RubbishToTestMultipleGenesis.ALICE_KEY_VALUE, - alice.metadata.sortedMapOfName[RubbishToTestMultipleGenesis.ALICE_KEY_VALUE.asName()]?.fromJsonString(), + alice!!.metadata.sortedMapOfName[RubbishToTestMultipleGenesis.ALICE_KEY_VALUE.asName()]!!.readValue(), ) } - QueryBuilder.findAccountById(BOB_ACCOUNT_ID) - .account(BOB_ACCOUNT_ID) - .buildSigned(BOB_KEYPAIR) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findAccountById(BOB_ACCOUNT_ID).signAs(BOB_ACCOUNT_ID, BOB_KEYPAIR)) .also { bob -> assertEquals( RubbishToTestMultipleGenesis.BOB_KEY_VALUE, - bob.metadata.sortedMapOfName[RubbishToTestMultipleGenesis.BOB_KEY_VALUE.asName()]?.fromJsonString(), + bob!!.metadata.sortedMapOfName[RubbishToTestMultipleGenesis.BOB_KEY_VALUE.asName()]!!.readValue(), ) } - QueryBuilder.findDomainById(DEFAULT_DOMAIN_ID) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findDomainById(DEFAULT_DOMAIN_ID)) .also { domain -> assertEquals( RubbishToTestMultipleGenesis.DOMAIN_KEY_VALUE, - domain.metadata.sortedMapOfName[RubbishToTestMultipleGenesis.DOMAIN_KEY_VALUE.asName()]?.fromJsonString(), + domain!!.metadata.sortedMapOfName[RubbishToTestMultipleGenesis.DOMAIN_KEY_VALUE.asName()]!!.readValue(), ) } } @@ -871,55 +908,53 @@ class InstructionsTest : IrohaTest() { fun `transfer domain ownership in genesis`(): Unit = runBlocking { val key = randomAlphabetic(5).asName() val value = randomAlphabetic(5) - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - setKeyValue(WithDomainTransferredToBob.DOMAIN_ID, key, value) - } - val extractedValue = QueryBuilder.findDomainById(WithDomainTransferredToBob.DOMAIN_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .metadata.sortedMapOfName[key] + client.submitAs(BOB_ACCOUNT_ID, BOB_KEYPAIR, SetKeyValue.domain(WithDomainTransferredToBob.DOMAIN_ID, key, value)).also { d -> + withTimeout(txTimeout) { d.await() } + } + val extractedValue: String = client.submit(QueryBuilder.findDomainById(WithDomainTransferredToBob.DOMAIN_ID))!! + .metadata.sortedMapOfName[key]!!.readValue() assertEquals(value, extractedValue) } @Test - @WithIroha([DefaultGenesis::class]) + @WithIroha([DefaultGenesis::class, AliceHasPermissionToRegisterDomain::class]) @Feature("Domains") @Story("Account transfers domain ownership") @SdkTestId("transfer_domain_ownership") fun `transfer domain ownership`(): Unit = runBlocking { val domainId = "Kingdom".asDomainId() - client.tx(ALICE_ACCOUNT_ID, ALICE_KEYPAIR) { registerDomain(domainId) } + client.submit(Register.domain(domainId)).also { d -> + withTimeout(txTimeout) { d.await() } + } assertFailsWith(TransactionRejectedException::class) { - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - setKeyValue(domainId, randomAlphabetic(5).asName(), randomAlphabetic(5)) + client.submitAs( + BOB_ACCOUNT_ID, + BOB_KEYPAIR, + SetKeyValue.domain(domainId, randomAlphabetic(5).asName(), randomAlphabetic(5)), + ).also { d -> + withTimeout(txTimeout) { d.await() } } } - var kingdomDomainOwnedBy = QueryBuilder.findDomainById(domainId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) }.ownedBy + val query = QueryBuilder.findDomainById(domainId) + .signAs(ALICE_ACCOUNT_ID, ALICE_KEYPAIR) + var kingdomDomainOwnedBy = client.submit(query)!!.ownedBy assertEquals(ALICE_ACCOUNT_ID, kingdomDomainOwnedBy) - client.tx(ALICE_ACCOUNT_ID, ALICE_KEYPAIR) { - transferDomainOwnership(ALICE_ACCOUNT_ID, domainId, BOB_ACCOUNT_ID) + client.submit(Transfer.domain(ALICE_ACCOUNT_ID, domainId, BOB_ACCOUNT_ID)).also { d -> + withTimeout(txTimeout) { d.await() } } - kingdomDomainOwnedBy = QueryBuilder.findDomainById(domainId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) }.ownedBy + kingdomDomainOwnedBy = client.submit(query)!!.ownedBy assertEquals(BOB_ACCOUNT_ID, kingdomDomainOwnedBy) val key = randomAlphabetic(5).asName() val value = randomAlphabetic(5) - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { setKeyValue(domainId, key, value) } + client.submitAs(BOB_ACCOUNT_ID, BOB_KEYPAIR, SetKeyValue.domain(domainId, key, value)).also { d -> + withTimeout(txTimeout) { d.await() } + } - val extractedValue = QueryBuilder.findDomainById(domainId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .metadata.sortedMapOfName[key] + val extractedValue: String = client.submit(QueryBuilder.findDomainById(domainId))!! + .metadata.sortedMapOfName[key]!!.readValue() assertEquals(value, extractedValue) } @@ -930,41 +965,23 @@ class InstructionsTest : IrohaTest() { @SdkTestId("initiator_start_network_with_fat_genesis") @WithIroha([FatGenesis::class]) fun `fat genesis apply`(): Unit = runBlocking { - QueryBuilder.findAllAccounts() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } + client.submit(QueryBuilder.findAccounts()) .also { accounts -> assert(accounts.any { it.id == ALICE_ACCOUNT_ID }) } .also { accounts -> assert(accounts.any { it.id == BOB_ACCOUNT_ID }) } } - private suspend fun registerAccount(id: AccountId) { - client.sendTransaction { - account(super.account) - registerAccount(id) - buildSigned(super.keyPair) - }.also { d -> - withTimeout(txTimeout) { d.await() } - } - } - - private suspend fun getAccountAmount(assetId: AssetId = DEFAULT_ASSET_ID) = QueryBuilder - .findAssetById(assetId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> - client.sendQuery(query).value - }.let { value -> - (value as? AssetValue.Numeric)?.numeric?.asLong() ?: 0 + private suspend fun getAccountAmount(assetId: AssetId = DEFAULT_ASSET_ID) = client.submit( + QueryBuilder + .findAssetById(assetId), + )!! + .value.let { value -> + (value as AssetValue.Numeric).numeric.asLong() } - private suspend fun getAsset(assetId: AssetId? = null) = QueryBuilder - .findAssetById(assetId ?: DEFAULT_ASSET_ID) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> - client.sendQuery(query) - } + private suspend fun getAsset(assetId: AssetId? = null) = client.submit( + QueryBuilder + .findAssetById(assetId ?: DEFAULT_ASSET_ID), + )!! private fun List.get(id: AssetId) = this.find { it.id == id } } diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/PeerTest.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/PeerTest.kt index ece88ac9e..e1c2dd674 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/PeerTest.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/PeerTest.kt @@ -7,33 +7,32 @@ import jp.co.soramitsu.iroha2.annotations.Permission import jp.co.soramitsu.iroha2.annotations.Sdk import jp.co.soramitsu.iroha2.annotations.SdkTestId import jp.co.soramitsu.iroha2.client.Iroha2Client -import jp.co.soramitsu.iroha2.generated.AccountId import jp.co.soramitsu.iroha2.generated.DomainId +import jp.co.soramitsu.iroha2.generated.Peer import jp.co.soramitsu.iroha2.generated.PeerId import jp.co.soramitsu.iroha2.generated.SocketAddr import jp.co.soramitsu.iroha2.generated.SocketAddrHost import jp.co.soramitsu.iroha2.query.QueryBuilder import jp.co.soramitsu.iroha2.testengine.ALICE_ACCOUNT_ID import jp.co.soramitsu.iroha2.testengine.ALICE_KEYPAIR -import jp.co.soramitsu.iroha2.testengine.AliceCanUnregisterAnyPeer +import jp.co.soramitsu.iroha2.testengine.AliceCanManagePeers import jp.co.soramitsu.iroha2.testengine.DEFAULT_DOMAIN_ID import jp.co.soramitsu.iroha2.testengine.DefaultGenesis import jp.co.soramitsu.iroha2.testengine.IrohaConfig import jp.co.soramitsu.iroha2.testengine.IrohaContainer import jp.co.soramitsu.iroha2.testengine.IrohaTest import jp.co.soramitsu.iroha2.testengine.WithIroha +import jp.co.soramitsu.iroha2.transaction.Register +import jp.co.soramitsu.iroha2.transaction.Unregister import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.async import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.delay import kotlinx.coroutines.runBlocking import kotlinx.coroutines.time.withTimeout import kotlinx.coroutines.withContext -import org.junit.jupiter.api.Disabled import org.junit.jupiter.api.Test import org.junit.jupiter.api.Timeout import java.security.KeyPair -import java.time.Duration import kotlin.test.assertEquals import kotlin.test.assertFalse import kotlin.test.assertTrue @@ -42,7 +41,6 @@ import kotlin.test.assertTrue @Owner("akostyuchenko") @Sdk("Java/Kotlin") @Feature("Peers") -@Disabled // https://github.com/hyperledger/iroha/issues/4999 class PeerTest : IrohaTest() { companion object { @@ -50,32 +48,23 @@ class PeerTest : IrohaTest() { } @Test - @WithIroha([DefaultGenesis::class], amount = PEER_AMOUNT) + @WithIroha([AliceCanManagePeers::class], amount = PEER_AMOUNT) @Story("Account registers a peer") @Permission("no_permission_required") @SdkTestId("register_peer") fun `register peer`(): Unit = runBlocking { - val p2pPort = DEFAULT_P2P_PORT + PEER_AMOUNT - val alias = "iroha$p2pPort" - val address = "$alias:$p2pPort" val keyPair = generateKeyPair() val payload = keyPair.public.bytes() - val containerJob = async { - startNewContainer(keyPair, alias, PEER_AMOUNT) - } - val registerJob = async { - registerPeer(PeerId(SocketAddr.Host(SocketAddrHost(address, p2pPort)), keyPair.public.toIrohaPublicKey())) + client.submit(Register.peer(PeerId(keyPair.public.toIrohaPublicKey()))).also { d -> + withTimeout(txTimeout) { d.await() } } - containerJob.await() - registerJob.await() - assertTrue(isPeerAvailable(address, payload)) + assertTrue(isPeerRegistered(payload)) } - @Disabled // https://app.zenhub.com/workspaces/iroha-v2-60ddb820813b9100181fc060/issues/gh/hyperledger/iroha-java/372 @Test - @WithIroha([AliceCanUnregisterAnyPeer::class], amount = PEER_AMOUNT) + @WithIroha([AliceCanManagePeers::class], amount = PEER_AMOUNT) @Story("Account unregisters a peer") @Permission("no_permission_required") @SdkTestId("unregister_peer") @@ -87,51 +76,43 @@ class PeerTest : IrohaTest() { val payload = keyPair.public.bytes() startNewContainer(keyPair, alias, PEER_AMOUNT).use { - registerPeer(PeerId(SocketAddr.Host(SocketAddrHost(address, p2pPort)), keyPair.public.toIrohaPublicKey())) - repeat(PEER_AMOUNT) { assertTrue(isPeerAvailable(address, payload)) } + client.submit(Register.peer(PeerId(keyPair.public.toIrohaPublicKey()))).also { d -> + withTimeout(txTimeout) { d.await() } + } + + assertTrue(isPeerRegistered(payload)) + client.submit(Unregister.peer(PeerId(keyPair.public.toIrohaPublicKey()))).also { d -> + withTimeout(txTimeout) { d.await() } + } - unregisterPeer(PeerId(SocketAddr.Host(SocketAddrHost(address, p2pPort)), keyPair.public.toIrohaPublicKey())) - repeat(PEER_AMOUNT) { assertFalse(isPeerAvailable(address, payload)) } + assertFalse(isPeerRegistered(payload)) } } @Test - @WithIroha([DefaultGenesis::class], amount = PEER_AMOUNT) + @WithIroha([AliceCanManagePeers::class], amount = PEER_AMOUNT) fun `registered peer should return consistent data`(): Unit = runBlocking { val p2pPort = DEFAULT_P2P_PORT val alias = "iroha$p2pPort" - val address = "$alias:$p2pPort" val keyPair = generateKeyPair() val payload = keyPair.public.bytes() startNewContainer(keyPair, alias, PEER_AMOUNT).use { container -> - registerPeer(PeerId(SocketAddr.Host(SocketAddrHost(address, p2pPort)), keyPair.public.toIrohaPublicKey())) - assertTrue(isPeerAvailable(address, payload)) - - delay(5000) - - val peersCount = QueryBuilder.findAllPeers() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { client.sendQuery(it) } - .size - - repeat(5) { - runCatching { - QueryBuilder.findAllPeers() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { - Iroha2Client( - container.getApiUrl(), - container.getP2pUrl(), - ).sendQuery(it) - } - .also { peers -> assertEquals(peers.size, peersCount) } - .also { return@repeat } - } - delay(2000) + client.submit(Register.peer(PeerId(keyPair.public.toIrohaPublicKey()))).also { d -> + withTimeout(txTimeout) { d.await() } } + assertTrue(isPeerRegistered(payload)) + + val peersCount = client.submit(QueryBuilder.findPeers()).size + + delay(10000) + Iroha2Client( + listOf(container.getApiUrl()), + container.config.chain, + ALICE_ACCOUNT_ID, + ALICE_KEYPAIR, + ).submit(QueryBuilder.findPeers()) + .also { peers -> assertEquals(peersCount, peers.size) } } } @@ -155,7 +136,7 @@ class PeerTest : IrohaTest() { this.networkToJoin = containers.first().network ?: throw IrohaSdkException("Container network not found") this.submitGenesis = false this.ports = listOf(DEFAULT_P2P_PORT + amount, DEFAULT_API_PORT + amount) - this.trustedPeers = containers.map { it.extractPeerId() } + this.trustedPeers = containers.map { it.extractPeer() } }.also { withContext(Dispatchers.IO) { it.start() @@ -163,62 +144,21 @@ class PeerTest : IrohaTest() { } } - private suspend fun isPeerAvailable( - address: String, - payload: ByteArray, - keyPair: KeyPair = ALICE_KEYPAIR, - ): Boolean { - return QueryBuilder.findAllPeers() - .account(ALICE_ACCOUNT_ID) - .buildSigned(keyPair) - .let { query -> - client.sendQuery(query) - }.any { peer -> - val peerAddr = peer.id.address.cast().socketAddrHost - "${peerAddr.host}:${peerAddr.port}" == address && peer.id.publicKey.payload.contentEquals(payload) + private suspend fun isPeerRegistered(payload: ByteArray, keyPair: KeyPair = ALICE_KEYPAIR): Boolean = + client.submit(QueryBuilder.findPeers()) + .any { peer -> + peer.publicKey.payload.contentEquals(payload) } - } - - private suspend fun unregisterPeer( - peerId: PeerId, - keyPair: KeyPair = ALICE_KEYPAIR, - ) { - client.sendTransaction { - account(ALICE_ACCOUNT_ID) - unregisterPeer(peerId) - buildSigned(keyPair) - }.also { d -> - withTimeout(txTimeout.plus(Duration.ofSeconds(20))) { d.await() } - } - } - - private suspend fun registerPeer( - peerId: PeerId, - account: AccountId = ALICE_ACCOUNT_ID, - keyPair: KeyPair = ALICE_KEYPAIR, - ) { - client.sendTransaction { - account(account) - registerPeer(peerId) - buildSigned(keyPair) - }.also { d -> - withTimeout(txTimeout.plus(Duration.ofSeconds(20))) { d.await() } - } - } - private fun IrohaContainer.extractPeerId() = PeerId( + private fun IrohaContainer.extractPeer() = Peer( SocketAddr.Host( SocketAddrHost( this.config.alias, this.config.ports[IrohaConfig.P2P_PORT_IDX], ), ), - this.config.keyPair.public.toIrohaPublicKey(), + PeerId(this.config.keyPair.public.toIrohaPublicKey()), ) - private suspend fun findDomain(id: DomainId = DEFAULT_DOMAIN_ID) = QueryBuilder - .findDomainById(id) - .account(super.account) - .buildSigned(super.keyPair) - .let { client.sendQuery(it) } + private suspend fun findDomain(id: DomainId = DEFAULT_DOMAIN_ID) = client.submit(QueryBuilder.findDomainById(id))!! } diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/QueriesTest.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/QueriesTest.kt index 30851121d..6991b680a 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/QueriesTest.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/QueriesTest.kt @@ -9,18 +9,49 @@ import jp.co.soramitsu.iroha2.annotations.Sdk import jp.co.soramitsu.iroha2.annotations.SdkTestId import jp.co.soramitsu.iroha2.client.Iroha2Client import jp.co.soramitsu.iroha2.generated.AccountId +import jp.co.soramitsu.iroha2.generated.AccountIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.AccountProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.AssetDefinitionIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.AssetDefinitionIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.AssetId +import jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.AssetProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.AssetType +import jp.co.soramitsu.iroha2.generated.AssetValue +import jp.co.soramitsu.iroha2.generated.CanBurnAssetWithDefinition +import jp.co.soramitsu.iroha2.generated.CanMintAssetWithDefinition +import jp.co.soramitsu.iroha2.generated.CommittedTransactionProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccount +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAsset +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRole +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId import jp.co.soramitsu.iroha2.generated.DomainId +import jp.co.soramitsu.iroha2.generated.DomainIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.DomainIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.DomainProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.InstructionBox +import jp.co.soramitsu.iroha2.generated.Json import jp.co.soramitsu.iroha2.generated.Metadata import jp.co.soramitsu.iroha2.generated.Name +import jp.co.soramitsu.iroha2.generated.NameProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.RegisterBox +import jp.co.soramitsu.iroha2.generated.RoleIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.RoleIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.RoleProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.SignedTransaction -import jp.co.soramitsu.iroha2.generated.StringPredicate +import jp.co.soramitsu.iroha2.generated.SignedTransactionProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.StringPredicateAtom +import jp.co.soramitsu.iroha2.generated.TransactionHashPredicateAtom +import jp.co.soramitsu.iroha2.generated.TransactionHashProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.TriggerIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.TriggerIdProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.query.QueryBuilder import jp.co.soramitsu.iroha2.testengine.ALICE_ACCOUNT_ID -import jp.co.soramitsu.iroha2.testengine.ALICE_KEYPAIR import jp.co.soramitsu.iroha2.testengine.ALICE_PUBLIC_KEY import jp.co.soramitsu.iroha2.testengine.AliceCanMintXor import jp.co.soramitsu.iroha2.testengine.AliceHas100XorAndPermissionToMintAndBurn @@ -44,19 +75,21 @@ import jp.co.soramitsu.iroha2.testengine.WithIroha import jp.co.soramitsu.iroha2.testengine.WithManyDomains import jp.co.soramitsu.iroha2.testengine.XOR_DEFINITION_ID import jp.co.soramitsu.iroha2.testengine.XorAndValAssets -import jp.co.soramitsu.iroha2.transaction.QueryFilters +import jp.co.soramitsu.iroha2.transaction.Burn +import jp.co.soramitsu.iroha2.transaction.Mint +import jp.co.soramitsu.iroha2.transaction.Register import kotlinx.coroutines.runBlocking import kotlinx.coroutines.time.withTimeout import org.apache.commons.lang3.RandomStringUtils import org.junit.jupiter.api.Disabled import org.junit.jupiter.api.Test +import java.math.BigDecimal import java.math.BigInteger import java.security.KeyPair import java.time.Instant import kotlin.test.assertContains import kotlin.test.assertContentEquals import kotlin.test.assertEquals -import kotlin.test.assertTrue @Owner("akostyuchenko") @Sdk("Java/Kotlin") @@ -70,15 +103,10 @@ class QueriesTest : IrohaTest() { @Story("Account queries all accounts") @SdkTestId("find_all_accounts") fun `find all accounts`(): Unit = runBlocking { - QueryBuilder.findAllAccounts() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { accounts -> - assert(accounts.any { it.id.signatory == ALICE_PUBLIC_KEY }) - assert(accounts.any { it.id.signatory == NewAccountWithMetadata.ACCOUNT_ID.signatory }) - } + client.submit(QueryBuilder.findAccounts()).also { accounts -> + assert(accounts.any { ALICE_PUBLIC_KEY == it.id.signatory }) + assert(accounts.any { NewAccountWithMetadata.ACCOUNT_ID.signatory == it.id.signatory }) + } } @Test @@ -88,20 +116,34 @@ class QueriesTest : IrohaTest() { @Story("Account queries all accounts with a filter") @SdkTestId("find_all_accounts_with_filter") fun `find all accounts with filter`(): Unit = runBlocking { - val filter = QueryFilters.or( - StringPredicate.Is("ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland"), - StringPredicate.Is("ed012004FF5B81046DDCCF19E2E451C45DFB6F53759D4EB30FA2EFA807284D1CC33016@wonderland"), + val filter = CompoundPredicateOfAccount.Or( + listOf( + CompoundPredicateOfAccount.Atom( + AccountProjectionOfPredicateMarker.Id( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals( + "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland".asAccountId(), + ), + ), + ), + ), + CompoundPredicateOfAccount.Atom( + AccountProjectionOfPredicateMarker.Id( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals( + "ed012004FF5B81046DDCCF19E2E451C45DFB6F53759D4EB30FA2EFA807284D1CC33016@wonderland".asAccountId(), + ), + ), + ), + ), + ), ) - QueryBuilder.findAllAccounts(filter) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { accounts -> - assert(accounts.size == 2) - assert(accounts.any { it.id.signatory == ALICE_PUBLIC_KEY }) - assert(accounts.any { it.id.signatory == BOB_PUBLIC_KEY }) - } + + client.submit(QueryBuilder.findAccounts(filter)).also { accounts -> + assertEquals(2, accounts.size) + assert(accounts.any { it.id.signatory == ALICE_PUBLIC_KEY }) + assert(accounts.any { it.id.signatory == BOB_PUBLIC_KEY }) + } } @Test @@ -111,17 +153,12 @@ class QueriesTest : IrohaTest() { @Story("Account queries account key value by ID and key") @SdkTestId("find_account_key_value_by_ID_and_key") fun `find account key value by ID and key`(): Unit = runBlocking { - QueryBuilder.findAccountKeyValueByIdAndKey( - NewAccountWithMetadata.ACCOUNT_ID, - NewAccountWithMetadata.KEY, - ) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { - assertEquals(NewAccountWithMetadata.VALUE, it) - } + val metadata = client.submit( + QueryBuilder.findAccountById( + NewAccountWithMetadata.ACCOUNT_ID, + ), + )!!.metadata.sortedMapOfName + assertEquals(NewAccountWithMetadata.VALUE, metadata[ NewAccountWithMetadata.KEY ]!!.readValue()) } @Test @@ -131,31 +168,36 @@ class QueriesTest : IrohaTest() { @Story("Account queries accounts by domain ID") @SdkTestId("find_accounts_by_domain_ID") fun `find accounts by domain ID`(): Unit = runBlocking { - QueryBuilder.findAccountsByDomainId(DEFAULT_DOMAIN_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { accounts -> - assert(accounts.all { it.id.domain == DEFAULT_DOMAIN_ID }) - } + val byDomainIdFilter = CompoundPredicateOfAccount.Atom( + AccountProjectionOfPredicateMarker.Id( + AccountIdProjectionOfPredicateMarker.Domain( + DomainIdProjectionOfPredicateMarker.Atom( + DomainIdPredicateAtom.Equals( + DEFAULT_DOMAIN_ID, + ), + ), + ), + ), + ) + + val accounts = client.submit(QueryBuilder.findAccounts(byDomainIdFilter)) + assert(accounts.all { it.id.domain == DEFAULT_DOMAIN_ID }) } - @Test +// @Test @WithIroha([XorAndValAssets::class, AliceCanMintXor::class]) @Feature("Assets") @Query("FindTotalAssetQuantityByAssetDefinitionId") @Story("Account queries total asset quantity by AssetDefinitionId") @SdkTestId("find_total_asset_quantity_by_AssetDefinitionId") fun `find total asset quantity by AssetDefinitionId`(): Unit = runBlocking { - val quantity = 10 - client.tx { mintAsset(AssetId(definition = XOR_DEFINITION_ID, account = BOB_ACCOUNT_ID), quantity) } + val quantity = BigDecimal(10) + client.submit(Mint.asset(AssetId(BOB_ACCOUNT_ID, XOR_DEFINITION_ID), quantity)).also { + withTimeout(txTimeout) { it.await() } + } - QueryBuilder.findTotalAssetQuantityByAssetDefinitionId(XOR_DEFINITION_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .also { assertEquals(quantity + XorAndValAssets.XOR_QUANTITY, it.asInt()) } + val totalQuantity = client.submit(QueryBuilder.findAssetDefinitionById(XOR_DEFINITION_ID))!!.totalQuantity + assertEquals(quantity + XorAndValAssets.XOR_QUANTITY, totalQuantity.asBigDecimal()) } @Test @@ -165,15 +207,10 @@ class QueriesTest : IrohaTest() { @Story("Account queries all assets") @SdkTestId("find_all_assets") fun `find all assets`(): Unit = runBlocking { - QueryBuilder.findAllAssets() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { assets -> - assert(assets.any { it.id.definition == XOR_DEFINITION_ID }) - assert(assets.any { it.id.definition == VAL_DEFINITION_ID }) - } + client.submit(QueryBuilder.findAssets()).also { assets -> + assert(assets.any { it.id.definition == XOR_DEFINITION_ID }) + assert(assets.any { it.id.definition == VAL_DEFINITION_ID }) + } } @Test @@ -183,14 +220,23 @@ class QueriesTest : IrohaTest() { @Story("Account queries assets by name") @SdkTestId("find_assets_by_name") fun `find assets by name`(): Unit = runBlocking { - QueryBuilder.findAssetsByName(XOR_DEFINITION_ID.name) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { assets -> - assert(assets.all { it.id.definition.name == XOR_DEFINITION_ID.name }) - } + val byNameFilter = CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Definition( + AssetDefinitionIdProjectionOfPredicateMarker.Name( + NameProjectionOfPredicateMarker.Atom( + StringPredicateAtom.Equals( + XOR_DEFINITION_ID.name.string, + ), + ), + ), + ), + ), + ) + + client.submit(QueryBuilder.findAssets(byNameFilter)).also { assets -> + assert(assets.all { it.id.definition.name == XOR_DEFINITION_ID.name }) + } } @Test @@ -200,16 +246,20 @@ class QueriesTest : IrohaTest() { @Story("Account queries assets by account ID") @SdkTestId("find_assets_by_account_ID") fun `find assets by account id`(): Unit = runBlocking { - QueryBuilder.findAssetsByAccountId(ALICE_ACCOUNT_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { assets -> - assert(assets.all { it.id.account == ALICE_ACCOUNT_ID }) - assert(assets.any { it.id.definition == XOR_DEFINITION_ID }) - assert(assets.any { it.id.definition == VAL_DEFINITION_ID }) - } + val byNameFilter = CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Account( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals(ALICE_ACCOUNT_ID), + ), + ), + ), + ) + client.submit(QueryBuilder.findAssets(byNameFilter)).also { assets -> + assert(assets.all { it.id.account == ALICE_ACCOUNT_ID }) + assert(assets.any { it.id.definition == XOR_DEFINITION_ID }) + assert(assets.any { it.id.definition == VAL_DEFINITION_ID }) + } } @Test @@ -219,18 +269,35 @@ class QueriesTest : IrohaTest() { @Story("Account queries assets by domain name and asset definition ID") @SdkTestId("find_assets_by_domain_name_and_asset_definition_ID") fun `find assets by domain name and asset definition id`(): Unit = runBlocking { - QueryBuilder.findAssetsByDomainIdAndAssetDefinitionId( - DEFAULT_DOMAIN_ID, - XOR_DEFINITION_ID, + val byAccountDomainIdAndAssetDefinitionIdFilter = CompoundPredicateOfAsset.And( + listOf( + CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Account( + AccountIdProjectionOfPredicateMarker.Domain( + DomainIdProjectionOfPredicateMarker.Atom( + DomainIdPredicateAtom.Equals(DEFAULT_DOMAIN_ID), + ), + ), + ), + ), + ), + CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Definition( + AssetDefinitionIdProjectionOfPredicateMarker.Atom( + AssetDefinitionIdPredicateAtom.Equals(XOR_DEFINITION_ID), + ), + ), + ), + ), + ), ) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { assets -> - assert(assets.all { it.id.definition == XOR_DEFINITION_ID }) - assert(assets.all { it.id.account.domain == DEFAULT_DOMAIN_ID }) - } + + client.submit(QueryBuilder.findAssets(byAccountDomainIdAndAssetDefinitionIdFilter)).also { assets -> + assert(assets.all { it.id.definition == XOR_DEFINITION_ID }) + assert(assets.all { it.id.account.domain == DEFAULT_DOMAIN_ID }) + } } @Test @@ -240,15 +307,10 @@ class QueriesTest : IrohaTest() { @Story("Account queries asset quantity by asset ID") @SdkTestId("find_asset_quantity_by_ID") fun `find asset quantity by id`(): Unit = runBlocking { - val assetId = AssetId(definition = XOR_DEFINITION_ID, account = ALICE_ACCOUNT_ID) - QueryBuilder.findAssetQuantityById(assetId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { quantity -> - assert(quantity.asInt() == XorAndValAssets.XOR_QUANTITY) - } + val assetId = AssetId(ALICE_ACCOUNT_ID, XOR_DEFINITION_ID) + + val asset = client.submit(QueryBuilder.findAssetById(assetId))!! + assertEquals(XorAndValAssets.XOR_QUANTITY, asset.value.cast().numeric.asBigDecimal()) } @Test @@ -258,17 +320,13 @@ class QueriesTest : IrohaTest() { @Story("Account queries asset key value by ID and key") @SdkTestId("find_asset_key_value_by_ID_and_key") fun `find asset key value by ID and key`(): Unit = runBlocking { - QueryBuilder.findAssetKeyValueByIdAndKey( - StoreAssetWithMetadata.ASSET_ID, - StoreAssetWithMetadata.ASSET_KEY, - ) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { value -> - assert(value == StoreAssetWithMetadata.ASSET_VALUE) - } + val metadata = client.submit( + QueryBuilder.findAssetById( + StoreAssetWithMetadata.ASSET_ID, + ), + )!!.metadata() + + assertEquals(StoreAssetWithMetadata.ASSET_VALUE, metadata[StoreAssetWithMetadata.ASSET_KEY]!!.readValue()) } @Test @@ -278,17 +336,12 @@ class QueriesTest : IrohaTest() { @Story("Account queries asset definition key value by ID and key") @SdkTestId("find_asset_definition_key_value_by_ID_and_key") fun `find asset definition key value by ID and key`(): Unit = runBlocking { - QueryBuilder.findAssetDefinitionKeyValueByIdAndKey( - StoreAssetWithMetadata.DEFINITION_ID, - StoreAssetWithMetadata.ASSET_KEY, - ) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { - assertEquals(it, StoreAssetWithMetadata.ASSET_VALUE) - } + val metadata = client.submit( + QueryBuilder.findAssetDefinitionById( + StoreAssetWithMetadata.DEFINITION_ID, + ), + )!!.metadata.sortedMapOfName + assertEquals(StoreAssetWithMetadata.ASSET_VALUE, metadata[StoreAssetWithMetadata.ASSET_KEY]!!.readValue()) } @Test @@ -299,14 +352,9 @@ class QueriesTest : IrohaTest() { @SdkTestId("find_asset_by_metadata_filters") @Disabled // https://github.com/hyperledger/iroha/issues/2697 fun `find asset by metadata filters`(): Unit = runBlocking { - QueryBuilder.findAllAssets() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { - assert(it.isNotEmpty()) - } + client.submit(QueryBuilder.findAssets()).also { + assert(it.isNotEmpty()) + } } @Test @@ -316,13 +364,8 @@ class QueriesTest : IrohaTest() { @Story("Account queries asset definition by ID") @SdkTestId("find_asset_definition_by_ID") fun `find asset definition by ID`(): Unit = runBlocking { - QueryBuilder.findAssetDefinitionById(DEFAULT_ASSET_DEFINITION_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { client.sendQuery(it) } - .also { assetDefinition -> - assertEquals(assetDefinition.id, DEFAULT_ASSET_DEFINITION_ID) - } + client.submit(QueryBuilder.findAssetDefinitionById(DEFAULT_ASSET_DEFINITION_ID))!! + .also { assertEquals(it.id, DEFAULT_ASSET_DEFINITION_ID) } } @Test @@ -332,12 +375,8 @@ class QueriesTest : IrohaTest() { @Story("Account queries all domains") @SdkTestId("find_all_domains") fun `find all domains`(): Unit = runBlocking { - QueryBuilder.findAllDomains() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { domains -> + client.submit(QueryBuilder.findDomains()) + .also { domains -> assert(domains.any { it.id == DEFAULT_DOMAIN_ID }) assert(domains.any { it.id == NewDomain.DOMAIN_ID }) } @@ -350,16 +389,19 @@ class QueriesTest : IrohaTest() { @Story("Account queries all domains with filter") @SdkTestId("find_all_domains_with_filter") fun `find all domains with filter`(): Unit = runBlocking { - val filter = QueryFilters.startsWith("wonder") - QueryBuilder.findAllDomains(filter) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { domains -> - assert(domains.size == 1) - assert(domains.any { it.id == DEFAULT_DOMAIN_ID }) - } + val filter = CompoundPredicateOfDomain.Atom( + DomainProjectionOfPredicateMarker.Id( + DomainIdProjectionOfPredicateMarker.Name( + NameProjectionOfPredicateMarker.Atom( + StringPredicateAtom.StartsWith("wonder"), + ), + ), + ), + ) + + val domains = client.submit(QueryBuilder.findDomains(filter)) + assertEquals(1, domains.size) + assertEquals(DEFAULT_DOMAIN_ID, domains[0].id) } @Test @@ -369,14 +411,9 @@ class QueriesTest : IrohaTest() { @Story("Domain queries domain by ID") @SdkTestId("find_domain_by_ID") fun `find domain by ID`(): Unit = runBlocking { - QueryBuilder.findDomainById(DEFAULT_DOMAIN_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { domain -> - assert(domain.id == DEFAULT_DOMAIN_ID) - } + client.submit(QueryBuilder.findDomainById(DEFAULT_DOMAIN_ID))!!.also { + assertEquals(DEFAULT_DOMAIN_ID, it.id) + } } @Test @@ -386,14 +423,8 @@ class QueriesTest : IrohaTest() { @Story("Peer queries all peers") @SdkTestId("find_all_peers") fun `find all peers`(): Unit = runBlocking { - QueryBuilder.findAllPeers() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { peers -> - assert(peers.isNotEmpty()) - } + client.submit(QueryBuilder.findPeers()) + .also { assert(it.isNotEmpty()) } } @Test @@ -403,26 +434,25 @@ class QueriesTest : IrohaTest() { @Story("Transaction queries transactions by account id") @SdkTestId("find_transactions_by_account_id") fun `find transactions by account id`(): Unit = runBlocking { - client.sendTransaction { - account(ALICE_ACCOUNT_ID) - registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()) - buildSigned(ALICE_KEYPAIR) + client.submit(Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric())).also { + withTimeout(txTimeout) { it.await() } } - QueryBuilder.findTransactionsByAccountId(ALICE_ACCOUNT_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.let { txValues -> - txValues.all { value -> - value.transaction.value - .cast().signedTransactionV1 - .payload.authority == ALICE_ACCOUNT_ID - } - }.also { - assert(it) - } + val result = client.submit( + QueryBuilder.findTransactions( + CompoundPredicateOfCommittedTransaction.Atom( + CommittedTransactionProjectionOfPredicateMarker.Value( + SignedTransactionProjectionOfPredicateMarker.Authority( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals(ALICE_ACCOUNT_ID), + ), + ), + ), + ), + ), + ) + + assertEquals(1, result.size) } @Test @@ -432,17 +462,14 @@ class QueriesTest : IrohaTest() { @Story("PermissionToken queries permission tokens by account id") @SdkTestId("find_permission_tokens_by_account_id") fun `find permission tokens by account id`(): Unit = runBlocking { - QueryBuilder.findPermissionsByAccountId(ALICE_ACCOUNT_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - } - .let { tokens -> - tokens.any { "{\"asset_definition\":\"xor#wonderland\"}" == it.payload } - }.also { - assert(it) - } + val result = client.submit(QueryBuilder.findPermissionsByAccountId(ALICE_ACCOUNT_ID)).filter { + it.name == CanMintAssetWithDefinition::class.simpleName && + CanMintAssetWithDefinition("xor#wonderland".asAssetDefinitionId()) == it.payload.readValue() || + it.name == CanBurnAssetWithDefinition::class.simpleName && + CanBurnAssetWithDefinition("xor#wonderland".asAssetDefinitionId()) == it.payload.readValue() + } + + assertEquals(2, result.size) } @Test @@ -452,32 +479,35 @@ class QueriesTest : IrohaTest() { @Story("Transaction queries transaction by hash") @SdkTestId("find_transaction_by_hash") fun `find transaction by hash`(): Unit = runBlocking { - client.sendTransaction { - account(ALICE_ACCOUNT_ID) - registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()) - buildSigned(ALICE_KEYPAIR) - }.let { d -> - withTimeout(txTimeout) { d.await() } + client.submit(Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric())).let { + withTimeout(txTimeout) { it.await() } } - val transactions = QueryBuilder.findAllTransactions() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - - val hash = SignedTransaction.encode(transactions[2].transaction.value).hash() + var transactions = client.submit(QueryBuilder.findTransactions()) + val hash = SignedTransaction.encode(transactions[2].value).hash() + + transactions = client.submit( + QueryBuilder.findTransactions( + CompoundPredicateOfCommittedTransaction.Atom( + CommittedTransactionProjectionOfPredicateMarker.Value( + SignedTransactionProjectionOfPredicateMarker.Hash( + TransactionHashProjectionOfPredicateMarker.Atom( + TransactionHashPredicateAtom.Equals(hash.asHashOf()), + ), + ), + ), + ), + ), + ) - val txByHash = QueryBuilder.findTransactionByHash(hash) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } + assertEquals(1, transactions.size) assertEquals( DEFAULT_ASSET_DEFINITION_ID.domain, - txByHash.transaction.value + transactions[0].value .extractInstruction() .registerBox.cast().registerOfDomain.`object`.id, ) - txByHash.transaction.value + transactions[0].value .let { SignedTransaction.encode(it).hash() } .also { assertContentEquals(hash, it) } } @@ -489,13 +519,11 @@ class QueriesTest : IrohaTest() { @Story("Domain queries domain key value by ID and key") @SdkTestId("find_domain_key_value_by_ID_and_key") fun `find domain key value by ID and key`(): Unit = runBlocking { - QueryBuilder.findDomainKeyValueByIdAndKey( - NewDomainWithMetadata.DOMAIN_ID, - NewDomainWithMetadata.KEY, - ).account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .also { assertEquals(NewDomainWithMetadata.VALUE, it) } + val metadata = client.submit( + QueryBuilder.findDomainById(NewDomainWithMetadata.DOMAIN_ID), + )!!.metadata.sortedMapOfName + + assertEquals(NewDomainWithMetadata.VALUE, metadata[NewDomainWithMetadata.KEY]!!.readValue()) } @Test @@ -507,25 +535,8 @@ class QueriesTest : IrohaTest() { fun `find trigger by ID`(): Unit = runBlocking { val triggerId = WithExecutableTrigger.TRIGGER_ID - QueryBuilder.findTriggerById(triggerId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { client.sendQuery(it) } - .also { trigger -> assertTrue { trigger.id == triggerId } } - } - - @Test - @WithIroha([WithExecutableTrigger::class]) - @Feature("Triggers") - @Query("FindTriggersByDomainId") - @Story("Trigger queries triggers by domain ID") - @SdkTestId("find_triggers_by_domain_id") - fun `find triggers by domain ID`(): Unit = runBlocking { - QueryBuilder.findTriggersByAuthorityDomainId(ALICE_ACCOUNT_ID.domain) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { client.sendQuery(it) } - .also { triggers -> assert(triggers.all { it.id == WithExecutableTrigger.TRIGGER_ID }) } + val trigger = client.submit(QueryBuilder.findTriggerById(triggerId))!! + assertEquals(triggerId, trigger.id) } @Test @@ -537,13 +548,18 @@ class QueriesTest : IrohaTest() { fun `find all active trigger IDs`(): Unit = runBlocking { val triggerId = WithExecutableTrigger.TRIGGER_ID - QueryBuilder.findAllActiveTriggerIds() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { client.sendQuery(it) } - .also { ids -> - assertTrue { ids.all { it == triggerId } } - } + val triggers = client.submit( + QueryBuilder.findActiveTriggerIds( + CompoundPredicateOfTriggerId.Atom( + TriggerIdProjectionOfPredicateMarker.Atom( + TriggerIdPredicateAtom.Equals(triggerId), + ), + ), + ), + ) + + assertEquals(1, triggers.size) + assertEquals(triggerId, triggers[0]) } @Test @@ -556,21 +572,16 @@ class QueriesTest : IrohaTest() { val key1 = RandomStringUtils.randomAlphabetic(5).asName() val key2 = RandomStringUtils.randomAlphabetic(5).asName() - createAccount(metadata = mapOf(key1 to "1", key2 to "1")) - createAccount(metadata = mapOf(key1 to "0", key2 to "0")) - createAccount(metadata = mapOf(key1 to "2", key2 to "2")) + createAccount(metadata = mapOf(key1 to Json.writeValue("1"), key2 to Json.writeValue("1"))) + createAccount(metadata = mapOf(key1 to Json.writeValue("0"), key2 to Json.writeValue("0"))) + createAccount(metadata = mapOf(key1 to Json.writeValue("2"), key2 to Json.writeValue("2"))) listOf(key1, key2).forEach { key -> - QueryBuilder.findAllAccounts() - .account(ALICE_ACCOUNT_ID) - .sorting(key.string) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .let { accounts -> - assertEquals("0", accounts[0].metadata.sortedMapOfName[key]) - assertEquals("1", accounts[1].metadata.sortedMapOfName[key]) - assertEquals("2", accounts[2].metadata.sortedMapOfName[key]) - } + client.submit(QueryBuilder.findAccounts().sorting(key.string)).let { accounts -> + assertEquals("0", accounts[0].metadata.sortedMapOfName[key]!!.readValue()) + assertEquals("1", accounts[1].metadata.sortedMapOfName[key]!!.readValue()) + assertEquals("2", accounts[2].metadata.sortedMapOfName[key]!!.readValue()) + } } } @@ -584,60 +595,69 @@ class QueriesTest : IrohaTest() { val key = "ts".asName() val limit = 3L - val metadata0 = Instant.now().toEpochMilli().toString() - createAccount(domainId = NewDomainWithMetadata.DOMAIN_ID, metadata = mapOf(key to metadata0)) - val metadata1 = Instant.now().toEpochMilli().toString() - createAccount(domainId = NewDomainWithMetadata.DOMAIN_ID, metadata = mapOf(key to metadata1)) - val metadata2 = Instant.now().toEpochMilli().toString() - createAccount(domainId = NewDomainWithMetadata.DOMAIN_ID, metadata = mapOf(key to metadata2)) - val metadata3 = Instant.now().toEpochMilli().toString() - createAccount(domainId = NewDomainWithMetadata.DOMAIN_ID, metadata = mapOf(key to metadata3)) - val metadata4 = Instant.now().toEpochMilli().toString() - createAccount(domainId = NewDomainWithMetadata.DOMAIN_ID, metadata = mapOf(key to metadata4)) - - QueryBuilder.findAccountsByDomainId(NewDomainWithMetadata.DOMAIN_ID) - .account(ALICE_ACCOUNT_ID) - .pagination(limit = limit) - .sorting(key) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } + val metadata0 = Instant.now().toEpochMilli() + val metadata1 = Instant.now().toEpochMilli() + val metadata2 = Instant.now().toEpochMilli() + val metadata3 = Instant.now().toEpochMilli() + val metadata4 = Instant.now().toEpochMilli() + + createAccount(NewDomainWithMetadata.DOMAIN_ID, mapOf(key to Json.writeValue(metadata0))) + createAccount(NewDomainWithMetadata.DOMAIN_ID, mapOf(key to Json.writeValue(metadata1))) + createAccount(NewDomainWithMetadata.DOMAIN_ID, mapOf(key to Json.writeValue(metadata2))) + createAccount(NewDomainWithMetadata.DOMAIN_ID, mapOf(key to Json.writeValue(metadata3))) + createAccount(NewDomainWithMetadata.DOMAIN_ID, mapOf(key to Json.writeValue(metadata4))) + + val byDomainIdFilter = CompoundPredicateOfAccount.Atom( + AccountProjectionOfPredicateMarker.Id( + AccountIdProjectionOfPredicateMarker.Domain( + DomainIdProjectionOfPredicateMarker.Atom( + DomainIdPredicateAtom.Equals( + NewDomainWithMetadata.DOMAIN_ID, + ), + ), + ), + ), + ) + client.submit( + QueryBuilder.findAccounts(byDomainIdFilter) + .pagination(limit.toBigInteger()) + .sorting(key), + ).map { it.metadata.sortedMapOfName } .let { accounts -> assertEquals(limit, accounts.size.toLong()) - assertEquals(metadata2, accounts[2].metadata.sortedMapOfName[key]) + assertEquals(metadata2, accounts[2][key]!!.readValue()) } - QueryBuilder.findAccountsByDomainId(NewDomainWithMetadata.DOMAIN_ID) - .account(ALICE_ACCOUNT_ID) - .pagination(start = limit.toBigInteger(), limit = limit) - .sorting(key) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } + client.submit( + QueryBuilder.findAccounts(byDomainIdFilter) + .pagination(limit.toBigInteger(), limit.toBigInteger()) + .sorting(key), + ).map { it.metadata.sortedMapOfName } .let { accounts -> assertEquals(2, accounts.size) - assertEquals(metadata4, accounts[1].metadata.sortedMapOfName[key]) + assertEquals(metadata4, accounts[1][key]!!.readValue()) } - val metadata5 = Instant.now().toEpochMilli().toString() - createAccount(domainId = NewDomainWithMetadata.DOMAIN_ID, metadata = mapOf(key to metadata5)) - val metadata6 = Instant.now().toEpochMilli().toString() - createAccount(domainId = NewDomainWithMetadata.DOMAIN_ID, metadata = mapOf(key to metadata6)) - val metadata7 = Instant.now().toEpochMilli().toString() - createAccount(domainId = NewDomainWithMetadata.DOMAIN_ID, metadata = mapOf(key to metadata7)) - val metadata8 = Instant.now().toEpochMilli().toString() - createAccount(domainId = NewDomainWithMetadata.DOMAIN_ID, metadata = mapOf(key to metadata8)) - - QueryBuilder.findAccountsByDomainId(NewDomainWithMetadata.DOMAIN_ID) - .account(ALICE_ACCOUNT_ID) - .pagination(start = BigInteger.valueOf(2).multiply(limit.toBigInteger()), limit = limit) - .sorting(key) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } + val metadata5 = Instant.now().toEpochMilli() + val metadata6 = Instant.now().toEpochMilli() + val metadata7 = Instant.now().toEpochMilli() + val metadata8 = Instant.now().toEpochMilli() + + createAccount(NewDomainWithMetadata.DOMAIN_ID, mapOf(key to Json.writeValue(metadata5))) + createAccount(NewDomainWithMetadata.DOMAIN_ID, mapOf(key to Json.writeValue(metadata6))) + createAccount(NewDomainWithMetadata.DOMAIN_ID, mapOf(key to Json.writeValue(metadata7))) + createAccount(NewDomainWithMetadata.DOMAIN_ID, mapOf(key to Json.writeValue(metadata8))) + + client.submit( + QueryBuilder.findAccounts(byDomainIdFilter) + .pagination(limit.toBigInteger(), BigInteger.valueOf(2).multiply(limit.toBigInteger())) + .sorting(key), + ) + .map { it.metadata.sortedMapOfName } .let { accounts -> assertEquals(3, accounts.size) - assertEquals(metadata6, accounts[0].metadata.sortedMapOfName[key]) - assertEquals(metadata8, accounts[2].metadata.sortedMapOfName[key]) + assertEquals(metadata6, accounts[0][key]!!.readValue()) + assertEquals(metadata8, accounts[2][key]!!.readValue()) } - print(metadata5) - print(metadata7) } @Test @@ -649,20 +669,15 @@ class QueriesTest : IrohaTest() { fun `find all account with pagination`(): Unit = runBlocking { val limit = 5L val start = 3L - var accounts = QueryBuilder.findAllAccounts() - .account(ALICE_ACCOUNT_ID) - .pagination(limit = 5) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } + + var accounts = client.submit(QueryBuilder.findAccounts().pagination(BigInteger.valueOf(5))) assertEquals(3, accounts.size) repeat(2) { createAccount() } - - accounts = QueryBuilder.findAllAccounts() - .account(ALICE_ACCOUNT_ID) - .pagination(start = BigInteger.valueOf(start), limit = limit) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } + accounts = client.submit( + QueryBuilder.findAccounts() + .pagination(BigInteger.valueOf(limit), BigInteger.valueOf(start)), + ) assertEquals(limit - start, accounts.size.toLong()) } @@ -674,21 +689,13 @@ class QueriesTest : IrohaTest() { @SdkTestId("find_all_transactions") fun `find all transactions`(): Unit = runBlocking { repeat(5) { - client.sendTransaction { - account(ALICE_ACCOUNT_ID) - burnAsset(DEFAULT_ASSET_ID, 1) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } + client.submit(Burn.asset(DEFAULT_ASSET_ID, BigDecimal(1))).also { + withTimeout(txTimeout) { it.await() } } } - QueryBuilder.findAllTransactions() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { client.sendQuery(it) } - .also { txs -> - assertTrue(txs.size == 9) // 5 + 4 genesis txs - } + client.submit(QueryBuilder.findTransactions()).also { + assertEquals(9, it.size) // 5 + 4 genesis txs + } } @Test @@ -698,59 +705,64 @@ class QueriesTest : IrohaTest() { @Story("Account queries all blocks") @SdkTestId("find_all_blocks") fun `find all blocks`(): Unit = runBlocking { - client.sendTransaction { - account(ALICE_ACCOUNT_ID) - burnAsset(DEFAULT_ASSET_ID, 1) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } + client.submit(Burn.asset(DEFAULT_ASSET_ID, BigDecimal(1))).also { + withTimeout(txTimeout) { it.await() } } - QueryBuilder.findAllBlocks() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { client.sendQuery(it) } - .also { blocks -> - assertTrue(blocks.size == 2) - } - } - - @Test - @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) - @Feature("Blocks") - @Query("FindAllBlockHeaders") - @Story("Account queries all block headers") - @SdkTestId("find_all_block_headers") - fun `find all block headers`(): Unit = runBlocking { - client.sendTransaction { - account(ALICE_ACCOUNT_ID) - burnAsset(DEFAULT_ASSET_ID, 1) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } + client.submit(QueryBuilder.findBlocks()).also { + assertEquals(2, it.size) } - QueryBuilder.findAllBlockHeaders() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { client.sendQuery(it) } - .also { headers -> - assertTrue(headers.size == 2) - } } +// @Test +// @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) +// @Feature("Blocks") +// @Query("FindAllBlockHeaders") +// @Story("Account queries all block headers") +// @SdkTestId("find_all_block_headers") +// fun `find all block headers`(): Unit = runBlocking { +// client.submit(Burn.asset(DEFAULT_ASSET_ID, BigDecimal(1))).also { +// withTimeout(txTimeout) { it.await() } +// } +// val headers: List = client.submit( +// QueryBuilder.findBlocks( +// selector = SelectorTupleOfSignedBlock( +// listOf( +// SignedBlockProjectionOfSelectorMarker.Header(BlockHeaderProjectionOfSelectorMarker.Atom()), +// ), +// ), +// ), +// ) +// assertEquals(2, headers.size) +// } + +// @Test +// @WithIroha([AliceHasRoleWithAccessToBobsMetadata::class]) +// @Feature("Roles") +// @Query("FindAllRoleIds") +// @Story("Account queries all role IDs") +// @SdkTestId("find_all_role_IDs") +// fun `find all role IDs`(): Unit = runBlocking { +// val roles: List = client.submit( +// QueryBuilder.findRoles( +// selector = SelectorTupleOfRole( +// listOf( +// RoleProjectionOfSelectorMarker.Id(RoleIdProjectionOfSelectorMarker.Atom()), +// ), +// ), +// ), +// ) +// assertContains(roles, AliceHasRoleWithAccessToBobsMetadata.ROLE_ID) +// } + @Test @WithIroha([AliceHasRoleWithAccessToBobsMetadata::class]) @Feature("Roles") - @Query("FindAllRoleIds") - @Story("Account queries all role IDs") - @SdkTestId("find_all_role_IDs") - fun `find all role IDs`(): Unit = runBlocking { - QueryBuilder.findAllRoleIds() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .also { ids -> - assertContains(ids, AliceHasRoleWithAccessToBobsMetadata.ROLE_ID) - } + @Query("FindAllRoles") + @Story("Account queries all roles") + @SdkTestId("find_all_roles") + fun `find all roles`(): Unit = runBlocking { + val roles = client.submit(QueryBuilder.findRoles()) + assertEquals(1, roles.size) } @Test @@ -760,32 +772,9 @@ class QueriesTest : IrohaTest() { @Story("Account queries roles by account ID") @SdkTestId("find_roles_by_account_ID") fun `find roles by account ID`(): Unit = runBlocking { - QueryBuilder.findRolesByAccountId(ALICE_ACCOUNT_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .also { ids -> - assertContains(ids, AliceHasRoleWithAccessToBobsMetadata.ROLE_ID) - } - } - - @Test - @WithIroha([AliceHasRoleWithAccessToBobsMetadata::class]) - @Feature("Roles") - @Query("FindAllRoles") - @Story("Account queries all roles") - @SdkTestId("find_all_roles") - fun `find all roles`(): Unit = runBlocking { - QueryBuilder.findAllRoles() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .also { roles -> - assertContains( - roles.map { it.id }, - AliceHasRoleWithAccessToBobsMetadata.ROLE_ID, - ) - } + client.submit(QueryBuilder.findRolesByAccountId(ALICE_ACCOUNT_ID)).also { + assertContains(it, AliceHasRoleWithAccessToBobsMetadata.ROLE_ID) + } } @Test @@ -796,11 +785,17 @@ class QueriesTest : IrohaTest() { @SdkTestId("find_role_by_role_ID") fun `find role by ID`(): Unit = runBlocking { val roleId = AliceHasRoleWithAccessToBobsMetadata.ROLE_ID - QueryBuilder.findRoleByRoleId(roleId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .also { role -> assertEquals(role.id, roleId) } + + val result = client.submit( + QueryBuilder.findRoles( + CompoundPredicateOfRole.Atom( + RoleProjectionOfPredicateMarker.Id(RoleIdProjectionOfPredicateMarker.Atom(RoleIdPredicateAtom.Equals(roleId))), + ), + ), + ) + + assertEquals(1, result.size) + assertEquals(roleId, result[0].id) } @Test @@ -811,18 +806,19 @@ class QueriesTest : IrohaTest() { @SdkTestId("find_asset_definitions_with_or_filter") fun `find asset definitions with or filter`(): Unit = runBlocking { val definitionId = AliceWithTestAssets.TEST_ASSET_DEFINITION_ID - val filter = QueryFilters.or( - StringPredicate.Is("${definitionId.name.string}#${definitionId.domain.name.string}"), + + val assets = client.submit( + QueryBuilder.findAssetsDefinitions( + CompoundPredicateOfAssetDefinition.Atom( + AssetDefinitionProjectionOfPredicateMarker.Id( + AssetDefinitionIdProjectionOfPredicateMarker.Atom(AssetDefinitionIdPredicateAtom.Equals(definitionId)), + ), + ), + ), ) - QueryBuilder.findAllAssetsDefinitions(filter) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { assets -> - assertEquals(1, assets.size) - assertEquals(definitionId, assets[0].id) - } + + assertEquals(1, assets.size) + assertEquals(definitionId, assets[0].id) } @WithIroha([WithManyDomains::class]) @@ -831,25 +827,16 @@ class QueriesTest : IrohaTest() { @Story("Account queries all domains using cursor pagination") @SdkTestId("querying_multiple_domains_with_cursor_test") fun `find multiple domains with cursor test`(): Unit = runBlocking { - val domains = QueryBuilder.findAllDomains() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } + val domains = client.submit(QueryBuilder.findDomains()) assertEquals(WithManyDomains.DOMAINS_COUNT + 2, domains.size) } - private suspend fun createAccount( - domainId: DomainId = DEFAULT_DOMAIN_ID, - keyPair: KeyPair = generateKeyPair(), - metadata: Map = mapOf(), - ) { + private suspend fun createAccount(domainId: DomainId = DEFAULT_DOMAIN_ID, metadata: Map = mapOf()) { + val keyPair: KeyPair = generateKeyPair() val newAccountId = AccountId(domainId, keyPair.public.toIrohaPublicKey()) - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - registerAccount(newAccountId, Metadata(metadata)) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } + + client.submit(Register.account(newAccountId, Metadata(metadata))).also { + withTimeout(txTimeout) { it.await() } } } } diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/TriggersTest.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/TriggersTest.kt index f28aa9b96..50497629b 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/TriggersTest.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/TriggersTest.kt @@ -7,15 +7,20 @@ import jp.co.soramitsu.iroha2.annotations.Sdk import jp.co.soramitsu.iroha2.annotations.SdkTestId import jp.co.soramitsu.iroha2.client.Iroha2Client import jp.co.soramitsu.iroha2.generated.AccountId +import jp.co.soramitsu.iroha2.generated.AccountIdPredicateAtom +import jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.AssetDefinitionId import jp.co.soramitsu.iroha2.generated.AssetId +import jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker +import jp.co.soramitsu.iroha2.generated.AssetProjectionOfPredicateMarker import jp.co.soramitsu.iroha2.generated.AssetType import jp.co.soramitsu.iroha2.generated.AssetValue +import jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAsset import jp.co.soramitsu.iroha2.generated.EventFilterBox -import jp.co.soramitsu.iroha2.generated.InstructionBox -import jp.co.soramitsu.iroha2.generated.Metadata -import jp.co.soramitsu.iroha2.generated.Name +import jp.co.soramitsu.iroha2.generated.ExecuteTriggerEventFilter +import jp.co.soramitsu.iroha2.generated.ExecutionTime import jp.co.soramitsu.iroha2.generated.Repeats +import jp.co.soramitsu.iroha2.generated.TimeEventFilter import jp.co.soramitsu.iroha2.generated.TriggerId import jp.co.soramitsu.iroha2.query.QueryBuilder import jp.co.soramitsu.iroha2.testengine.ALICE_ACCOUNT_ID @@ -29,15 +34,22 @@ import jp.co.soramitsu.iroha2.testengine.IROHA_CONFIG_DELIMITER import jp.co.soramitsu.iroha2.testengine.IrohaTest import jp.co.soramitsu.iroha2.testengine.WithIroha import jp.co.soramitsu.iroha2.testengine.XOR_DEFINITION_ID +import jp.co.soramitsu.iroha2.transaction.Burn import jp.co.soramitsu.iroha2.transaction.EntityFilters import jp.co.soramitsu.iroha2.transaction.EventFilters +import jp.co.soramitsu.iroha2.transaction.Execute import jp.co.soramitsu.iroha2.transaction.Filters -import jp.co.soramitsu.iroha2.transaction.Instructions +import jp.co.soramitsu.iroha2.transaction.Instruction +import jp.co.soramitsu.iroha2.transaction.Mint +import jp.co.soramitsu.iroha2.transaction.Register +import jp.co.soramitsu.iroha2.transaction.SetKeyValue +import jp.co.soramitsu.iroha2.transaction.Transfer +import jp.co.soramitsu.iroha2.transaction.Unregister import kotlinx.coroutines.delay import kotlinx.coroutines.runBlocking import kotlinx.coroutines.time.withTimeout import org.junit.jupiter.api.Test -import org.junit.jupiter.api.assertThrows +import java.math.BigDecimal import java.math.BigInteger import java.security.KeyPair import java.time.Duration @@ -45,6 +57,7 @@ import java.time.Instant import java.util.Date import kotlin.test.assertEquals import kotlin.test.assertNotNull +import kotlin.test.assertNull @Feature("Triggers") @Owner("akostyuchenko") @@ -60,10 +73,8 @@ class TriggersTest : IrohaTest() { val newAssetName = "token1" // check account assets before trigger - val query = QueryBuilder.findAllAssetsDefinitions() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - val assetDefinitions = client.sendQuery(query) + val query = QueryBuilder.findAssetsDefinitions() + val assetDefinitions = client.submit(query) assertEquals(1, assetDefinitions.size) val asset = assetDefinitions.first { it.id.name.string == "xor" } assertNotNull(asset) @@ -75,20 +86,18 @@ class TriggersTest : IrohaTest() { val filter = EventFilterBox.Data( EntityFilters.byAssetDefinition(1), ) - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - registerEventTrigger( + client.submit( + Register.trigger( triggerId, - listOf(Instructions.mintAsset(DEFAULT_ASSET_ID, 1)), + listOf(Mint.asset(DEFAULT_ASSET_ID, BigDecimal(1))), Repeats.Indefinitely(), ALICE_ACCOUNT_ID, - Metadata(mapOf()), filter, - ) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } - } + ), + ) + .also { d -> + withTimeout(txTimeout) { d.await() } + } // register new asset // after that trigger should mint DEFAULT_ASSET_ID @@ -108,10 +117,8 @@ class TriggersTest : IrohaTest() { val newAssetName = "token1" // check account assets before trigger - val query = QueryBuilder.findAllAssetsDefinitions() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - val assetDefinitions = client.sendQuery(query) + val query = QueryBuilder.findAssetsDefinitions() + val assetDefinitions = client.submit(query) assertEquals(1, assetDefinitions.size) // check DEFAULT_ASSET_ID quantity before trigger @@ -119,16 +126,15 @@ class TriggersTest : IrohaTest() { assertEquals(100L, prevQuantity) // register pre commit trigger - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - registerPreCommitTrigger( + client.submit( + Register.trigger( triggerId, - listOf(Instructions.mintAsset(DEFAULT_ASSET_ID, 10)), + listOf(Mint.asset(DEFAULT_ASSET_ID, BigDecimal(10))), Repeats.Indefinitely(), ALICE_ACCOUNT_ID, - ) - buildSigned(ALICE_KEYPAIR) - }.also { d -> + EventFilterBox.Time(TimeEventFilter(ExecutionTime.PreCommit())), + ), + ).also { d -> withTimeout(txTimeout) { d.await() } } @@ -145,13 +151,10 @@ class TriggersTest : IrohaTest() { assertEquals(120L, newQuantity) // transfer asset instruction just to test trigger - client.sendTransaction { - account(ALICE_ACCOUNT_ID) - transferAsset(DEFAULT_ASSET_ID, 100, BOB_ACCOUNT_ID) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } - } + client.submit(Transfer.asset(DEFAULT_ASSET_ID, BigDecimal(100), BOB_ACCOUNT_ID)) + .also { d -> + withTimeout(txTimeout) { d.await() } + } // check DEFAULT_ASSET_ID quantity after trigger is run newQuantity = checkDefaultAssetQuantity() @@ -163,19 +166,18 @@ class TriggersTest : IrohaTest() { @Story("Executable trigger mints asset") @SdkTestId("executable_trigger") fun `executable trigger`(): Unit = runBlocking { - val triggerId = TriggerId(name = "executable_trigger".asName()) + val triggerId = TriggerId("executable_trigger".asName()) - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - registerExecutableTrigger( + client.submit( + Register.trigger( triggerId, - listOf(Instructions.mintAsset(DEFAULT_ASSET_ID, 1)), + listOf(Mint.asset(DEFAULT_ASSET_ID, BigDecimal(1))), Repeats.Exactly(1L), ALICE_ACCOUNT_ID, - ) - executeTrigger(triggerId) - buildSigned(ALICE_KEYPAIR) - }.also { d -> + EventFilterBox.ExecuteTrigger(ExecuteTriggerEventFilter(triggerId)), + ), + Execute.trigger(triggerId, null), + ).also { d -> withTimeout(txTimeout) { d.await() } } @@ -187,12 +189,12 @@ class TriggersTest : IrohaTest() { @Story("Endless time trigger decreases asset quantity continuously") @SdkTestId("endless_time_trigger") fun `endless time trigger`(): Unit = runBlocking { - val triggerId = TriggerId(name = Name("endless_time_trigger")) + val triggerId = TriggerId("endless_time_trigger".asName()) sendAndAwaitTimeTrigger( triggerId, Repeats.Indefinitely(), - Instructions.burnAsset(DEFAULT_ASSET_ID, 1), + Burn.asset(DEFAULT_ASSET_ID, BigDecimal(1)), ) sendAndWait10Txs() @@ -206,12 +208,12 @@ class TriggersTest : IrohaTest() { @Story("Time trigger executes a limited number of times") @SdkTestId("time_trigger_execution_repeats_few_times") fun `time trigger execution repeats few times`(): Unit = runBlocking { - val triggerId = TriggerId(name = Name("time_trigger")) + val triggerId = TriggerId("time_trigger".asName()) sendAndAwaitTimeTrigger( triggerId, Repeats.Exactly(5L), - Instructions.burnAsset(DEFAULT_ASSET_ID, 1), + Burn.asset(DEFAULT_ASSET_ID, BigDecimal(1)), ) sendAndWait10Txs() @@ -226,7 +228,7 @@ class TriggersTest : IrohaTest() { fun `wasm trigger to mint nft for every user and update trigger metadata`(): Unit = runBlocking { val triggerId = TriggerId(name = "wasm_trigger".asName()) - val currentTime = Date().time + 10000 + val currentTime = Date().time + 5000 val filter = EventFilterBox.Time( EventFilters.timeEventFilter(BigInteger.valueOf(currentTime), BigInteger.valueOf(1000L)), ) @@ -234,29 +236,28 @@ class TriggersTest : IrohaTest() { .getResource("create_nft_for_alice_smartcontract.wasm") .readBytes() - client.tx { - registerWasmTrigger( + client.submit( + Register.trigger( triggerId, wasm, Repeats.Indefinitely(), ALICE_ACCOUNT_ID, - Metadata(mapOf()), filter, - ) - } + ), + ) keepNetworkBusyAndCheckAssetDefinitionIds() - val testKey = "key02357123" + val testKey = "key02357123".asName() val testValue = "value986441123" - client.tx { setKeyValue(triggerId, testKey.asName(), testValue) } + client.submit(SetKeyValue.trigger(triggerId, testKey, testValue)) + .also { d -> + withTimeout(txTimeout) { d.await() } + } delay(15000) - QueryBuilder.findTriggerById(triggerId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .also { assertEquals(testValue, it.action.metadata.getStringValue(testKey)) } + client.submit(QueryBuilder.findTriggerById(triggerId))!! + .also { assertEquals(testValue, it.action.metadata.sortedMapOfName[testKey]!!.readValue()) } } @Test @@ -274,35 +275,35 @@ class TriggersTest : IrohaTest() { .getResource("create_nft_for_alice_smartcontract.wasm") .readBytes() - client.tx { - registerWasmTrigger( + client.submit( + Register.trigger( wasmTriggerId, wasm, Repeats.Indefinitely(), ALICE_ACCOUNT_ID, - Metadata(mapOf()), filter, - ) - } - val testKey = "key" + ), + ) + .also { d -> + withTimeout(txTimeout) { d.await() } + } + val testKey = "key".asName() val testValue = "value" - client.tx { - registerExecutableTrigger( + client.submit( + Register.trigger( setKeyValueTriggerId, - listOf(Instructions.setKeyValue(wasmTriggerId, testKey.asName(), testValue)), + listOf(SetKeyValue.trigger(wasmTriggerId, testKey, testValue)), Repeats.Exactly(1L), ALICE_ACCOUNT_ID, - ) - executeTrigger(setKeyValueTriggerId) - } + EventFilterBox.ExecuteTrigger(ExecuteTriggerEventFilter(setKeyValueTriggerId)), + ), + Execute.trigger(setKeyValueTriggerId, null), + ) keepNetworkBusyAndCheckAssetDefinitionIds() - QueryBuilder.findTriggerById(wasmTriggerId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .also { assertEquals(testValue, it.action.metadata.getStringValue(testKey)) } + client.submit(QueryBuilder.findTriggerById(wasmTriggerId))!! + .also { assertEquals(testValue, it.action.metadata.sortedMapOfName[testKey]!!.readValue()) } } @Test @@ -313,47 +314,36 @@ class TriggersTest : IrohaTest() { val triggerName = "executable_trigger" val triggerId = TriggerId(name = triggerName.asName()) - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - registerExecutableTrigger( + client.submit( + Register.trigger( triggerId, - listOf(Instructions.mintAsset(DEFAULT_ASSET_ID, 1)), + listOf(Mint.asset(DEFAULT_ASSET_ID, BigDecimal(1))), Repeats.Exactly(1L), ALICE_ACCOUNT_ID, - ) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } - } - - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - unregisterTrigger(triggerName) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } - } + EventFilterBox.ExecuteTrigger(ExecuteTriggerEventFilter(triggerId)), + ), + ) + .also { d -> + withTimeout(txTimeout) { d.await() } + } - assertThrows { - runBlocking { - QueryBuilder.findTriggerById(triggerId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } + client.submit(Unregister.trigger(triggerId)) + .also { d -> + withTimeout(txTimeout) { d.await() } } + + client.submit(QueryBuilder.findTriggerById(triggerId)).also { + assertNull(it) } } private suspend fun sendAndWait10Txs() { repeat(10) { i -> - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - setKeyValue(ALICE_ACCOUNT_ID, "key$i".asName(), "value$i") - buildSigned(ALICE_KEYPAIR) - }.also { d -> - delay(1000) - withTimeout(txTimeout) { d.await() } - } + client.submit(SetKeyValue.account(ALICE_ACCOUNT_ID, "key$i".asName(), "value$i")) + .also { d -> + delay(1000) + withTimeout(txTimeout) { d.await() } + } } } @@ -361,83 +351,74 @@ class TriggersTest : IrohaTest() { assetId: AssetId = DEFAULT_ASSET_ID, accountId: AccountId = ALICE_ACCOUNT_ID, keyPair: KeyPair = ALICE_KEYPAIR, - ): Long { - return QueryBuilder.findAssetById(assetId) - .account(accountId) - .buildSigned(keyPair) - .let { query -> client.sendQuery(query) } - .value.cast().numeric.asLong() - } + ): Long = client.submit(QueryBuilder.findAssetById(assetId))!! + .value.cast().numeric.asLong() - private suspend fun sendAndAwaitTimeTrigger( + private suspend fun sendAndAwaitTimeTrigger( triggerId: TriggerId, repeats: Repeats, - instruction: InstructionBox, + instruction: I, accountId: AccountId = ALICE_ACCOUNT_ID, ) { - client.sendTransaction { - this.accountId = accountId - registerTimeTrigger( + client.submit( + Register.trigger( triggerId, listOf(instruction), repeats, accountId, - EventFilters.timeEventFilter( - BigInteger.valueOf(Instant.now().toEpochMilli()), - BigInteger.valueOf(500L), + EventFilterBox.Time( + EventFilters.timeEventFilter( + BigInteger.valueOf(Instant.now().toEpochMilli()), + BigInteger.valueOf(500L), + ), ), - ) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } - } + ), + ) + .also { d -> + withTimeout(txTimeout) { d.await() } + } } private suspend fun createNewAsset(assetName: String, prevSize: Int) { val newAsset = AssetDefinitionId(DEFAULT_DOMAIN_ID, assetName.asName()) - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - registerAssetDefinition(newAsset, AssetType.numeric()) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } - } + client.submit(Register.assetDefinition(newAsset, AssetType.numeric())) + .also { d -> + withTimeout(txTimeout) { d.await() } + } // check new asset is created - val query = QueryBuilder.findAllAssetsDefinitions() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - val assetDefinitions = client.sendQuery(query) + val query = QueryBuilder.findAssetsDefinitions() + val assetDefinitions = client.submit(query) assertEquals(prevSize + 1, assetDefinitions.size) val asset = assetDefinitions.first { it.id.name.string == assetName } assertNotNull(asset) } - private suspend fun checkDefaultAssetQuantity(): Long { - return QueryBuilder.findAssetById(DEFAULT_ASSET_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .value.cast() - .numeric.asLong() - } + private suspend fun checkDefaultAssetQuantity(): Long = client.submit(QueryBuilder.findAssetById(DEFAULT_ASSET_ID))!! + .value.cast() + .numeric.asLong() private suspend fun keepNetworkBusyAndCheckAssetDefinitionIds() { // send some transactions to keep Iroha2 network busy repeat(5) { i -> - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - setKeyValue(ALICE_ACCOUNT_ID, "test$i".asName(), "test$i") - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(Duration.ofSeconds(60)) { d.await() } - } + client.submit(SetKeyValue.account(ALICE_ACCOUNT_ID, "test$i".asName(), "test$i")) + .also { d -> + withTimeout(Duration.ofSeconds(60)) { d.await() } + } delay(500) } - QueryBuilder.findAssetsByAccountId(ALICE_ACCOUNT_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } + val byAccountIdFilter = CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Account( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals( + ALICE_ACCOUNT_ID, + ), + ), + ), + ), + ) + client.submit(QueryBuilder.findAssets(byAccountIdFilter)) .also { assets -> val expectedDefinition = AssetDefinitionId( DEFAULT_DOMAIN_ID, @@ -448,7 +429,7 @@ class TriggersTest : IrohaTest() { assert(assets.any { it.id.definition == XOR_DEFINITION_ID }) assert( assets.any { - it.id.definition.asString().lowercase() == expectedDefinition.asString().lowercase() + expectedDefinition.asString().lowercase() == it.id.definition.asString().lowercase() }, ) } diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/testengine/Genesis.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/testengine/Genesis.kt index 97a077d06..2cd09e7b7 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/testengine/Genesis.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/testengine/Genesis.kt @@ -1,9 +1,7 @@ package jp.co.soramitsu.iroha2.testengine import jp.co.soramitsu.iroha2.Genesis -import jp.co.soramitsu.iroha2.Permissions import jp.co.soramitsu.iroha2.asDomainId -import jp.co.soramitsu.iroha2.asJsonString import jp.co.soramitsu.iroha2.asName import jp.co.soramitsu.iroha2.generateKeyPair import jp.co.soramitsu.iroha2.generatePublicKey @@ -11,21 +9,42 @@ import jp.co.soramitsu.iroha2.generated.AccountId import jp.co.soramitsu.iroha2.generated.AssetDefinitionId import jp.co.soramitsu.iroha2.generated.AssetId import jp.co.soramitsu.iroha2.generated.AssetType +import jp.co.soramitsu.iroha2.generated.BlockParameters +import jp.co.soramitsu.iroha2.generated.CanBurnAssetWithDefinition +import jp.co.soramitsu.iroha2.generated.CanManagePeers +import jp.co.soramitsu.iroha2.generated.CanManageRoles +import jp.co.soramitsu.iroha2.generated.CanMintAssetWithDefinition +import jp.co.soramitsu.iroha2.generated.CanModifyAccountMetadata +import jp.co.soramitsu.iroha2.generated.CanRegisterDomain +import jp.co.soramitsu.iroha2.generated.CanTransferAssetWithDefinition +import jp.co.soramitsu.iroha2.generated.CanUnregisterDomain +import jp.co.soramitsu.iroha2.generated.CanUpgradeExecutor import jp.co.soramitsu.iroha2.generated.ChainId import jp.co.soramitsu.iroha2.generated.DomainId -import jp.co.soramitsu.iroha2.generated.InstructionBox +import jp.co.soramitsu.iroha2.generated.EventFilterBox +import jp.co.soramitsu.iroha2.generated.ExecuteTriggerEventFilter +import jp.co.soramitsu.iroha2.generated.Json import jp.co.soramitsu.iroha2.generated.Metadata +import jp.co.soramitsu.iroha2.generated.Name import jp.co.soramitsu.iroha2.generated.NonZeroOfu64 -import jp.co.soramitsu.iroha2.generated.Parameter -import jp.co.soramitsu.iroha2.generated.Permission +import jp.co.soramitsu.iroha2.generated.Parameters import jp.co.soramitsu.iroha2.generated.RawGenesisTransaction import jp.co.soramitsu.iroha2.generated.Repeats import jp.co.soramitsu.iroha2.generated.RoleId -import jp.co.soramitsu.iroha2.generated.SmartContractParameter +import jp.co.soramitsu.iroha2.generated.SmartContractParameters +import jp.co.soramitsu.iroha2.generated.SumeragiParameters +import jp.co.soramitsu.iroha2.generated.TransactionParameters import jp.co.soramitsu.iroha2.generated.TriggerId import jp.co.soramitsu.iroha2.numeric import jp.co.soramitsu.iroha2.toIrohaPublicKey -import jp.co.soramitsu.iroha2.transaction.Instructions +import jp.co.soramitsu.iroha2.transaction.Burn +import jp.co.soramitsu.iroha2.transaction.Grant +import jp.co.soramitsu.iroha2.transaction.Instruction +import jp.co.soramitsu.iroha2.transaction.Mint +import jp.co.soramitsu.iroha2.transaction.Register +import jp.co.soramitsu.iroha2.transaction.SetKeyValue +import jp.co.soramitsu.iroha2.transaction.Transfer +import jp.co.soramitsu.iroha2.writeValue import org.apache.commons.lang3.RandomStringUtils.randomAlphabetic import org.testcontainers.shaded.org.apache.commons.lang3.RandomStringUtils import java.math.BigDecimal @@ -37,79 +56,98 @@ import kotlin.random.Random.Default.nextDouble */ open class DefaultGenesis(transaction: RawGenesisTransaction? = null) : Genesis(transaction ?: rawGenesisTx()) -open class AliceCanUpgradeExecutor : Genesis( - rawGenesisTx( - Instructions.grantPermissionToken( - Permissions.CanUpgradeExecutor, - destinationId = ALICE_ACCOUNT_ID, +open class BobCanManageRoles : + Genesis( + rawGenesisTx( + Grant.accountPermission( + CanManageRoles(), + BOB_ACCOUNT_ID, + ), ), - ), -) + ) + +open class BobHasPermissionToRegisterDomain : + Genesis( + rawGenesisTx( + Grant.accountPermission( + CanRegisterDomain(), + BOB_ACCOUNT_ID, + ), + ), + ) + +open class AliceHasPermissionToRegisterDomain : + Genesis( + rawGenesisTx( + Grant.accountPermission( + CanRegisterDomain(), + ALICE_ACCOUNT_ID, + ), + ), + ) -open class WithDomainTransferredToBob : Genesis( - rawGenesisTx( - Instructions.registerDomain(DOMAIN_ID), - Instructions.transferDomainOwnership(GENESIS_ACCOUNT, DOMAIN_ID, BOB_ACCOUNT_ID), - ), -) { +open class AliceCanUpgradeExecutor : + Genesis( + rawGenesisTx( + Grant.accountPermission( + CanUpgradeExecutor(), + ALICE_ACCOUNT_ID, + ), + ), + ) + +open class WithDomainTransferredToBob : + Genesis( + rawGenesisTx( + Register.domain(DOMAIN_ID), + Transfer.domain(GENESIS_ACCOUNT, DOMAIN_ID, BOB_ACCOUNT_ID), + ), + ) { companion object { val DOMAIN_ID = randomAlphabetic(10).asDomainId() } } -open class AliceCanUnregisterAnyPeer : Genesis( - rawGenesisTx( - Instructions.grantPermissionToken( - Permissions.CanUnregisterAnyPeer, - destinationId = ALICE_ACCOUNT_ID, - ), - ), -) - -open class AliceAndBobHasPermissionToMintPublicKeys : Genesis( - rawGenesisTx( - Instructions.grantPermissionToken( - Permissions.CanMintUserPublicKeys, - ALICE_ACCOUNT_ID.asJsonString(), - ALICE_ACCOUNT_ID, - ), - Instructions.grantPermissionToken( - Permissions.CanMintUserPublicKeys, - BOB_ACCOUNT_ID.asJsonString(), - BOB_ACCOUNT_ID, +open class AliceCanManagePeers : + Genesis( + rawGenesisTx( + Grant.accountPermission( + CanManagePeers(), + ALICE_ACCOUNT_ID, + ), ), - ), -) + ) -open class AliceHasPermissionToUnregisterDomain : Genesis( - rawGenesisTx( - Instructions.registerDomain(NEW_DOMAIN_ID), - Instructions.grantPermissionToken( - Permissions.CanUnregisterDomain, - NEW_DOMAIN_ID.asJsonString(), - ALICE_ACCOUNT_ID, +open class AliceHasPermissionToUnregisterDomain : + Genesis( + rawGenesisTx( + Register.domain(NEW_DOMAIN_ID), + Grant.accountPermission( + CanUnregisterDomain(NEW_DOMAIN_ID), + ALICE_ACCOUNT_ID, + ), ), - ), -) { + ) { companion object { val NEW_DOMAIN_ID = DomainId("NEW_DOMAIN".asName()) } } -open class WithManyDomains : Genesis( - rawGenesisTx( - *registerDomains(DOMAINS_COUNT), - ), -) { +open class WithManyDomains : + Genesis( + rawGenesisTx( + *registerDomains(DOMAINS_COUNT), + ), + ) { companion object { const val DOMAINS_COUNT = 25 } } -fun registerDomains(count: Int): Array { - val instructions = mutableListOf() +fun registerDomains(count: Int): Array { + val instructions = mutableListOf() for (i in 1..count) { - instructions.add(Instructions.registerDomain(DomainId("NEW_DOMAIN$i".asName()))) + instructions.add(Register.domain(DomainId("NEW_DOMAIN$i".asName()))) } return instructions.toTypedArray() } @@ -117,22 +155,16 @@ fun registerDomains(count: Int): Array { /** * Give Alice access to Bob's metadata */ -open class AliceHasRoleWithAccessToBobsMetadata : Genesis( - rawGenesisTx( - Instructions.registerRole( - ROLE_ID, - Permission( - Permissions.CanSetKeyValueInAccount.type, - BOB_ACCOUNT_ID.asJsonString(true), - ), - Permission( - Permissions.CanRemoveKeyValueInAccount.type, - BOB_ACCOUNT_ID.asJsonString(true), +open class AliceHasRoleWithAccessToBobsMetadata : + Genesis( + rawGenesisTx( + Register.role( + ALICE_ACCOUNT_ID, + ROLE_ID, + CanModifyAccountMetadata(BOB_ACCOUNT_ID), ), ), - Instructions.grantRole(ROLE_ID, ALICE_ACCOUNT_ID), - ), -) { + ) { companion object { val ROLE_ID = RoleId("USER_METADATA_ACCESS".asName()) } @@ -141,40 +173,55 @@ open class AliceHasRoleWithAccessToBobsMetadata : Genesis( /** * Give Alice 100 XOR and the permission to burn them */ -open class AliceHas100XorAndPermissionToMintAndBurn : Genesis( - rawGenesisTx( - Instructions.registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()), - Instructions.mintAsset(DEFAULT_ASSET_ID, 100), - Instructions.grantPermissionToken( - Permissions.CanMintAssetWithDefinition, - DEFAULT_ASSET_DEFINITION_ID.asJsonString(), - ALICE_ACCOUNT_ID, - ), - Instructions.grantPermissionToken( - Permissions.CanBurnAssetWithDefinition, - DEFAULT_ASSET_DEFINITION_ID.asJsonString(), - ALICE_ACCOUNT_ID, - ), - params = listOf( - Parameter.SmartContract( - SmartContractParameter.Fuel(NonZeroOfu64(BigInteger.valueOf(5500000000))), +open class AliceHas100XorAndPermissionToMintAndBurn : + Genesis( + rawGenesisTx( + Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()), + Mint.asset(DEFAULT_ASSET_ID, BigDecimal(100)), + Grant.accountPermission( + CanMintAssetWithDefinition(DEFAULT_ASSET_DEFINITION_ID), + ALICE_ACCOUNT_ID, + ), + Grant.accountPermission( + CanBurnAssetWithDefinition(DEFAULT_ASSET_DEFINITION_ID), + ALICE_ACCOUNT_ID, ), - Parameter.Executor( - SmartContractParameter.Fuel(NonZeroOfu64(BigInteger.valueOf(5500000000))), + params = Parameters( + sumeragi = SumeragiParameters( + blockTimeMs = BigInteger.valueOf(2000), + commitTimeMs = BigInteger.valueOf(4000), + maxClockDriftMs = BigInteger.valueOf(1000), + ), + block = BlockParameters( + maxTransactions = NonZeroOfu64(BigInteger.valueOf(4096)), + ), + smartContract = SmartContractParameters( + fuel = NonZeroOfu64(BigInteger.valueOf(5500000000)), + memory = NonZeroOfu64(BigInteger.valueOf(55000000)), + ), + executor = SmartContractParameters( + fuel = NonZeroOfu64(BigInteger.valueOf(5500000000)), + memory = NonZeroOfu64(BigInteger.valueOf(55000000)), + ), + transaction = TransactionParameters( + maxInstructions = NonZeroOfu64(BigInteger.valueOf(4096)), + smartContractSize = NonZeroOfu64(BigInteger.valueOf(4194304)), + ), + custom = emptyMap(), ), ), - ), -) + ) /** * Give Alice test assets */ -open class AliceWithTestAssets : Genesis( - rawGenesisTx( - Instructions.registerAssetDefinition(TEST_ASSET_DEFINITION_ID, AssetType.Store()), - Instructions.registerAssetDefinition(TEST_ASSET_DEFINITION_ID2, AssetType.Store()), - ), -) { +open class AliceWithTestAssets : + Genesis( + rawGenesisTx( + Register.assetDefinition(TEST_ASSET_DEFINITION_ID, AssetType.Store()), + Register.assetDefinition(TEST_ASSET_DEFINITION_ID2, AssetType.Store()), + ), + ) { companion object { val TEST_ASSET_DEFINITION_ID = AssetDefinitionId(DEFAULT_DOMAIN_ID, "test".asName()) val TEST_ASSET_DEFINITION_ID2 = AssetDefinitionId(DEFAULT_DOMAIN_ID, "test2".asName()) @@ -184,17 +231,18 @@ open class AliceWithTestAssets : Genesis( /** * Register an executable trigger without instructions */ -open class WithExecutableTrigger : Genesis( - rawGenesisTx( - Instructions.registerTrigger( - TRIGGER_ID, - listOf(), - Repeats.Exactly(1L), - ALICE_ACCOUNT_ID, - Metadata(mapOf()), +open class WithExecutableTrigger : + Genesis( + rawGenesisTx( + Register.trigger( + TRIGGER_ID, + listOf(), + Repeats.Exactly(1L), + ALICE_ACCOUNT_ID, + EventFilterBox.ExecuteTrigger(ExecuteTriggerEventFilter(TRIGGER_ID)), + ), ), - ), -) { + ) { companion object { val TRIGGER_ID = TriggerId("some_trigger".asName()) } @@ -203,23 +251,22 @@ open class WithExecutableTrigger : Genesis( /** * Mint 100 XOR for Alice and Bob */ -open class AliceAndBobEachHave100Xor : Genesis( - rawGenesisTx( - Instructions.registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()), - Instructions.grantPermissionToken( - Permissions.CanTransferAssetWithDefinition, - DEFAULT_ASSET_DEFINITION_ID.asJsonString(), - ALICE_ACCOUNT_ID, - ), - Instructions.grantPermissionToken( - Permissions.CanTransferAssetWithDefinition, - DEFAULT_ASSET_DEFINITION_ID.asJsonString(), - BOB_ACCOUNT_ID, +open class AliceAndBobEachHave100Xor : + Genesis( + rawGenesisTx( + Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()), + Grant.accountPermission( + CanTransferAssetWithDefinition(DEFAULT_ASSET_DEFINITION_ID), + ALICE_ACCOUNT_ID, + ), + Grant.accountPermission( + CanTransferAssetWithDefinition(DEFAULT_ASSET_DEFINITION_ID), + BOB_ACCOUNT_ID, + ), + Mint.asset(DEFAULT_ASSET_ID, BigDecimal(100)), + Mint.asset(BOB_ASSET_ID, BigDecimal(100)), ), - Instructions.mintAsset(DEFAULT_ASSET_ID, 100), - Instructions.mintAsset(BOB_ASSET_ID, 100), - ), -) { + ) { companion object { val BOB_ASSET_ID = AssetId(BOB_ACCOUNT_ID, DEFAULT_ASSET_DEFINITION_ID) } @@ -228,16 +275,17 @@ open class AliceAndBobEachHave100Xor : Genesis( /** * Create a Store asset with metadata */ -open class StoreAssetWithMetadata : Genesis( - rawGenesisTx( - Instructions.registerAssetDefinition( - DEFINITION_ID, - AssetType.Store(), - Metadata(mapOf(ASSET_KEY to ASSET_VALUE)), +open class StoreAssetWithMetadata : + Genesis( + rawGenesisTx( + Register.assetDefinition( + DEFINITION_ID, + AssetType.Store(), + metadata = Metadata(mapOf(ASSET_KEY to Json.writeValue(ASSET_VALUE))), + ), + SetKeyValue.asset(ASSET_ID, ASSET_KEY, ASSET_VALUE), ), - Instructions.setKeyValue(ASSET_ID, ASSET_KEY, ASSET_VALUE), - ), -) { + ) { companion object { val ASSET_KEY = "key".asName() val ASSET_VALUE: String = RandomStringUtils.randomAlphabetic(50) @@ -246,45 +294,47 @@ open class StoreAssetWithMetadata : Genesis( } } -open class AliceCanMintXor : Genesis( - rawGenesisTx( - Instructions.grantPermissionToken( - Permissions.CanMintAssetWithDefinition, - XOR_DEFINITION_ID.asJsonString(), - ALICE_ACCOUNT_ID, +open class AliceCanMintXor : + Genesis( + rawGenesisTx( + Grant.accountPermission( + CanMintAssetWithDefinition(XOR_DEFINITION_ID), + ALICE_ACCOUNT_ID, + ), ), - ), -) + ) /** * Create XOR and VAL assets with one token for each and metadata */ -open class XorAndValAssets : Genesis( - rawGenesisTx( - Instructions.registerAssetDefinition(XOR_DEFINITION_ID, AssetType.numeric()), - Instructions.mintAsset(AssetId(ALICE_ACCOUNT_ID, XOR_DEFINITION_ID), XOR_QUANTITY), +open class XorAndValAssets : + Genesis( + rawGenesisTx( + Register.assetDefinition(XOR_DEFINITION_ID, AssetType.numeric()), + Mint.asset(AssetId(ALICE_ACCOUNT_ID, XOR_DEFINITION_ID), XOR_QUANTITY), - Instructions.registerAssetDefinition(VAL_DEFINITION_ID, AssetType.numeric()), - Instructions.mintAsset(AssetId(ALICE_ACCOUNT_ID, VAL_DEFINITION_ID), VAL_QUANTITY), - ), -) { + Register.assetDefinition(VAL_DEFINITION_ID, AssetType.numeric()), + Mint.asset(AssetId(ALICE_ACCOUNT_ID, VAL_DEFINITION_ID), VAL_QUANTITY), + ), + ) { companion object { - const val XOR_QUANTITY = 1 - const val VAL_QUANTITY = 1 + val XOR_QUANTITY = BigDecimal(1) + val VAL_QUANTITY = BigDecimal(1) } } /** * Create a new account with metadata */ -open class NewAccountWithMetadata : Genesis( - rawGenesisTx( - Instructions.registerAccount( - id = ACCOUNT_ID, - metadata = Metadata(mapOf(KEY to VALUE)), +open class NewAccountWithMetadata : + Genesis( + rawGenesisTx( + Register.account( + ACCOUNT_ID, + Metadata(mapOf(KEY to Json.writeValue(VALUE))), + ), ), - ), -) { + ) { companion object { const val VALUE = "value" @@ -297,30 +347,27 @@ open class NewAccountWithMetadata : Genesis( /** * Create a new domain with metadata */ -open class NewDomainWithMetadata : Genesis( - rawGenesisTx( - Instructions.registerDomain( - domainId = DOMAIN_ID, - metadata = mapOf(KEY to VALUE), +open class NewDomainWithMetadata : + Genesis( + rawGenesisTx( + Register.domain( + DOMAIN_ID, + mapOf(KEY to Json.writeValue(VALUE)), + ), + Transfer.domain(GENESIS_ACCOUNT, DOMAIN_ID, ALICE_ACCOUNT_ID), ), - Instructions.transferDomainOwnership(GENESIS_ACCOUNT, DOMAIN_ID, ALICE_ACCOUNT_ID), - ), -) { + ) { companion object { - val KEY = "key".asName() - val VALUE = "value" - val DOMAIN_ID = DomainId("foo_domain".asName()) + val KEY: Name = "key".asName() + val VALUE: String = "value" + val DOMAIN_ID: DomainId = DomainId("foo_domain".asName()) } } /** * Create a new domain */ -open class NewDomain : Genesis( - rawGenesisTx( - Instructions.registerDomain(DOMAIN_ID), - ), -) { +open class NewDomain : Genesis(rawGenesisTx(Register.domain(DOMAIN_ID))) { companion object { val DOMAIN_ID = "foo_domain".asDomainId() } @@ -329,22 +376,23 @@ open class NewDomain : Genesis( /** * Specific genesis to test multiple genesis case */ -open class RubbishToTestMultipleGenesis : Genesis( - rawGenesisTx( - Instructions.registerDomain( - DEFAULT_DOMAIN_ID, - mapOf(DOMAIN_KEY_VALUE.asName() to DOMAIN_KEY_VALUE), - ), - Instructions.registerAccount( - ALICE_ACCOUNT_ID, - Metadata(mapOf(ALICE_KEY_VALUE.asName() to ALICE_KEY_VALUE)), - ), - Instructions.registerAccount( - BOB_ACCOUNT_ID, - Metadata(mapOf(BOB_KEY_VALUE.asName() to BOB_KEY_VALUE)), +open class RubbishToTestMultipleGenesis : + Genesis( + rawGenesisTx( + Register.domain( + DEFAULT_DOMAIN_ID, + mapOf(DOMAIN_KEY_VALUE.asName() to Json.writeValue(DOMAIN_KEY_VALUE)), + ), + Register.account( + ALICE_ACCOUNT_ID, + Metadata(mapOf(ALICE_KEY_VALUE.asName() to Json.writeValue(ALICE_KEY_VALUE))), + ), + Register.account( + BOB_ACCOUNT_ID, + Metadata(mapOf(BOB_KEY_VALUE.asName() to Json.writeValue(BOB_KEY_VALUE))), + ), ), - ), -) { + ) { companion object { val DOMAIN_KEY_VALUE: String = RandomStringUtils.randomAlphabetic(10) val ALICE_KEY_VALUE: String = RandomStringUtils.randomAlphabetic(10) @@ -355,67 +403,60 @@ open class RubbishToTestMultipleGenesis : Genesis( /** * To test serializers */ -open class FatGenesis : Genesis( - rawGenesisTx( - Instructions.registerDomain( - randomAlphabetic(10).asDomainId(), - mapOf(randomAlphabetic(10).asName() to randomAlphabetic(10)), - ), - Instructions.registerAccount( - AccountId(domain = DEFAULT_DOMAIN_ID, signatory = generatePublicKey()), - Metadata(mapOf(randomAlphabetic(10).asName() to randomAlphabetic(10))), - ), - Instructions.registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()), - Instructions.grantPermissionToken( - Permissions.CanTransferAssetWithDefinition, - DEFAULT_ASSET_DEFINITION_ID.asJsonString(), - ALICE_ACCOUNT_ID, - ), - Instructions.grantPermissionToken( - Permissions.CanTransferAssetWithDefinition, - DEFAULT_ASSET_DEFINITION_ID.asJsonString(), - BOB_ACCOUNT_ID, - ), - Instructions.registerAssetDefinition( - DEFINITION_ID, - AssetType.Store(), - Metadata(mapOf(randomAlphabetic(10).asName() to randomAlphabetic(10))), - ), - Instructions.registerRole( - ROLE_ID, - Permission( - Permissions.CanSetKeyValueInAccount.type, - BOB_ACCOUNT_ID.asJsonString(true), +open class FatGenesis : + Genesis( + rawGenesisTx( + Register.domain( + randomAlphabetic(10).asDomainId(), + mapOf(randomAlphabetic(10).asName() to Json.writeValue(randomAlphabetic(10))), ), - Permission( - Permissions.CanRemoveKeyValueInAccount.type, - BOB_ACCOUNT_ID.asJsonString(true), + Register.account( + AccountId(DEFAULT_DOMAIN_ID, generatePublicKey()), + Metadata(mapOf(randomAlphabetic(10).asName() to Json.writeValue(randomAlphabetic(10)))), + ), + Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric()), + Grant.accountPermission( + CanTransferAssetWithDefinition(DEFAULT_ASSET_DEFINITION_ID), + ALICE_ACCOUNT_ID, + ), + Grant.accountPermission( + CanTransferAssetWithDefinition(DEFAULT_ASSET_DEFINITION_ID), + BOB_ACCOUNT_ID, + ), + Register.assetDefinition( + DEFINITION_ID, + AssetType.Store(), + metadata = Metadata(mapOf(randomAlphabetic(10).asName() to Json.writeValue(randomAlphabetic(10)))), + ), + Register.role( + BOB_ACCOUNT_ID, + ROLE_ID, + CanModifyAccountMetadata(BOB_ACCOUNT_ID), + ), + Grant.accountRole(ROLE_ID, ALICE_ACCOUNT_ID), + Mint.asset(AssetId(BOB_ACCOUNT_ID, DEFAULT_ASSET_DEFINITION_ID), BigDecimal(100)), + Burn.asset(AssetId(BOB_ACCOUNT_ID, DEFAULT_ASSET_DEFINITION_ID), BigDecimal(100)), + SetKeyValue.asset(ASSET_ID, randomAlphabetic(10).asName(), Int.MAX_VALUE.toString()), + SetKeyValue.asset(ASSET_ID, randomAlphabetic(10).asName(), (Int.MAX_VALUE * 10L).toString()), + SetKeyValue.asset(ASSET_ID, randomAlphabetic(10).asName(), nextDouble().toString()), + SetKeyValue.asset( + ASSET_ID, + randomAlphabetic(10).asName(), + BigDecimal(nextDouble()).toString(), + ), + SetKeyValue.asset( + ASSET_ID, + randomAlphabetic(10).asName(), + (BigInteger.valueOf(Long.MAX_VALUE) * BigInteger.valueOf(2)).toString(), + ), + SetKeyValue.asset(ASSET_ID, randomAlphabetic(10).asName(), randomAlphabetic(10)), + SetKeyValue.domain( + DEFAULT_DOMAIN_ID, + randomAlphabetic(10).asName(), + randomAlphabetic(10), ), ), - Instructions.grantRole(ROLE_ID, ALICE_ACCOUNT_ID), - Instructions.mintAsset(AssetId(BOB_ACCOUNT_ID, DEFAULT_ASSET_DEFINITION_ID), 100), - Instructions.burnAsset(AssetId(BOB_ACCOUNT_ID, DEFAULT_ASSET_DEFINITION_ID), 100), - Instructions.setKeyValue(ASSET_ID, randomAlphabetic(10).asName(), Int.MAX_VALUE.toString()), - Instructions.setKeyValue(ASSET_ID, randomAlphabetic(10).asName(), (Int.MAX_VALUE * 10L).toString()), - Instructions.setKeyValue(ASSET_ID, randomAlphabetic(10).asName(), nextDouble().toString()), - Instructions.setKeyValue( - ASSET_ID, - randomAlphabetic(10).asName(), - BigDecimal(nextDouble()).toString(), - ), - Instructions.setKeyValue( - ASSET_ID, - randomAlphabetic(10).asName(), - (BigInteger.valueOf(Long.MAX_VALUE) * BigInteger.valueOf(2)).toString(), - ), - Instructions.setKeyValue(ASSET_ID, randomAlphabetic(10).asName(), randomAlphabetic(10)), - Instructions.setKeyValue( - DEFAULT_DOMAIN_ID, - randomAlphabetic(10).asName(), - randomAlphabetic(10), - ), - ), -) { + ) { companion object { val DEFINITION_ID = AssetDefinitionId(DEFAULT_DOMAIN_ID, "foo".asName()) val ASSET_ID = AssetId(BOB_ACCOUNT_ID, DEFINITION_ID) @@ -423,36 +464,25 @@ open class FatGenesis : Genesis( } } -/** - * Grant permission token to unregister any role - */ -open class BobCanUnregisterAnyRole : Genesis( - rawGenesisTx( - Instructions.grantPermissionToken( - permission = Permissions.CanUnregisterAnyRole, - destinationId = BOB_ACCOUNT_ID, - ), - transferTo = BOB_ACCOUNT_ID, - ), -) - /** * Return [RawGenesisTransaction] with instructions to init genesis */ fun rawGenesisTx( - vararg isi: InstructionBox, - params: List = emptyList(), + vararg isi: Instruction, + params: Parameters? = null, transferTo: AccountId = ALICE_ACCOUNT_ID, ) = RawGenesisTransaction( - chain = ChainId("00000000-0000-0000-0000-000000000000"), - executor = Genesis.EXECUTOR_FILE_NAME, - parameters = params, - instructions = listOf( - Instructions.registerDomain(DEFAULT_DOMAIN_ID), - Instructions.registerAccount(ALICE_ACCOUNT_ID, Metadata(emptyMap())), - Instructions.registerAccount(BOB_ACCOUNT_ID, Metadata(emptyMap())), - Instructions.transferDomainOwnership(GENESIS_ACCOUNT, DEFAULT_DOMAIN_ID, transferTo), + ChainId("00000000-0000-0000-0000-000000000000"), + Genesis.EXECUTOR_FILE_NAME, + params ?: DEFAULT_GENESIS_PARAMETERS, + listOf( + Register.domain(DEFAULT_DOMAIN_ID), + Register.account(ALICE_ACCOUNT_ID, Metadata(emptyMap())), + Register.account(BOB_ACCOUNT_ID, Metadata(emptyMap())), + Transfer.domain(GENESIS_ACCOUNT, DEFAULT_DOMAIN_ID, transferTo), *isi, - ), - topology = emptyList(), + ).map { it.asInstructionBox() }, + "libs", + emptyList(), + emptyList(), ) diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/util/CryptoTest.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/util/CryptoTest.kt index 4f106ac29..de6581102 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/util/CryptoTest.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/util/CryptoTest.kt @@ -5,7 +5,7 @@ import jp.co.soramitsu.iroha2.fromHex import jp.co.soramitsu.iroha2.generateKeyPair import jp.co.soramitsu.iroha2.hash import jp.co.soramitsu.iroha2.keyPairFromHex -import jp.co.soramitsu.iroha2.sign +import jp.co.soramitsu.iroha2.signAs import jp.co.soramitsu.iroha2.toHex import jp.co.soramitsu.iroha2.verify import kotlinx.coroutines.CoroutineScope @@ -32,8 +32,7 @@ class CryptoTest { override fun equals(other: Any?): Boolean { if (this === other) return true if (other !is ByteArrayWrapper) return false - if (!byteArray.contentEquals(other.byteArray)) return false - return true + return byteArray.contentEquals(other.byteArray) } override fun hashCode() = byteArray.contentHashCode() @@ -53,7 +52,7 @@ class CryptoTest { fun `signature created and verified`() { val keyPair = generateKeyPair() val message = "Test message to sign.".toByteArray() - val signature = keyPair.private.sign(message) + val signature = keyPair.private.signAs(message) assertTrue { keyPair.public.verify(signature, message) } } @@ -72,7 +71,7 @@ class CryptoTest { val privKey = keyPair.private.bytes().toHex() val message = "foo".toByteArray() - val signature = keyPair.private.sign(message) + val signature = keyPair.private.signAs(message) val restoredKeyPair = keyPairFromHex(pubKey, privKey) assertEquals(keyPair.private, restoredKeyPair.private) diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/util/FixnumTest.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/util/FixnumTest.kt index 57fc9b91a..7aa353055 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/util/FixnumTest.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/util/FixnumTest.kt @@ -52,7 +52,11 @@ class FixnumTest { test(1, 3) { BigDecimal.ONE.setScale(15) } } - private fun test(probes: Int = 20_000, scale: Int = DEFAULT_SCALE, generator: () -> BigDecimal) { + private fun test( + probes: Int = 20_000, + scale: Int = DEFAULT_SCALE, + generator: () -> BigDecimal, + ) { generateSequence { generator() } .take(probes) .forEachIndexed { iteration, expected -> 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 272357a69..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 a723e6eb4..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 @@ -1,6 +1,6 @@ [package] name = "create_nft_for_alice_smartcontract" -version = "2.0.0-pre-rc.22.2" +version = "2.0.0-rc.1.0" # TODO: teams are being deprecated update the authors URL authors = ["Iroha 2 team "] edition = "2021" @@ -14,17 +14,21 @@ crate-type = ['cdylib'] # Empty workspace to fix "current package believes it's in a workspace when it's not" [workspace] +[profile.dev] +panic = "abort" + [profile.release] +panic = "abort" + +[profile.deploy] +inherits = "release" strip = "debuginfo" # Remove debugging info from the binary -panic = "abort" # Panics are transcribed to Traps when compiling for wasm anyways lto = true # Link-time-optimization produces notable decrease in binary size opt-level = "z" # Optimize for size vs speed with "s"/"z"(removes vectorization) codegen-units = 1 # Further reduces binary size but increases compilation time [dependencies] -iroha_trigger = { git = "https://github.com/hyperledger/iroha/", tag = "v2.0.0-pre-rc.22.2", features = ["debug"] } - -getrandom = { version = "0.2", features = ["custom"] } +iroha_trigger = { git = "https://github.com/hyperledger/iroha/", tag = "v2.0.0-rc.1.0", features = ["debug"] } -lol_alloc = "0.4.0" +dlmalloc = { version = "0.2.6", features = ["global"] } panic-halt = "0.2.0" diff --git a/modules/client/src/test/resources/create_nft_for_alice_smartcontract/build.sh b/modules/client/src/test/resources/create_nft_for_alice_smartcontract/build.sh index b80cf0267..1778189ce 100755 --- a/modules/client/src/test/resources/create_nft_for_alice_smartcontract/build.sh +++ b/modules/client/src/test/resources/create_nft_for_alice_smartcontract/build.sh @@ -1,4 +1,4 @@ #!/bin/bash -cargo +nightly-2024-04-18 build --release -Zbuild-std -Zbuild-std-features=panic_immediate_abort -cp ./target/wasm32-unknown-unknown/release/create_nft_for_alice_smartcontract.wasm ../create_nft_for_alice_smartcontract.wasm +cargo +nightly-2024-09-09 build --profile=deploy -Zbuild-std -Zbuild-std-features=panic_immediate_abort +cp ./target/wasm32-unknown-unknown/deploy/create_nft_for_alice_smartcontract.wasm ../create_nft_for_alice_smartcontract.wasm diff --git a/modules/client/src/test/resources/create_nft_for_alice_smartcontract/src/lib.rs b/modules/client/src/test/resources/create_nft_for_alice_smartcontract/src/lib.rs index f4389fbc5..668966355 100644 --- a/modules/client/src/test/resources/create_nft_for_alice_smartcontract/src/lib.rs +++ b/modules/client/src/test/resources/create_nft_for_alice_smartcontract/src/lib.rs @@ -9,16 +9,19 @@ extern crate alloc; extern crate panic_halt; use alloc::{format, string::ToString}; -use lol_alloc::{FreeListAllocator, LockedAllocator}; +use dlmalloc::GlobalDlmalloc; #[global_allocator] -static ALLOC: LockedAllocator = LockedAllocator::new(FreeListAllocator::new()); +static ALLOC: GlobalDlmalloc = GlobalDlmalloc; -use iroha_trigger::{prelude::*}; +use iroha_trigger::prelude::*; #[iroha_trigger::main] -fn main(_id: TriggerId, _owner: AccountId, _event: EventBox) { - let account_id: AccountId = "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland".parse().unwrap(); +fn main(host: Iroha, _context: Context) { + let account_id: AccountId = + "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland" + .parse() + .unwrap(); let mut metadata = Metadata::default(); let name = format!( "nft_for_{}_in_{}", @@ -29,25 +32,25 @@ fn main(_id: TriggerId, _owner: AccountId, _event: EventBox) { .dbg_unwrap(); metadata.insert(name, true); - let nft_id = generate_new_nft_id(&account_id); + let nft_id = generate_new_nft_id(&host, &account_id); let nft_definition = AssetDefinition::store(nft_id.clone()) .mintable_once() .with_metadata(metadata); - Register::asset_definition(nft_definition) - .execute() + host.submit(&Register::asset_definition(nft_definition)) .dbg_unwrap(); - SetKeyValue::asset( + host.submit(&SetKeyValue::asset( AssetId::new(nft_id, account_id), "has_this_nft".parse::().dbg_unwrap(), true, - ) - .execute() + )) .dbg_unwrap(); } -fn generate_new_nft_id(account_id: &AccountId) -> AssetDefinitionId { - let assets = FindAssetsByAccountId::new(account_id.clone()) +fn generate_new_nft_id(host: &Iroha, account_id: &AccountId) -> AssetDefinitionId { + let assets = host + .query(FindAssets) + .filter_with(|asset| asset.id.account.eq(account_id.clone())) .execute() .dbg_unwrap(); diff --git a/modules/client/src/test/resources/executor.wasm b/modules/client/src/test/resources/executor.wasm index f51b51123..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 bbaa34bf1..57d45af29 100644 --- a/modules/client/src/test/resources/executor/Cargo.toml +++ b/modules/client/src/test/resources/executor/Cargo.toml @@ -1,27 +1,28 @@ [package] name = "iroha_java_executor" edition = "2021" -version = "2.0.0-pre-rc.19" +version = "2.0.0-rc.1.0" # TODO: teams are being deprecated update the authors URL authors = ["Iroha 2 team "] +[lib] +crate-type = ['cdylib'] + [profile.dev] panic = "abort" [profile.release] +panic = "abort" + +[profile.deploy] +inherits = "release" strip = "debuginfo" # Remove debugging info from the binary -panic = "abort" # Panics are transcribed to Traps when compiling for wasm anyways lto = true # Link-time-optimization produces notable decrease in binary size opt-level = "z" # Optimize for size vs speed with "s"/"z"(removes vectorization) codegen-units = 1 # Further reduces binary size but increases compilation time -[lib] -crate-type = ['cdylib'] - [dependencies] -iroha_executor = { git = "https://github.com/hyperledger/iroha/", tag = "v2.0.0-pre-rc.22.1", features = ["debug"] } +iroha_executor = { git = "https://github.com/hyperledger/iroha/", tag = "v2.0.0-rc.1.0", features = ["debug"] } -getrandom = { version = "0.2", features = ["custom"] } dlmalloc = { version = "0.2.6", features = ["global"] } panic-halt = "0.2.0" - diff --git a/modules/client/src/test/resources/executor/build.sh b/modules/client/src/test/resources/executor/build.sh index 0e095603f..68d32ec4e 100755 --- a/modules/client/src/test/resources/executor/build.sh +++ b/modules/client/src/test/resources/executor/build.sh @@ -1,4 +1,4 @@ #!/bin/bash -cargo +nightly-2024-04-18 build --release -Zbuild-std -Zbuild-std-features=panic_immediate_abort -cp ./target/wasm32-unknown-unknown/release/iroha_java_executor.wasm ../executor.wasm +cargo +nightly-2024-09-09 build --profile=deploy -Zbuild-std -Zbuild-std-features=panic_immediate_abort +cp ./target/wasm32-unknown-unknown/deploy/iroha_java_executor.wasm ../executor.wasm diff --git a/modules/client/src/test/resources/executor/src/lib.rs b/modules/client/src/test/resources/executor/src/lib.rs index 9fc907296..aa91df295 100644 --- a/modules/client/src/test/resources/executor/src/lib.rs +++ b/modules/client/src/test/resources/executor/src/lib.rs @@ -2,33 +2,31 @@ #![no_std] -extern crate alloc; #[cfg(not(test))] extern crate panic_halt; use dlmalloc::GlobalDlmalloc; -use iroha_executor::{debug::dbg_panic, prelude::*, DataModelBuilder}; +use iroha_executor::{prelude::*, data_model::block::BlockHeader}; #[global_allocator] static ALLOC: GlobalDlmalloc = GlobalDlmalloc; -getrandom::register_custom_getrandom!(iroha_executor::stub_getrandom); - -/// Executor that replaces some of [`Validate`]'s methods with sensible defaults +/// Executor that replaces some of [`Execute`]'s methods with sensible defaults /// /// # Warning /// /// The defaults are not guaranteed to be stable. -#[derive(Debug, Clone, Constructor, Visit, Validate, ValidateEntrypoints)] -pub struct Executor { +#[derive(Debug, Clone, Visit, Execute, Entrypoints)] +struct Executor { + host: Iroha, + context: Context, verdict: Result, - block_height: u64, } impl Executor { - fn ensure_genesis(block_height: u64) { - if block_height != 0 { - dbg_panic( + fn ensure_genesis(curr_block: BlockHeader) { + if !curr_block.is_genesis() { + dbg_panic!( "Default Executor is intended to be used only in genesis. \ Write your own executor if you need to upgrade executor on existing chain.", ); @@ -45,8 +43,8 @@ impl Executor { /// /// If `migrate()` entrypoint fails then the whole `Upgrade` instruction /// will be denied and previous executor will stay unchanged. -#[entrypoint] -fn migrate(block_height: u64) { - Executor::ensure_genesis(block_height); - DataModelBuilder::with_default_permissions().build_and_set(); +#[iroha_executor::migrate] +fn migrate(host: Iroha, context: Context) { + Executor::ensure_genesis(context.curr_block); + DataModelBuilder::with_default_permissions().build_and_set(&host); } diff --git a/modules/client/src/test/resources/genesis.json b/modules/client/src/test/resources/genesis.json index 955c808b0..58b096f64 100644 --- a/modules/client/src/test/resources/genesis.json +++ b/modules/client/src/test/resources/genesis.json @@ -1,7 +1,29 @@ { "chain": "00000000-0000-0000-0000-000000000000", - "executor": "./executor.wasm", - "parameters": [], + "executor": "executor.wasm", + "parameters": { + "sumeragi": { + "block_time_ms": 2000, + "commit_time_ms": 4000, + "max_clock_drift_ms": 1000 + }, + "block": { + "max_transactions": 512 + }, + "transaction": { + "max_instructions": 4096, + "smart_contract_size": 4194304 + }, + "executor": { + "fuel": 55000000, + "memory": 55000000 + }, + "smart_contract": { + "fuel": 55000000, + "memory": 55000000 + }, + "custom": {} + }, "instructions": [ { "Register": { @@ -31,7 +53,7 @@ "Grant": { "Permission": { "object": { - "name": "CanSetKeyValueInAccount", + "name": "CanModifyAccountMetadata", "payload": { "account": "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland" } @@ -41,5 +63,7 @@ } } ], + "wasm_dir": "libs", + "wasm_triggers": [], "topology": [] } diff --git a/modules/codegen/build.gradle b/modules/codegen/build.gradle index c71fb0a72..b4856e3cd 100644 --- a/modules/codegen/build.gradle +++ b/modules/codegen/build.gradle @@ -1,13 +1,8 @@ dependencies { implementation project(":model") - implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVer" implementation "com.fasterxml.jackson.core:jackson-databind:$jacksonKotlinVer" - implementation "com.squareup:kotlinpoet:$kotlinPoetVer" - - testImplementation "org.jetbrains.kotlin:kotlin-test-junit5:$kotlinVer" - testImplementation "org.jetbrains.kotlin:kotlin-test:$kotlinVer" } task generate(type: JavaExec) { diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/EntryPoint.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/EntryPoint.kt index 6b85c0fdb..1b8a1f7f4 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/EntryPoint.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/EntryPoint.kt @@ -26,15 +26,12 @@ fun main(args: Array) { /** * Parse the [arguments][args] */ -fun parseArgs(args: Array): Map { - return args.map { it.split("=") } - .onEach { if (it.size != 2) throw RuntimeException("Incorrect format: expected format argumentKey=argumentValue") } - .associateBy({ it[0] }, { it[1] }) -} +fun parseArgs(args: Array): Map = args.map { it.split("=") } + .onEach { if (it.size != 2) throw RuntimeException("Incorrect format: expected format argumentKey=argumentValue") } + .associateBy({ it[0] }, { it[1] }) /** * Extract a specified [argumnt][argName] from all [arguments][args] */ -fun tryExtractArg(args: Map, argName: String): String { - return args[argName] ?: throw RuntimeException("Property '$argName' must be specified") -} +fun tryExtractArg(args: Map, argName: String): String = + args[argName] ?: throw RuntimeException("Property '$argName' must be specified") diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/KotlinTypeResolver.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/KotlinTypeResolver.kt index aa9baae83..1e7435d6a 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/KotlinTypeResolver.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/KotlinTypeResolver.kt @@ -8,7 +8,6 @@ import jp.co.soramitsu.iroha2.type.ArrayType import jp.co.soramitsu.iroha2.type.BooleanType import jp.co.soramitsu.iroha2.type.CompactType import jp.co.soramitsu.iroha2.type.CompositeType -import jp.co.soramitsu.iroha2.type.FixedPointType import jp.co.soramitsu.iroha2.type.I128Type import jp.co.soramitsu.iroha2.type.I16Type import jp.co.soramitsu.iroha2.type.I256Type @@ -17,7 +16,6 @@ import jp.co.soramitsu.iroha2.type.I64Type import jp.co.soramitsu.iroha2.type.I8Type import jp.co.soramitsu.iroha2.type.MapType import jp.co.soramitsu.iroha2.type.OptionType -import jp.co.soramitsu.iroha2.type.SetType import jp.co.soramitsu.iroha2.type.StringType import jp.co.soramitsu.iroha2.type.Type import jp.co.soramitsu.iroha2.type.U128Type @@ -28,7 +26,6 @@ import jp.co.soramitsu.iroha2.type.U64Type import jp.co.soramitsu.iroha2.type.U8Type import jp.co.soramitsu.iroha2.type.VecType import jp.co.soramitsu.iroha2.type.WrapperType -import java.math.BigDecimal import java.math.BigInteger import kotlin.reflect.KClass @@ -66,7 +63,6 @@ fun resolveKotlinType(type: Type): TypeName { } } is CompactType -> resolveKotlinType((type as WrapperType).innerType.requireValue()) - is FixedPointType -> BigDecimal::class.asTypeName() is WrapperType -> { // special case for vector of bytes if (type is VecType && type.innerType.requireValue() is U8Type) { @@ -96,13 +92,12 @@ fun lookUpInBuiltInTypes(type: Type): TypeName = builtinKotlinTypes[type::class] /** * Define the package name for the given [class][className] and [type] */ -fun definePackageName(className: String, type: Type): String { - return "jp.co.soramitsu.iroha2.generated." + type.name.substringBeforeLast(className) +fun definePackageName(className: String, type: Type): String = + "jp.co.soramitsu.iroha2.generated." + type.name.substringBeforeLast(className) .removeSuffix("::") .removePrefix("iroha") .replace("::", ".") .replace("_", "") -} /** * Define the class name for the given [type][typeName] @@ -126,7 +121,6 @@ val builtinKotlinTypes = mapOf, TypeName>( I128Type::class to BigInteger::class.asTypeName(), I256Type::class to BigInteger::class.asTypeName(), VecType::class to List::class.asTypeName(), - SetType::class to Set::class.asTypeName(), MapType::class to Map::class.asTypeName(), ArrayType::class to Array::class.asTypeName(), ) diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/Blueprint.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/Blueprint.kt index baace2e09..711fcf007 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/Blueprint.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/Blueprint.kt @@ -17,4 +17,8 @@ abstract class Blueprint(val source: T) { /** * Type properties */ -data class Property(val name: String, val typeName: TypeName, val original: Type) +data class Property( + val name: String, + val typeName: TypeName, + val original: Type, +) diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/EnumBlueprint.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/EnumBlueprint.kt index f1926dfc6..75587f867 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/EnumBlueprint.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/EnumBlueprint.kt @@ -8,9 +8,7 @@ import jp.co.soramitsu.iroha2.type.EnumType class EnumBlueprint(type: EnumType) : TypeBasedBlueprint(type) { val variants = resolveVariants() - private fun resolveVariants(): List { - return source.variants.map { - EnumVariantBlueprint(it.discriminant, this, it) - } + private fun resolveVariants(): List = source.variants.map { + EnumVariantBlueprint(it.discriminant, this, it) } } diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/EnumVariantBlueprint.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/EnumVariantBlueprint.kt index b9b13cc81..16b7ad694 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/EnumVariantBlueprint.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/EnumVariantBlueprint.kt @@ -17,14 +17,12 @@ class EnumVariantBlueprint( override val packageName = "${parentBlueprint.packageName}.${parentBlueprint.className}" override val properties = resolveProperties(source) - override fun resolveProperties(variant: EnumType.Variant): List { - return variant.type?.requireValue() - ?.let { type -> - Property( - defineClassName(type.name).replaceFirstChar(Char::lowercase), - resolveKotlinType(type), - type, - ) - }?.let { property -> listOf(property) } ?: listOf() - } + override fun resolveProperties(variant: EnumType.Variant): List = variant.type?.requireValue() + ?.let { type -> + Property( + defineClassName(type.name).replaceFirstChar(Char::lowercase), + resolveKotlinType(type), + type, + ) + }?.let { property -> listOf(property) } ?: listOf() } diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/StructBlueprint.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/StructBlueprint.kt index db4bbf00e..2f7251e92 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/StructBlueprint.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/StructBlueprint.kt @@ -8,14 +8,12 @@ import java.util.StringTokenizer * Blueprint for [StructType] */ class StructBlueprint(type: StructType) : TypeBasedBlueprint(type) { - override fun resolveProperties(type: StructType): List { - return type.mapping.map { (name, ty) -> - Property( - convertToCamelCase(name), - resolveKotlinType(ty.requireValue()), - ty.requireValue(), - ) - } + override fun resolveProperties(type: StructType): List = type.mapping.map { (name, ty) -> + Property( + convertToCamelCase(name), + resolveKotlinType(ty.requireValue()), + ty.requireValue(), + ) } /** diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/TupleStructBlueprint.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/TupleStructBlueprint.kt index 9381847ca..43dff1bd8 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/TupleStructBlueprint.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/TupleStructBlueprint.kt @@ -21,14 +21,16 @@ class TupleStructBlueprint(type: TupleStructType) : TypeBasedBlueprint "array" - else -> defineClassName(type.name).let { name -> - when (unique) { - true -> name.replaceFirstChar { it.lowercase() } - else -> "p${propertyCount}${name.replaceFirstChar { it.uppercase() }}" - } + private fun createPropName( + type: Type, + unique: Boolean = true, + propertyCount: Int? = null, + ): String = when (type) { + is ArrayType -> "array" + else -> defineClassName(type.name).let { name -> + when (unique) { + true -> name.replaceFirstChar { it.lowercase() } + else -> "p${propertyCount}${name.replaceFirstChar { it.uppercase() }}" } } } diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/AbstractGenerator.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/AbstractGenerator.kt index 49fe2c233..8ceab90d6 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/AbstractGenerator.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/AbstractGenerator.kt @@ -4,6 +4,7 @@ import com.squareup.kotlinpoet.ClassName import com.squareup.kotlinpoet.CodeBlock import com.squareup.kotlinpoet.FunSpec import com.squareup.kotlinpoet.KModifier +import com.squareup.kotlinpoet.MemberName import com.squareup.kotlinpoet.ParameterSpec import com.squareup.kotlinpoet.ParameterizedTypeName import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy @@ -12,7 +13,11 @@ import com.squareup.kotlinpoet.TypeName import com.squareup.kotlinpoet.TypeSpec import com.squareup.kotlinpoet.TypeVariableName import com.squareup.kotlinpoet.WildcardTypeName +import jp.co.soramitsu.iroha2.ModelCustomInstruction +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codegen.blueprint.Blueprint +import jp.co.soramitsu.iroha2.generated.InstructionBox +import jp.co.soramitsu.iroha2.transaction.Instruction import jp.co.soramitsu.iroha2.type.CompositeType /** @@ -119,7 +124,23 @@ abstract class AbstractGenerator> { .build() } - open fun implFunctions(blueprint: T, clazz: TypeSpec.Builder) = Unit + open fun implFunctions(blueprint: T, clazz: TypeSpec.Builder) { + if (blueprint.className.startsWith("RegisterOf") || + blueprint.className.startsWith("UnregisterOf") || + blueprint.className.startsWith("SetKeyValueOf") || + blueprint.className.startsWith("RemoveKeyValueOf") || + blueprint.className.startsWith("MintOf") || + blueprint.className.startsWith("BurnOf") || + blueprint.className.startsWith("TransferOf") || + blueprint.className.startsWith("GrantOf") || + blueprint.className.startsWith("RevokeOf") || + blueprint.className == "Upgrade" || + blueprint.className == "SetParameter" || + blueprint.className == "ExecuteTrigger" + ) { + clazz.addFunction(asInstructionBoxFun()) + } + } open fun implInnerClasses(blueprint: T, clazz: TypeSpec.Builder) = Unit @@ -129,7 +150,31 @@ abstract class AbstractGenerator> { } } - open fun implSuperClasses(blueprint: T, clazz: TypeSpec.Builder) = Unit + open fun implSuperClasses(blueprint: T, clazz: TypeSpec.Builder) { + if (blueprint.className.startsWith("Can")) { + clazz.addSuperinterface(ModelPermission::class) + } else if ( + blueprint.className == "MultisigRegister" || + blueprint.className == "MultisigPropose" || + blueprint.className == "MultisigApprove" + ) { + clazz.addSuperinterface(ModelCustomInstruction::class) + } else if (blueprint.className.startsWith("RegisterOf") || + blueprint.className.startsWith("UnregisterOf") || + blueprint.className.startsWith("SetKeyValueOf") || + blueprint.className.startsWith("RemoveKeyValueOf") || + blueprint.className.startsWith("MintOf") || + blueprint.className.startsWith("BurnOf") || + blueprint.className.startsWith("TransferOf") || + blueprint.className.startsWith("GrantOf") || + blueprint.className.startsWith("RevokeOf") || + blueprint.className == "Upgrade" || + blueprint.className == "SetParameter" || + blueprint.className == "ExecuteTrigger" + ) { + clazz.addSuperinterface(Instruction::class) + } + } open fun implConstructor(blueprint: T, clazz: TypeSpec.Builder) { if (blueprint.properties.isEmpty()) { @@ -155,21 +200,25 @@ abstract class AbstractGenerator> { clazz.addKdoc(blueprint.className) } - private fun writeFun(type: TypeName, blueprint: T) = - FunSpec.builder("write") - .addParameter(ParameterSpec.builder("writer", SCALE_CODEC_WRITER).build()) - .addParameter(ParameterSpec.builder("instance", type).build()) - .addCode(scaleWriterCode(blueprint)) - .addModifiers(KModifier.OVERRIDE) - .build() - - private fun readFun(type: TypeName, blueprint: T) = - FunSpec.builder("read") - .addParameter(ParameterSpec.builder("reader", SCALE_CODEC_READER).build()) - .addCode(scaleReaderCode(blueprint)) - .addModifiers(KModifier.OVERRIDE) - .returns(type) - .build() + private fun writeFun(type: TypeName, blueprint: T) = FunSpec.builder("write") + .addParameter(ParameterSpec.builder("writer", SCALE_CODEC_WRITER).build()) + .addParameter(ParameterSpec.builder("instance", type).build()) + .addCode(scaleWriterCode(blueprint)) + .addModifiers(KModifier.OVERRIDE) + .build() + + private fun asInstructionBoxFun() = FunSpec.builder("asInstructionBox") + .addCode(CodeBlock.of("return %M()", MemberName("jp.co.soramitsu.iroha2", "asInstructionBoxExt"))) + .addModifiers(KModifier.OVERRIDE) + .returns(InstructionBox::class) + .build() + + private fun readFun(type: TypeName, blueprint: T) = FunSpec.builder("read") + .addParameter(ParameterSpec.builder("reader", SCALE_CODEC_READER).build()) + .addCode(scaleReaderCode(blueprint)) + .addModifiers(KModifier.OVERRIDE) + .returns(type) + .build() private fun variantEqualsFun(blueprint: T): FunSpec { val variantType = ClassName(blueprint.packageName, blueprint.className) diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/EnumGenerator.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/EnumGenerator.kt index efe137751..f18f6f957 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/EnumGenerator.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/EnumGenerator.kt @@ -71,22 +71,18 @@ object EnumGenerator : AbstractGenerator() { clazz.addSuperinterface(ModelEnum::class) } - private fun hashCodeFun(blueprint: EnumBlueprint): FunSpec { - return FunSpec.builder("hashCode") - .addCode(hashcodeCode(blueprint)) - .addModifiers(KModifier.OVERRIDE) - .returns(Int::class.java) - .build() - } - - private fun equalsFun(blueprint: EnumBlueprint): FunSpec { - return FunSpec.builder("equals") - .addParameter(ParameterSpec.builder("other", ANY_TYPE.copy(nullable = true)).build()) - .addCode(equalsCode(blueprint)) - .addModifiers(KModifier.OVERRIDE) - .returns(Boolean::class.java) - .build() - } + private fun hashCodeFun(blueprint: EnumBlueprint): FunSpec = FunSpec.builder("hashCode") + .addCode(hashcodeCode(blueprint)) + .addModifiers(KModifier.OVERRIDE) + .returns(Int::class.java) + .build() + + private fun equalsFun(blueprint: EnumBlueprint): FunSpec = FunSpec.builder("equals") + .addParameter(ParameterSpec.builder("other", ANY_TYPE.copy(nullable = true)).build()) + .addCode(equalsCode(blueprint)) + .addModifiers(KModifier.OVERRIDE) + .returns(Boolean::class.java) + .build() private fun equalsCode(blueprint: EnumBlueprint): CodeBlock { val codeBlock = CodeBlock.builder().add("return when(this) {\n") diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/EnumVariantGenerator.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/EnumVariantGenerator.kt index 952918d0a..2c8ee4e76 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/EnumVariantGenerator.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/EnumVariantGenerator.kt @@ -49,17 +49,13 @@ object EnumVariantGenerator : AbstractGenerator() { } } - override fun implCompanions( - blueprint: EnumVariantBlueprint, - clazz: TypeSpec.Builder, - ): TypeSpec.Builder { - return super.implCompanions(blueprint, clazz) + override fun implCompanions(blueprint: EnumVariantBlueprint, clazz: TypeSpec.Builder): TypeSpec.Builder = + super.implCompanions(blueprint, clazz) .addProperty( PropertySpec.builder("DISCRIMINANT", Int::class, KModifier.CONST) .initializer("%L", blueprint.discriminant) .build(), ) - } override fun implSuperClasses(blueprint: EnumVariantBlueprint, clazz: TypeSpec.Builder) { super.implSuperClasses(blueprint, clazz) diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/Scale.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/Scale.kt index 48ed9bd27..82a0ea6dd 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/Scale.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/Scale.kt @@ -17,14 +17,12 @@ import jp.co.soramitsu.iroha2.type.ArrayType import jp.co.soramitsu.iroha2.type.BooleanType import jp.co.soramitsu.iroha2.type.CompactType import jp.co.soramitsu.iroha2.type.CompositeType -import jp.co.soramitsu.iroha2.type.FixedPointType import jp.co.soramitsu.iroha2.type.I128Type import jp.co.soramitsu.iroha2.type.I256Type import jp.co.soramitsu.iroha2.type.I32Type import jp.co.soramitsu.iroha2.type.I64Type import jp.co.soramitsu.iroha2.type.MapType import jp.co.soramitsu.iroha2.type.OptionType -import jp.co.soramitsu.iroha2.type.SetType import jp.co.soramitsu.iroha2.type.StringType import jp.co.soramitsu.iroha2.type.Type import jp.co.soramitsu.iroha2.type.U128Type @@ -48,98 +46,81 @@ val FROM_FIXED_POINT = MemberName("jp.co.soramitsu.iroha2", "fromFixedPoint") /** * Resolve Scale Reader for a given [type] */ -fun resolveScaleReadImpl(type: Type): CodeBlock { - return when (type) { - is ArrayType -> type.scaleReadImpl() - is VecType -> type.scaleReadImpl() - is SetType -> CodeBlock.of( - "reader.readSet(reader.readCompactInt()) {%L}", - resolveScaleReadImpl(type.innerType.requireValue()), - ) - is MapType -> CodeBlock.of( - "reader.readMap(reader.readCompactInt(), {%1L}, {%2L})", - resolveScaleReadImpl(type.key.requireValue()), - resolveScaleReadImpl(type.value.requireValue()), - ) - is U8Type -> CodeBlock.of("reader.readUByte().toShort()") - is U16Type -> CodeBlock.of("reader.readUint16()") - is U32Type -> CodeBlock.of("reader.readUint32()") - is U64Type -> CodeBlock.of("reader.readUint64()") - is U128Type -> CodeBlock.of("reader.readUint128()") - is U256Type -> CodeBlock.of("reader.readUint256()") - is I32Type -> CodeBlock.of("reader.readInt32()") - is I64Type -> CodeBlock.of("reader.readInt64()") - is I128Type -> CodeBlock.of("reader.readInt128()") - is I256Type -> CodeBlock.of("reader.readInt256()") - is StringType -> CodeBlock.of("reader.readString()") - is BooleanType -> CodeBlock.of("reader.readBoolean()") - is CompositeType -> type.scaleReadImpl() - is OptionType -> type.scaleReadImpl() - is FixedPointType -> type.scaleReadImpl() - is CompactType -> type.scaleReadImpl() - else -> throw RuntimeException("Unexpected type: $type") - } +fun resolveScaleReadImpl(type: Type): CodeBlock = when (type) { + is ArrayType -> type.scaleReadImpl() + is VecType -> type.scaleReadImpl() + is MapType -> CodeBlock.of( + "reader.readMap(reader.readCompactInt(), {%1L}, {%2L})", + resolveScaleReadImpl(type.key.requireValue()), + resolveScaleReadImpl(type.value.requireValue()), + ) + is U8Type -> CodeBlock.of("reader.readUByte().toShort()") + is U16Type -> CodeBlock.of("reader.readUint16()") + is U32Type -> CodeBlock.of("reader.readUint32()") + is U64Type -> CodeBlock.of("reader.readUint64()") + is U128Type -> CodeBlock.of("reader.readUint128()") + is U256Type -> CodeBlock.of("reader.readUint256()") + is I32Type -> CodeBlock.of("reader.readInt32()") + is I64Type -> CodeBlock.of("reader.readInt64()") + is I128Type -> CodeBlock.of("reader.readInt128()") + is I256Type -> CodeBlock.of("reader.readInt256()") + is StringType -> CodeBlock.of("reader.readString()") + is BooleanType -> CodeBlock.of("reader.readBoolean()") + is CompositeType -> type.scaleReadImpl() + is OptionType -> type.scaleReadImpl() + is CompactType -> type.scaleReadImpl() + else -> throw RuntimeException("Unexpected type: $type") } /** * Resolve Scale Writer for a given [type] */ -fun resolveScaleWriteImpl(type: Type, propName: CodeBlock): CodeBlock { - return when (type) { - is ArrayType -> type.scaleWriteImpl(propName) - is VecType -> type.scaleWriteImpl(propName) - is SetType -> type.scaleWriteImpl(propName) - is MapType -> type.scaleWriteImpl(propName) - is U8Type -> CodeBlock.of("writer.writeUByte(%L)", propName) - is U16Type -> CodeBlock.of("writer.writeUint16(%L)", propName) - is U32Type -> CodeBlock.of("writer.writeUint32(%L)", propName) - is U64Type -> CodeBlock.of("writer.writeUint64(%L)", propName) - is U128Type -> CodeBlock.of("writer.writeUint128(%L)", propName) - is U256Type -> CodeBlock.of("writer.writeUint256(%L)", propName) - is I32Type -> CodeBlock.of("writer.writeInt32(%L)", propName) - is I64Type -> CodeBlock.of("writer.writeInt64(%L)", propName) - is I128Type -> CodeBlock.of("writer.writeInt128(%L)", propName) - is I256Type -> CodeBlock.of("writer.writeInt256(%L)", propName) - is StringType -> CodeBlock.of("writer.writeAsList(%L.toByteArray(Charsets.UTF_8))", propName) - is BooleanType -> CodeBlock.of("if (%L) { writer.directWrite(1) } else { writer.directWrite(0) }", propName) - is CompositeType -> CodeBlock.of("%T.write(writer, %L)", withoutGenerics(resolveKotlinType(type)), propName) - is OptionType -> type.scaleWriteImpl(propName) - is FixedPointType -> type.scaleWriteImpl(propName) - is CompactType -> CodeBlock.of("writer.write(%T(), %L.toLong())", COMPACT_ULONG_WRITER, propName) - else -> throw RuntimeException("Unexpected type: $type") - } +fun resolveScaleWriteImpl(type: Type, propName: CodeBlock): CodeBlock = when (type) { + is ArrayType -> type.scaleWriteImpl(propName) + is VecType -> type.scaleWriteImpl(propName) + is MapType -> type.scaleWriteImpl(propName) + is U8Type -> CodeBlock.of("writer.writeUByte(%L)", propName) + is U16Type -> CodeBlock.of("writer.writeUint16(%L)", propName) + is U32Type -> CodeBlock.of("writer.writeUint32(%L)", propName) + is U64Type -> CodeBlock.of("writer.writeUint64(%L)", propName) + is U128Type -> CodeBlock.of("writer.writeUint128(%L)", propName) + is U256Type -> CodeBlock.of("writer.writeUint256(%L)", propName) + is I32Type -> CodeBlock.of("writer.writeInt32(%L)", propName) + is I64Type -> CodeBlock.of("writer.writeInt64(%L)", propName) + is I128Type -> CodeBlock.of("writer.writeInt128(%L)", propName) + is I256Type -> CodeBlock.of("writer.writeInt256(%L)", propName) + is StringType -> CodeBlock.of("writer.writeAsList(%L.toByteArray(Charsets.UTF_8))", propName) + is BooleanType -> CodeBlock.of("if (%L) { writer.directWrite(1) } else { writer.directWrite(0) }", propName) + is CompositeType -> CodeBlock.of("%T.write(writer, %L)", withoutGenerics(resolveKotlinType(type)), propName) + is OptionType -> type.scaleWriteImpl(propName) + is CompactType -> CodeBlock.of("writer.write(%T(), %L.toLong())", COMPACT_ULONG_WRITER, propName) + else -> throw RuntimeException("Unexpected type: $type") } /** * @return the class name for a given [type][typeName] */ -fun withoutGenerics(typeName: TypeName): ClassName { - return when (typeName) { - is ClassName -> typeName.topLevelClassName() - is ParameterizedTypeName -> typeName.rawType.topLevelClassName() - else -> throw RuntimeException("Unexpected type name: $typeName") - } +fun withoutGenerics(typeName: TypeName): ClassName = when (typeName) { + is ClassName -> typeName.topLevelClassName() + is ParameterizedTypeName -> typeName.rawType.topLevelClassName() + else -> throw RuntimeException("Unexpected type name: $typeName") } -private fun ArrayType.scaleReadImpl(): CodeBlock { - return when (this.innerType.requireValue()) { - is U8Type -> CodeBlock.of("reader.readByteArray(%L)", this.size) - else -> CodeBlock.of( - "reader.readArray(%L) {%L}", - this.size, - resolveScaleReadImpl(this.innerType.requireValue()), - ) - } +private fun ArrayType.scaleReadImpl(): CodeBlock = when (this.innerType.requireValue()) { + is U8Type -> CodeBlock.of("reader.readByteArray(%L)", this.size) + else -> CodeBlock.of( + "reader.readArray(%L) {%L}", + this.size, + resolveScaleReadImpl(this.innerType.requireValue()), + ) } -private fun VecType.scaleReadImpl(): CodeBlock { - return when (this.innerType.requireValue()) { - is U8Type -> CodeBlock.of("reader.readByteArray()") - else -> CodeBlock.of( - "reader.readVec(reader.readCompactInt()) {%L}", - resolveScaleReadImpl(this.innerType.requireValue()), - ) - } +private fun VecType.scaleReadImpl(): CodeBlock = when (this.innerType.requireValue()) { + is U8Type -> CodeBlock.of("reader.readByteArray()") + else -> CodeBlock.of( + "reader.readVec(reader.readCompactInt()) {%L}", + resolveScaleReadImpl(this.innerType.requireValue()), + ) } private fun CompositeType.scaleReadImpl(): CodeBlock { @@ -152,38 +133,24 @@ private fun CompositeType.scaleReadImpl(): CodeBlock { } } -private fun OptionType.scaleReadImpl(): CodeBlock { - return when (this.innerType.requireValue()) { - is U64Type, U32Type, U16Type, StringType -> CodeBlock.of("reader.readNullable()") - else -> resolveKotlinType(this).let { type -> - CodeBlock.of( - "reader.readNullable(%1T) as %2T", - withoutGenerics(type), - type, - ) - } - } -} - -private fun FixedPointType.scaleReadImpl(): CodeBlock { - return when (this.innerType.requireValue()) { - is I64Type -> CodeBlock.builder() - .add(resolveScaleReadImpl(this.innerType.requireValue())) - .add(".toBigInteger().%M()", FROM_FIXED_POINT) - .build() - else -> throw RuntimeException("Fixed point with base type $this not implemented") +private fun OptionType.scaleReadImpl(): CodeBlock = when (this.innerType.requireValue()) { + is U64Type, U32Type, U16Type, StringType -> CodeBlock.of("reader.readNullable()") + else -> resolveKotlinType(this).let { type -> + CodeBlock.of( + "reader.readNullable(%1T) as %2T", + withoutGenerics(type), + type, + ) } } -private fun CompactType.scaleReadImpl(): CodeBlock { - return when (val innerType = this.innerType.requireValue()) { - is U8Type -> CodeBlock.of("reader.readCompactInt().toShort()") - is U16Type -> CodeBlock.of("reader.readCompactInt().toInt()") - is U32Type -> CodeBlock.of("reader.readCompactInt().toLong()") - is U64Type -> CodeBlock.of("reader.read(%T()).toBigInteger()", COMPACT_BIG_INT_READER) - is U128Type, is U256Type -> CodeBlock.of("reader.read(%T())", COMPACT_BIG_INT_READER) - else -> throw RuntimeException("Compact type implementation unresolved: $innerType") - } +private fun CompactType.scaleReadImpl(): CodeBlock = when (val innerType = this.innerType.requireValue()) { + is U8Type -> CodeBlock.of("reader.readCompactInt().toShort()") + is U16Type -> CodeBlock.of("reader.readCompactInt().toInt()") + is U32Type -> CodeBlock.of("reader.readCompactInt().toLong()") + is U64Type -> CodeBlock.of("reader.read(%T()).toBigInteger()", COMPACT_BIG_INT_READER) + is U128Type, is U256Type -> CodeBlock.of("reader.read(%T())", COMPACT_BIG_INT_READER) + else -> throw RuntimeException("Compact type implementation unresolved: $innerType") } private fun MapType.scaleWriteImpl(propName: CodeBlock): CodeBlock { @@ -203,71 +170,50 @@ private fun MapType.scaleWriteImpl(propName: CodeBlock): CodeBlock { ) } -private fun FixedPointType.scaleWriteImpl(propName: CodeBlock): CodeBlock { - return when (this.innerType.requireValue()) { - is I64Type -> CodeBlock.of("writer.writeInt64(%1L.%2M().toLong())", propName, TO_FIXED_POINT) - else -> throw RuntimeException("Fixed point with base type $this not implemented") - } +private fun OptionType.scaleWriteImpl(propName: CodeBlock): CodeBlock = when (this.innerType.requireValue()) { + is U64Type, U32Type, U16Type, StringType -> CodeBlock.of( + "writer.writeNullable(%L)", + propName, + ) + else -> CodeBlock.of( + "writer.writeNullable(%1T, %2L)", + withoutGenerics(resolveKotlinType(this)), + propName, + ) } -private fun OptionType.scaleWriteImpl(propName: CodeBlock): CodeBlock { - return when (this.innerType.requireValue()) { - is U64Type, U32Type, U16Type, StringType -> CodeBlock.of( - "writer.writeNullable(%L)", - propName, - ) - else -> CodeBlock.of( - "writer.writeNullable(%1T, %2L)", - withoutGenerics(resolveKotlinType(this)), +private fun ArrayType.scaleWriteImpl(propName: CodeBlock): CodeBlock = when (this.innerType.requireValue()) { + is U8Type -> CodeBlock.of("writer.writeByteArray(%L)", propName) + else -> { + val value = resolveScaleWriteImpl(this.innerType.requireValue(), CodeBlock.of("value")) + CodeBlock.of( + "%1L.forEach { value ->\n%2L\n}", propName, + value, ) } } -private fun ArrayType.scaleWriteImpl(propName: CodeBlock): CodeBlock { - return when (this.innerType.requireValue()) { - is U8Type -> CodeBlock.of("writer.writeByteArray(%L)", propName) - else -> { - val value = resolveScaleWriteImpl(this.innerType.requireValue(), CodeBlock.of("value")) - CodeBlock.of( - "%1L.forEach { value ->\n%2L\n}", - propName, - value, - ) - } - } -} - -private fun VecType.scaleWriteImpl(propName: CodeBlock): CodeBlock { - return when (this.innerType.requireValue()) { - is U8Type -> CodeBlock.of("writer.writeAsList(%L)", propName) - else -> { - val sorted = when (this.sorted) { - true -> { - val innerType = resolveKotlinType(this.innerType.requireValue()) - val innerTypeName = innerType.rawTypeName() - CodeBlock.of(".sortedWith(\n%1L.comparator()\n)", innerTypeName) - } - false -> CodeBlock.of("") +private fun VecType.scaleWriteImpl(propName: CodeBlock): CodeBlock = when (this.innerType.requireValue()) { + is U8Type -> CodeBlock.of("writer.writeAsList(%L)", propName) + else -> { + val sorted = when (this.sorted) { + true -> { + val innerType = resolveKotlinType(this.innerType.requireValue()) + val innerTypeName = innerType.rawTypeName() + CodeBlock.of(".sortedWith(\n%1L.comparator()\n)", innerTypeName) } - val value = resolveScaleWriteImpl(this.innerType.requireValue(), CodeBlock.of("value")) - - CodeBlock.of( - "writer.writeCompact(%1L.size)\n%1L%3L.forEach { value ->\n%2L\n}", - propName, - value, - sorted, - ) + false -> CodeBlock.of("") } - } -} + val value = resolveScaleWriteImpl(this.innerType.requireValue(), CodeBlock.of("value")) -private fun SetType.scaleWriteImpl(propName: CodeBlock): CodeBlock { - return CodeBlock.of( - "writer.writeCompact(%1L.size)\n%1L.forEach { value -> %2L }", - propName, - resolveScaleWriteImpl(this.innerType.requireValue(), CodeBlock.of("value")), - ) + CodeBlock.of( + "writer.writeCompact(%1L.size)\n%1L%3L.forEach { value ->\n%2L\n}", + propName, + value, + sorted, + ) + } } private fun TypeName.rawTypeName() = ((this as? ParameterizedTypeName)?.rawType ?: (this as ClassName)).simpleName diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/StructGenerator.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/StructGenerator.kt index 7cef21f34..89599da8a 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/StructGenerator.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/StructGenerator.kt @@ -25,47 +25,43 @@ object StructGenerator : AbstractGenerator() { } } - private fun hashCodeFun(blueprint: StructBlueprint): FunSpec { - return FunSpec.builder("hashCode") - .addModifiers(KModifier.OVERRIDE) - .returns(Int::class) - .apply { - when (blueprint.properties.isEmpty()) { - true -> addStatement("return 0") - false -> { - val firstProperty = blueprint.properties[0] - when (blueprint.properties[0].typeName) { - ByteArray::class.asTypeName() -> addCode("return %L.%L()", firstProperty.name, "contentHashCode") - else -> addCode("return %L.%L()", firstProperty.name, "hashCode") - } - for ((property, type) in blueprint.properties.drop(1)) { - addCode(" * 31") - when (type) { - ByteArray::class.asTypeName() -> addCode(" + %L.contentHashCode()", property) - else -> addCode(" + %L.hashCode()", property) - } + private fun hashCodeFun(blueprint: StructBlueprint): FunSpec = FunSpec.builder("hashCode") + .addModifiers(KModifier.OVERRIDE) + .returns(Int::class) + .apply { + when (blueprint.properties.isEmpty()) { + true -> addStatement("return 0") + false -> { + val firstProperty = blueprint.properties[0] + when (blueprint.properties[0].typeName) { + ByteArray::class.asTypeName() -> addCode("return %L.%L()", firstProperty.name, "contentHashCode") + else -> addCode("return %L.%L()", firstProperty.name, "hashCode") + } + for ((property, type) in blueprint.properties.drop(1)) { + addCode(" * 31") + when (type) { + ByteArray::class.asTypeName() -> addCode(" + %L.contentHashCode()", property) + else -> addCode(" + %L.hashCode()", property) } - addCode("\n") } + addCode("\n") } - }.build() - } + } + }.build() - private fun equalsFun(blueprint: StructBlueprint): FunSpec { - return FunSpec.builder("equals") - .addModifiers(KModifier.OVERRIDE) - .addParameter(ParameterSpec.builder("other", ANY_TYPE.copy(nullable = true)).build()) - .returns(Boolean::class) - .addStatement("if (this === other) return true") - .addStatement("if (other !is %L) return false", blueprint.className) - .apply { - for ((property, type) in blueprint.properties) { - when (type) { - ByteArray::class.asTypeName() -> addStatement("if (!%L.contentEquals(other.%L)) return false", property, property) - else -> addStatement("if (%L != other.%L) return false", property, property) - } + private fun equalsFun(blueprint: StructBlueprint): FunSpec = FunSpec.builder("equals") + .addModifiers(KModifier.OVERRIDE) + .addParameter(ParameterSpec.builder("other", ANY_TYPE.copy(nullable = true)).build()) + .returns(Boolean::class) + .addStatement("if (this === other) return true") + .addStatement("if (other !is %L) return false", blueprint.className) + .apply { + for ((property, type) in blueprint.properties) { + when (type) { + ByteArray::class.asTypeName() -> addStatement("if (!%L.contentEquals(other.%L)) return false", property, property) + else -> addStatement("if (%L != other.%L) return false", property, property) } - addStatement("return true") - }.build() - } + } + addStatement("return true") + }.build() } diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/TupleStructGenerator.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/TupleStructGenerator.kt index 4a51af474..f74a1edaf 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/TupleStructGenerator.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/TupleStructGenerator.kt @@ -7,10 +7,7 @@ import jp.co.soramitsu.iroha2.codegen.blueprint.TupleStructBlueprint * Generator for [TupleStructBlueprint] */ object TupleStructGenerator : AbstractGenerator() { - override fun implKDoc( - blueprint: TupleStructBlueprint, - clazz: TypeSpec.Builder, - ) { + override fun implKDoc(blueprint: TupleStructBlueprint, clazz: TypeSpec.Builder) { super.implKDoc(blueprint, clazz) clazz.addKdoc("\n\nGenerated from '${blueprint.source.name}' tuple structure") } diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/SchemaParser.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/SchemaParser.kt index af337c2dd..ecb7313de 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/SchemaParser.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/SchemaParser.kt @@ -31,13 +31,11 @@ class SchemaParser { /** * Parse the given [name] and return its [TypeNest] */ - fun createAndGetNest(name: String, typeValue: Any? = null): TypeNest { - return registry.getOrPut(name) { - TypeNest(name, null) - }.also { - if (it.value == null) { - it.value = resolver.resolve(name, typeValue) - } + fun createAndGetNest(name: String, typeValue: Any? = null): TypeNest = registry.getOrPut(name) { + TypeNest(name, null) + }.also { + if (it.value == null) { + it.value = resolver.resolve(name, typeValue) } } } diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/SchemaReader.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/SchemaReader.kt index 96eec8b50..a4ea5c34d 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/SchemaReader.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/SchemaReader.kt @@ -22,6 +22,7 @@ class SchemaReader { lines.forEach { line -> line.countRepeatedWithGenerics() } repeated.entries.removeIf { (it.key != "Trigger" && it.key != "Action") && it.value < 2 } toReplace.putAll(lines.mapNotNull { it.getReplacePairOrNull() }.toMap()) + toReplace["null"] = "{\"Tuple\": []}" lines.forEach { line -> sb.appendLine(line.replace()) } diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/TypeResolver.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/TypeResolver.kt index 77fb9aad2..74b24a65e 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/TypeResolver.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/TypeResolver.kt @@ -6,7 +6,6 @@ import jp.co.soramitsu.iroha2.type.ArrayType import jp.co.soramitsu.iroha2.type.BooleanType import jp.co.soramitsu.iroha2.type.CompactType import jp.co.soramitsu.iroha2.type.EnumType -import jp.co.soramitsu.iroha2.type.FixedPointType import jp.co.soramitsu.iroha2.type.I128Type import jp.co.soramitsu.iroha2.type.I16Type import jp.co.soramitsu.iroha2.type.I256Type @@ -18,7 +17,6 @@ import jp.co.soramitsu.iroha2.type.IterableType import jp.co.soramitsu.iroha2.type.MapType import jp.co.soramitsu.iroha2.type.NullType import jp.co.soramitsu.iroha2.type.OptionType -import jp.co.soramitsu.iroha2.type.SetType import jp.co.soramitsu.iroha2.type.StringType import jp.co.soramitsu.iroha2.type.StructType import jp.co.soramitsu.iroha2.type.TupleStructType @@ -53,9 +51,6 @@ class TypeResolver(private val schemaParser: SchemaParser) { CompactResolver, UIntResolver, IntResolver, - SetResolver, - FixedPointResolver, - QueryResolver, ) /** @@ -81,18 +76,24 @@ class TypeResolver(private val schemaParser: SchemaParser) { * @param schemaParser The schema parser to use */ interface Resolver { - fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): T? + fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): T? } /** * Resolver for [BooleanType] */ object BooleanResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): BooleanType? { - return when (name) { - "bool" -> BooleanType - else -> null - } + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): BooleanType? = when (name) { + "bool" -> BooleanType + else -> null } } @@ -103,7 +104,11 @@ object BitMapResolver : Resolver { const val NAME = "Bitmap" - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): UIntType? { + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): UIntType? { when (typeValue) { is Map<*, *> -> if (typeValue.keys.first() != NAME) return null else -> return null @@ -122,7 +127,11 @@ object SortedMapResolver : Resolver { const val NAME = "SortedMap" - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): MapType? { + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): MapType? { if (!name.startsWith("$NAME<")) return null val wildcards = name.removePrefix(NAME) @@ -144,44 +153,48 @@ object SortedMapResolver : Resolver { * Basic resolver for wrapped types */ abstract class WrapperResolver(open val wrapperName: String) : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): T? { - return when { - name.startsWith("$wrapperName<") -> { - val innerTypeName = name.removeSurrounding("$wrapperName<", ">") - val innerType = schemaParser.createAndGetNest(innerTypeName) - createWrapper(name, innerType) - } - name.startsWith("${wrapperName}Of") -> { - val innerTypeName = name.replace("${wrapperName}Of", "") - val innerType = schemaParser.createAndGetNest(innerTypeName) - createWrapper(name, innerType) - } - else -> null + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): T? = when { + name.startsWith("$wrapperName<") -> { + val innerTypeName = name.removeSurrounding("$wrapperName<", ">") + val innerType = schemaParser.createAndGetNest(innerTypeName) + createWrapper(name, innerType) + } + name.startsWith("${wrapperName}Of") -> { + val innerTypeName = name.replace("${wrapperName}Of", "") + val innerType = schemaParser.createAndGetNest(innerTypeName) + createWrapper(name, innerType) } + else -> null } /** * Create a wrapper type for [innerType] */ - abstract fun createWrapper(name: String, innerType: TypeNest, sorted: Boolean = false): T + abstract fun createWrapper( + name: String, + innerType: TypeNest, + sorted: Boolean = false, + ): T } /** * Basic resolver for iterable types */ -abstract class SortedWrapperResolver( - override val wrapperName: String, -) : WrapperResolver(wrapperName) { +abstract class SortedWrapperResolver(override val wrapperName: String) : WrapperResolver(wrapperName) { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): T? { - return super.resolve(name, typeValue, schemaParser)?.also { - it.sorted = getSortedProperty(typeValue) - } + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): T? = super.resolve(name, typeValue, schemaParser)?.also { + it.sorted = getSortedProperty(typeValue) } - fun getSortedProperty(typeValue: Any?): Boolean { - return (typeValue as? Map<*, *>)?.get("Sorted$wrapperName") != null - } + fun getSortedProperty(typeValue: Any?): Boolean = (typeValue as? Map<*, *>)?.get("Sorted$wrapperName") != null } object SortedVectorResolver : SortedWrapperResolver("SortedVec") { @@ -193,13 +206,15 @@ object SortedVectorResolver : SortedWrapperResolver("SortedVec") { sorted: Boolean, ) = VecType(name, innerType, sorted) - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): VecType? { - return when ( - name.startsWith(wrapperName) || (typeValue as? Map<*, *>)?.get(wrapperName) != null - ) { - true -> createWrapper(name, extractGeneric(name, schemaParser).first(), true) - false -> null - } + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): VecType? = when ( + name.startsWith(wrapperName) || (typeValue as? Map<*, *>)?.get(wrapperName) != null + ) { + true -> createWrapper(name, extractGeneric(name, schemaParser).first(), true) + false -> null } } @@ -215,25 +230,16 @@ object VectorResolver : SortedWrapperResolver("Vec") { sorted: Boolean, ) = VecType(name, innerType, sorted) - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): VecType? { - return when ( - name.startsWith(wrapperName) || (typeValue as? Map<*, *>)?.get(wrapperName) != null - ) { - true -> createWrapper(name, extractGeneric(name, schemaParser).first(), false) - false -> null - } - } -} - -/** - * Resolver for [SetType] - */ -object SetResolver : WrapperResolver("BTreeSet") { - override fun createWrapper( + override fun resolve( name: String, - innerType: TypeNest, - sorted: Boolean, - ) = SetType(name, innerType, sorted) + typeValue: Any?, + schemaParser: SchemaParser, + ): VecType? = when ( + name.startsWith(wrapperName) || (typeValue as? Map<*, *>)?.get(wrapperName) != null + ) { + true -> createWrapper(name, extractGeneric(name, schemaParser).first(), false) + false -> null + } } /** @@ -243,7 +249,11 @@ object ArrayResolver : Resolver { const val NAME = "Array" - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): ArrayType? { + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): ArrayType? { if (!name.startsWith(NAME)) return null val groups = ARRAY_REGEX.find(name)?.groupValues ?: return null return ArrayType(name, schemaParser.createAndGetNest(groups[1]), groups[2].toInt()) @@ -276,22 +286,24 @@ object CompactResolver : WrapperResolver("Compact") { * Resolver for [EnumType] */ object EnumResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): EnumType? { - return if (typeValue is Map<*, *> && typeValue["Enum"] != null) { - val components = typeValue["Enum"] as List> - val generics = extractGeneric(name, schemaParser) - val variants = components.map { - val variantProperty = it["type"] as String? - EnumType.Variant( - (it["tag"] ?: throw IrohaSdkException("Enum name not found")) as String, - (it["discriminant"] ?: throw IrohaSdkException("Enum discriminant not found")) as Int, - variantProperty?.let(schemaParser::createAndGetNest), - ) - } - EnumType(name, generics, variants) - } else { - null + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): EnumType? = if (typeValue is Map<*, *> && typeValue["Enum"] != null) { + val components = typeValue["Enum"] as List> + val generics = extractGeneric(name, schemaParser) + val variants = components.map { + val variantProperty = it["type"] as String? + EnumType.Variant( + (it["tag"] ?: throw IrohaSdkException("Enum name not found")) as String, + (it["discriminant"] ?: throw IrohaSdkException("Enum discriminant not found")) as Int, + variantProperty?.let(schemaParser::createAndGetNest), + ) } + EnumType(name, generics, variants) + } else { + null } } @@ -303,15 +315,13 @@ object TupleStructResolver : Resolver { name: String, typeValue: Any?, schemaParser: SchemaParser, - ): TupleStructType? { - return if (typeValue is Map<*, *> && typeValue["Tuple"] != null) { - val components = typeValue["Tuple"] as List - val children = components.map(schemaParser::createAndGetNest) - val generics = extractGeneric(name, schemaParser) - TupleStructType(name, generics, children) - } else { - null - } + ): TupleStructType? = if (typeValue is Map<*, *> && typeValue["Tuple"] != null) { + val components = typeValue["Tuple"] as List + val children = components.map(schemaParser::createAndGetNest) + val generics = extractGeneric(name, schemaParser) + TupleStructType(name, generics, children) + } else { + null } } @@ -319,20 +329,22 @@ object TupleStructResolver : Resolver { * Resolver for [StructType] */ object StructResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): StructType? { - return if ((typeValue is Map<*, *> && typeValue["Struct"] != null)) { - val components = typeValue["Struct"] as List> - val properties = LinkedHashMap() - for (singleMapping in components) { - val fieldName = singleMapping["name"] ?: throw IrohaSdkException("Component 'name' not found") - val fieldType = singleMapping["type"] ?: throw IrohaSdkException("Component 'type' not found") - properties[fieldName] = schemaParser.createAndGetNest(fieldType) - } - val generics = extractGeneric(name, schemaParser) - StructType(name, generics, properties) - } else { - null + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): StructType? = if ((typeValue is Map<*, *> && typeValue["Struct"] != null)) { + val components = typeValue["Struct"] as List> + val properties = LinkedHashMap() + for (singleMapping in components) { + val fieldName = singleMapping["name"] ?: throw IrohaSdkException("Component 'name' not found") + val fieldType = singleMapping["type"] ?: throw IrohaSdkException("Component 'type' not found") + properties[fieldName] = schemaParser.createAndGetNest(fieldType) } + val generics = extractGeneric(name, schemaParser) + StructType(name, generics, properties) + } else { + null } } @@ -340,17 +352,19 @@ object StructResolver : Resolver { * Resolver for [StructType] */ object OneStringStructResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): StructType? { - return if (typeValue is String) { - val fieldName = typeValue.toFieldName() - val properties = LinkedHashMap().also { map -> - map[fieldName] = schemaParser.createAndGetNest(typeValue) - } - val generics = extractGeneric(name, schemaParser) - StructType(name, generics, properties) - } else { - null + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): StructType? = if (typeValue is String) { + val fieldName = typeValue.toFieldName() + val properties = LinkedHashMap().also { map -> + map[fieldName] = schemaParser.createAndGetNest(typeValue) } + val generics = extractGeneric(name, schemaParser) + StructType(name, generics, properties) + } else { + null } private fun String.toFieldName() = this.replaceFirstChar { it.lowercase() }.let { name -> @@ -367,29 +381,17 @@ object OneStringStructResolver : Resolver { } } -/** - * Resolver for [StructType] - */ -object QueryResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): StructType? { - return if (name.startsWith("Find") && typeValue == null) { - val generics = extractGeneric(name, schemaParser) - StructType(name, generics, emptyMap()) - } else { - null - } - } -} - /** * Resolver for [StringType] */ object StringResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): StringType? { - return when { - name.endsWith("String") -> StringType - else -> null - } + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): StringType? = when { + name.endsWith("String") -> StringType + else -> null } } @@ -397,18 +399,20 @@ object StringResolver : Resolver { * Resolver for [UIntType] */ object UIntResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): UIntType? { - return when (name) { - "AtomicU32Wrapper" -> U32Type - "NonZeroU8" -> U8Type - "u8" -> U8Type - "u16" -> U16Type - "u32" -> U32Type - "u64" -> U64Type - "u128" -> U128Type - "u256" -> U256Type - else -> null - } + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): UIntType? = when (name) { + "AtomicU32Wrapper" -> U32Type + "NonZeroU8" -> U8Type + "u8" -> U8Type + "u16" -> U16Type + "u32" -> U32Type + "u64" -> U64Type + "u128" -> U128Type + "u256" -> U256Type + else -> null } } @@ -416,32 +420,18 @@ object UIntResolver : Resolver { * Resolver for [IntType] */ object IntResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): IntType? { - return when (name) { - "i8" -> I8Type - "i16" -> I16Type - "i32" -> I32Type - "i64" -> I64Type - "i128" -> I128Type - "i256" -> I256Type - else -> null - } - } -} - -/** - * Resolver for [FixedPointType] - */ -object FixedPointResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): FixedPointType? { - return if (name.startsWith("FixedPoint<") && typeValue is Map<*, *>) { - val members = (typeValue["FixedPoint"] as? Map)!! - val base = schemaParser.createAndGetNest(members["base"]!! as String) - val decimalPlaces = members["decimal_places"]!! as Int - FixedPointType(name, base, decimalPlaces) - } else { - null - } + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): IntType? = when (name) { + "i8" -> I8Type + "i16" -> I16Type + "i32" -> I32Type + "i64" -> I64Type + "i128" -> I128Type + "i256" -> I256Type + else -> null } } @@ -471,7 +461,5 @@ data class TypeNest(val name: String, var value: Type?) { return name == other.name } - override fun hashCode(): Int { - return name.hashCode() - } + override fun hashCode(): Int = name.hashCode() } diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Common.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Common.kt index a3e0e330f..aef25294f 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Common.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Common.kt @@ -12,7 +12,7 @@ sealed class Type(open val name: String) { } /** - * Boolean type + * Unit struct type */ object NullType : Type("null") diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Composite.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Composite.kt index f3cf3af4c..d980e8c93 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Composite.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Composite.kt @@ -19,7 +19,11 @@ data class EnumType( /** * Variant of a enum type */ - data class Variant(val name: String, val discriminant: Int, val type: TypeNest?) + data class Variant( + val name: String, + val discriminant: Int, + val type: TypeNest?, + ) private var resolutionInProgress: Boolean = false @@ -44,11 +48,9 @@ data class TupleStructType( override val generics: List, val types: List, ) : CompositeType(name, generics) { - override fun notResolvedTypes(): Set { - return types.union(generics).flatMap { - it.value?.notResolvedTypes() ?: setOf(it.name) - }.toSet() - } + override fun notResolvedTypes(): Set = types.union(generics).flatMap { + it.value?.notResolvedTypes() ?: setOf(it.name) + }.toSet() } /** @@ -59,9 +61,7 @@ data class StructType( override val generics: List, val mapping: Map, ) : CompositeType(name, generics) { - override fun notResolvedTypes(): Set { - return mapping.values.union(generics).flatMap { - it.value?.let { setOf() } ?: setOf(it.name) - }.toSet() - } + override fun notResolvedTypes(): Set = mapping.values.union(generics).flatMap { + it.value?.let { setOf() } ?: setOf(it.name) + }.toSet() } diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Wrapper.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Wrapper.kt index 83dd2796b..4494083f5 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Wrapper.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Wrapper.kt @@ -25,10 +25,7 @@ abstract class IterableType( /** * `OptionType` wrapper type. */ -data class OptionType( - override val name: String, - override val innerType: TypeNest, -) : WrapperType(name, innerType) +data class OptionType(override val name: String, override val innerType: TypeNest) : WrapperType(name, innerType) /** * `VecType` iterable type. @@ -39,15 +36,6 @@ data class VecType( override var sorted: Boolean = false, ) : IterableType(name, innerType, sorted) -/** - * `SetType` iterable type. - */ -data class SetType( - override val name: String, - override val innerType: TypeNest, - override var sorted: Boolean = false, -) : IterableType(name, innerType, sorted) - /** * `ArrayType` iterable type. */ @@ -61,16 +49,4 @@ data class ArrayType( /** * `CompactType` wrapper type. */ -data class CompactType( - override val name: String, - override val innerType: TypeNest, -) : WrapperType(name, innerType) - -/** - * Fixed-point type - */ -data class FixedPointType( - override val name: String, - override val innerType: TypeNest, - val decimalPlaces: Int, -) : WrapperType(name, innerType) +data class CompactType(override val name: String, override val innerType: TypeNest) : WrapperType(name, innerType) \ No newline at end of file diff --git a/modules/codegen/src/main/resources/schema.json b/modules/codegen/src/main/resources/schema.json index a77385493..85751191e 100644 --- a/modules/codegen/src/main/resources/schema.json +++ b/modules/codegen/src/main/resources/schema.json @@ -127,6 +127,52 @@ } ] }, + "AccountIdPredicateAtom": { + "Enum": [ + { + "tag": "Equals", + "discriminant": 0, + "type": "AccountId" + } + ] + }, + "AccountIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "AccountIdPredicateAtom" + }, + { + "tag": "Domain", + "discriminant": 1, + "type": "DomainIdProjection" + }, + { + "tag": "Signatory", + "discriminant": 2, + "type": "PublicKeyProjection" + } + ] + }, + "AccountIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Domain", + "discriminant": 1, + "type": "DomainIdProjection" + }, + { + "tag": "Signatory", + "discriminant": 2, + "type": "PublicKeyProjection" + } + ] + }, "AccountPermissionChanged": { "Struct": [ { @@ -139,6 +185,46 @@ } ] }, + "AccountPredicateAtom": { + "Enum": [] + }, + "AccountProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "AccountPredicateAtom" + }, + { + "tag": "Id", + "discriminant": 1, + "type": "AccountIdProjection" + }, + { + "tag": "Metadata", + "discriminant": 2, + "type": "MetadataProjection" + } + ] + }, + "AccountProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Id", + "discriminant": 1, + "type": "AccountIdProjection" + }, + { + "tag": "Metadata", + "discriminant": 2, + "type": "MetadataProjection" + } + ] + }, "AccountRoleChanged": { "Struct": [ { @@ -175,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": [ { @@ -262,6 +378,10 @@ { "name": "owned_by", "type": "AccountId" + }, + { + "name": "total_quantity", + "type": "Numeric" } ] }, @@ -363,6 +483,52 @@ } ] }, + "AssetDefinitionIdPredicateAtom": { + "Enum": [ + { + "tag": "Equals", + "discriminant": 0, + "type": "AssetDefinitionId" + } + ] + }, + "AssetDefinitionIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "AssetDefinitionIdPredicateAtom" + }, + { + "tag": "Domain", + "discriminant": 1, + "type": "DomainIdProjection" + }, + { + "tag": "Name", + "discriminant": 2, + "type": "NameProjection" + } + ] + }, + "AssetDefinitionIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Domain", + "discriminant": 1, + "type": "DomainIdProjection" + }, + { + "tag": "Name", + "discriminant": 2, + "type": "NameProjection" + } + ] + }, "AssetDefinitionOwnerChanged": { "Struct": [ { @@ -375,6 +541,46 @@ } ] }, + "AssetDefinitionPredicateAtom": { + "Enum": [] + }, + "AssetDefinitionProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "AssetDefinitionPredicateAtom" + }, + { + "tag": "Id", + "discriminant": 1, + "type": "AssetDefinitionIdProjection" + }, + { + "tag": "Metadata", + "discriminant": 2, + "type": "MetadataProjection" + } + ] + }, + "AssetDefinitionProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Id", + "discriminant": 1, + "type": "AssetDefinitionIdProjection" + }, + { + "tag": "Metadata", + "discriminant": 2, + "type": "MetadataProjection" + } + ] + }, "AssetDefinitionTotalQuantityChanged": { "Struct": [ { @@ -476,6 +682,92 @@ } ] }, + "AssetIdPredicateAtom": { + "Enum": [ + { + "tag": "Equals", + "discriminant": 0, + "type": "AssetId" + } + ] + }, + "AssetIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "AssetIdPredicateAtom" + }, + { + "tag": "Account", + "discriminant": 1, + "type": "AccountIdProjection" + }, + { + "tag": "Definition", + "discriminant": 2, + "type": "AssetDefinitionIdProjection" + } + ] + }, + "AssetIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Account", + "discriminant": 1, + "type": "AccountIdProjection" + }, + { + "tag": "Definition", + "discriminant": 2, + "type": "AssetDefinitionIdProjection" + } + ] + }, + "AssetPredicateAtom": { + "Enum": [] + }, + "AssetProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "AssetPredicateAtom" + }, + { + "tag": "Id", + "discriminant": 1, + "type": "AssetIdProjection" + }, + { + "tag": "Value", + "discriminant": 2, + "type": "AssetValueProjection" + } + ] + }, + "AssetProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Id", + "discriminant": 1, + "type": "AssetIdProjection" + }, + { + "tag": "Value", + "discriminant": 2, + "type": "AssetValueProjection" + } + ] + }, "AssetTransferBox": { "Enum": [ { @@ -517,36 +809,52 @@ } ] }, - "AtIndex": { - "Struct": [ + "AssetValuePredicateAtom": { + "Enum": [ { - "name": "index", - "type": "u32" + "tag": "IsNumeric", + "discriminant": 0 }, { - "name": "predicate", - "type": "QueryOutputPredicate" + "tag": "IsStore", + "discriminant": 1 } ] }, - "BatchedResponse": { + "AssetValueProjection": { "Enum": [ { - "tag": "V1", + "tag": "Atom", + "discriminant": 0, + "type": "AssetValuePredicateAtom" + }, + { + "tag": "Numeric", "discriminant": 1, - "type": "BatchedResponseV1" + "type": "NumericProjection" + }, + { + "tag": "Store", + "discriminant": 2, + "type": "MetadataProjection" } ] }, - "BatchedResponseV1": { - "Struct": [ + "AssetValueProjection": { + "Enum": [ { - "name": "batch", - "type": "QueryOutputBox" + "tag": "Atom", + "discriminant": 0 }, { - "name": "cursor", - "type": "ForwardCursor" + "tag": "Numeric", + "discriminant": 1, + "type": "NumericProjection" + }, + { + "tag": "Store", + "discriminant": 2, + "type": "MetadataProjection" } ] }, @@ -595,44 +903,92 @@ { "name": "view_change_index", "type": "u32" - }, - { - "name": "consensus_estimation_ms", - "type": "u64" } ] }, - "BlockMessage": "SignedBlock", - "BlockParameter": { + "BlockHeaderHashPredicateAtom": { "Enum": [ { - "tag": "MaxTransactions", + "tag": "Equals", "discriminant": 0, - "type": "NonZero" + "type": "HashOf" } ] }, - "BlockParameters": { - "Struct": [ + "BlockHeaderHashProjection": { + "Enum": [ { - "name": "max_transactions", - "type": "NonZero" + "tag": "Atom", + "discriminant": 0, + "type": "BlockHeaderHashPredicateAtom" } ] }, - "BlockPayload": { - "Struct": [ - { - "name": "header", - "type": "BlockHeader" - }, + "BlockHeaderHashProjection": { + "Enum": [ { - "name": "transactions", - "type": "Vec" + "tag": "Atom", + "discriminant": 0 + } + ] + }, + "BlockHeaderPredicateAtom": { + "Enum": [] + }, + "BlockHeaderProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "BlockHeaderPredicateAtom" + }, + { + "tag": "Hash", + "discriminant": 1, + "type": "BlockHeaderHashProjection" + } + ] + }, + "BlockHeaderProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Hash", + "discriminant": 1, + "type": "BlockHeaderHashProjection" + } + ] + }, + "BlockMessage": "SignedBlock", + "BlockParameter": { + "Enum": [ + { + "tag": "MaxTransactions", + "discriminant": 0, + "type": "NonZero" + } + ] + }, + "BlockParameters": { + "Struct": [ + { + "name": "max_transactions", + "type": "NonZero" + } + ] + }, + "BlockPayload": { + "Struct": [ + { + "name": "header", + "type": "BlockHeader" }, { - "name": "event_recommendations", - "type": "Vec" + "name": "transactions", + "type": "Vec" } ] }, @@ -653,21 +1009,25 @@ "BlockStatus": { "Enum": [ { - "tag": "Approved", + "tag": "Created", "discriminant": 0 }, + { + "tag": "Approved", + "discriminant": 1 + }, { "tag": "Rejected", - "discriminant": 1, + "discriminant": 2, "type": "BlockRejectionReason" }, { "tag": "Committed", - "discriminant": 2 + "discriminant": 3 }, { "tag": "Applied", - "discriminant": 3 + "discriminant": 4 } ] }, @@ -710,15 +1070,7 @@ } ] }, - "CanBurnAssetWithDefinition": { - "Struct": [ - { - "name": "asset_definition", - "type": "AssetDefinitionId" - } - ] - }, - "CanBurnUserAsset": { + "CanBurnAsset": { "Struct": [ { "name": "asset", @@ -726,23 +1078,7 @@ } ] }, - "CanBurnUserTrigger": { - "Struct": [ - { - "name": "trigger", - "type": "TriggerId" - } - ] - }, - "CanExecuteUserTrigger": { - "Struct": [ - { - "name": "trigger", - "type": "TriggerId" - } - ] - }, - "CanMintAssetWithDefinition": { + "CanBurnAssetWithDefinition": { "Struct": [ { "name": "asset_definition", @@ -750,15 +1086,7 @@ } ] }, - "CanMintUserAsset": { - "Struct": [ - { - "name": "asset", - "type": "AssetId" - } - ] - }, - "CanMintUserTrigger": { + "CanExecuteTrigger": { "Struct": [ { "name": "trigger", @@ -766,23 +1094,17 @@ } ] }, - "CanRegisterAccountInDomain": { - "Struct": [ - { - "name": "domain", - "type": "DomainId" - } - ] - }, - "CanRegisterAssetDefinitionInDomain": { + "CanManagePeers": null, + "CanManageRoles": null, + "CanMintAsset": { "Struct": [ { - "name": "domain", - "type": "DomainId" + "name": "asset", + "type": "AssetId" } ] }, - "CanRegisterAssetWithDefinition": { + "CanMintAssetWithDefinition": { "Struct": [ { "name": "asset_definition", @@ -790,7 +1112,7 @@ } ] }, - "CanRegisterUserTrigger": { + "CanModifyAccountMetadata": { "Struct": [ { "name": "account", @@ -798,23 +1120,23 @@ } ] }, - "CanRemoveKeyValueInAccount": { + "CanModifyAssetDefinitionMetadata": { "Struct": [ { - "name": "account", - "type": "AccountId" + "name": "asset_definition", + "type": "AssetDefinitionId" } ] }, - "CanRemoveKeyValueInAssetDefinition": { + "CanModifyAssetMetadata": { "Struct": [ { - "name": "asset_definition", - "type": "AssetDefinitionId" + "name": "asset", + "type": "AssetId" } ] }, - "CanRemoveKeyValueInDomain": { + "CanModifyDomainMetadata": { "Struct": [ { "name": "domain", @@ -822,7 +1144,7 @@ } ] }, - "CanRemoveKeyValueInTrigger": { + "CanModifyTrigger": { "Struct": [ { "name": "trigger", @@ -830,31 +1152,31 @@ } ] }, - "CanRemoveKeyValueInUserAsset": { + "CanModifyTriggerMetadata": { "Struct": [ { - "name": "asset", - "type": "AssetId" + "name": "trigger", + "type": "TriggerId" } ] }, - "CanSetKeyValueInAccount": { + "CanRegisterAccount": { "Struct": [ { - "name": "account", - "type": "AccountId" + "name": "domain", + "type": "DomainId" } ] }, - "CanSetKeyValueInAssetDefinition": { + "CanRegisterAsset": { "Struct": [ { - "name": "asset_definition", - "type": "AssetDefinitionId" + "name": "owner", + "type": "AccountId" } ] }, - "CanSetKeyValueInDomain": { + "CanRegisterAssetDefinition": { "Struct": [ { "name": "domain", @@ -862,15 +1184,25 @@ } ] }, - "CanSetKeyValueInTrigger": { + "CanRegisterAssetWithDefinition": { "Struct": [ { - "name": "trigger", - "type": "TriggerId" + "name": "asset_definition", + "type": "AssetDefinitionId" + } + ] + }, + "CanRegisterDomain": null, + "CanRegisterTrigger": { + "Struct": [ + { + "name": "authority", + "type": "AccountId" } ] }, - "CanSetKeyValueInUserAsset": { + "CanSetParameters": null, + "CanTransferAsset": { "Struct": [ { "name": "asset", @@ -878,7 +1210,6 @@ } ] }, - "CanSetParameters": null, "CanTransferAssetWithDefinition": { "Struct": [ { @@ -887,24 +1218,22 @@ } ] }, - "CanTransferUserAsset": { + "CanUnregisterAccount": { "Struct": [ { - "name": "asset", - "type": "AssetId" + "name": "account", + "type": "AccountId" } ] }, - "CanUnregisterAccount": { + "CanUnregisterAsset": { "Struct": [ { - "name": "account", - "type": "AccountId" + "name": "asset", + "type": "AssetId" } ] }, - "CanUnregisterAnyPeer": null, - "CanUnregisterAnyRole": null, "CanUnregisterAssetDefinition": { "Struct": [ { @@ -929,61 +1258,79 @@ } ] }, - "CanUnregisterUserAsset": { - "Struct": [ - { - "name": "asset", - "type": "AssetId" - } - ] - }, - "CanUnregisterUserTrigger": { + "CanUnregisterTrigger": { "Struct": [ { - "name": "account", - "type": "AccountId" + "name": "trigger", + "type": "TriggerId" } ] }, "CanUpgradeExecutor": null, "ChainId": "String", - "ClientQueryPayload": { + "CommittedTransaction": { "Struct": [ { - "name": "authority", - "type": "AccountId" + "name": "block_hash", + "type": "HashOf" }, { - "name": "query", - "type": "QueryBox" + "name": "value", + "type": "SignedTransaction" }, { - "name": "filter", - "type": "GenericPredicateBox" + "name": "error", + "type": "Option" + } + ] + }, + "CommittedTransactionPredicateAtom": { + "Enum": [] + }, + "CommittedTransactionProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "CommittedTransactionPredicateAtom" }, { - "name": "sorting", - "type": "Sorting" + "tag": "BlockHash", + "discriminant": 1, + "type": "BlockHeaderHashProjection" }, { - "name": "pagination", - "type": "Pagination" + "tag": "Value", + "discriminant": 2, + "type": "SignedTransactionProjection" }, { - "name": "fetch_size", - "type": "FetchSize" + "tag": "Error", + "discriminant": 3, + "type": "TransactionErrorProjection" } ] }, - "CommittedTransaction": { - "Struct": [ + "CommittedTransactionProjection": { + "Enum": [ { - "name": "value", - "type": "SignedTransaction" + "tag": "Atom", + "discriminant": 0 }, { - "name": "error", - "type": "Option" + "tag": "BlockHash", + "discriminant": 1, + "type": "BlockHeaderHashProjection" + }, + { + "tag": "Value", + "discriminant": 2, + "type": "SignedTransactionProjection" + }, + { + "tag": "Error", + "discriminant": 3, + "type": "TransactionErrorProjection" } ] }, @@ -993,73 +1340,366 @@ "Compact": { "Int": "Compact" }, - "ConfigurationEvent": { + "CompoundPredicate": { "Enum": [ { - "tag": "Changed", + "tag": "Atom", "discriminant": 0, - "type": "ParameterChanged" - } - ] - }, - "ConfigurationEventFilter": { - "Struct": [ + "type": "AccountProjection" + }, { - "name": "event_set", - "type": "ConfigurationEventSet" + "tag": "Not", + "discriminant": 1, + "type": "CompoundPredicate" + }, + { + "tag": "And", + "discriminant": 2, + "type": "Vec>" + }, + { + "tag": "Or", + "discriminant": 3, + "type": "Vec>" } ] }, - "ConfigurationEventSet": { - "Bitmap": { - "repr": "u32", - "masks": [ - { - "name": "Changed", - "mask": 1 - } - ] - } - }, - "Container": { + "CompoundPredicate": { "Enum": [ { - "tag": "Any", + "tag": "Atom", "discriminant": 0, - "type": "QueryOutputPredicate" + "type": "AssetProjection" }, { - "tag": "All", + "tag": "Not", "discriminant": 1, - "type": "QueryOutputPredicate" + "type": "CompoundPredicate" }, { - "tag": "AtIndex", + "tag": "And", "discriminant": 2, - "type": "AtIndex" - } - ] - }, - "CustomInstruction": { - "Struct": [ + "type": "Vec>" + }, { - "name": "payload", - "type": "JsonString" + "tag": "Or", + "discriminant": 3, + "type": "Vec>" } ] }, - "CustomParameter": { - "Struct": [ + "CompoundPredicate": { + "Enum": [ { - "name": "id", - "type": "CustomParameterId" + "tag": "Atom", + "discriminant": 0, + "type": "AssetDefinitionProjection" }, { - "name": "payload", - "type": "JsonString" - } - ] - }, + "tag": "Not", + "discriminant": 1, + "type": "CompoundPredicate" + }, + { + "tag": "And", + "discriminant": 2, + "type": "Vec>" + }, + { + "tag": "Or", + "discriminant": 3, + "type": "Vec>" + } + ] + }, + "CompoundPredicate": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "BlockHeaderProjection" + }, + { + "tag": "Not", + "discriminant": 1, + "type": "CompoundPredicate" + }, + { + "tag": "And", + "discriminant": 2, + "type": "Vec>" + }, + { + "tag": "Or", + "discriminant": 3, + "type": "Vec>" + } + ] + }, + "CompoundPredicate": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "CommittedTransactionProjection" + }, + { + "tag": "Not", + "discriminant": 1, + "type": "CompoundPredicate" + }, + { + "tag": "And", + "discriminant": 2, + "type": "Vec>" + }, + { + "tag": "Or", + "discriminant": 3, + "type": "Vec>" + } + ] + }, + "CompoundPredicate": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "DomainProjection" + }, + { + "tag": "Not", + "discriminant": 1, + "type": "CompoundPredicate" + }, + { + "tag": "And", + "discriminant": 2, + "type": "Vec>" + }, + { + "tag": "Or", + "discriminant": 3, + "type": "Vec>" + } + ] + }, + "CompoundPredicate": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "PeerIdProjection" + }, + { + "tag": "Not", + "discriminant": 1, + "type": "CompoundPredicate" + }, + { + "tag": "And", + "discriminant": 2, + "type": "Vec>" + }, + { + "tag": "Or", + "discriminant": 3, + "type": "Vec>" + } + ] + }, + "CompoundPredicate": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "PermissionProjection" + }, + { + "tag": "Not", + "discriminant": 1, + "type": "CompoundPredicate" + }, + { + "tag": "And", + "discriminant": 2, + "type": "Vec>" + }, + { + "tag": "Or", + "discriminant": 3, + "type": "Vec>" + } + ] + }, + "CompoundPredicate": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "RoleProjection" + }, + { + "tag": "Not", + "discriminant": 1, + "type": "CompoundPredicate" + }, + { + "tag": "And", + "discriminant": 2, + "type": "Vec>" + }, + { + "tag": "Or", + "discriminant": 3, + "type": "Vec>" + } + ] + }, + "CompoundPredicate": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "RoleIdProjection" + }, + { + "tag": "Not", + "discriminant": 1, + "type": "CompoundPredicate" + }, + { + "tag": "And", + "discriminant": 2, + "type": "Vec>" + }, + { + "tag": "Or", + "discriminant": 3, + "type": "Vec>" + } + ] + }, + "CompoundPredicate": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "SignedBlockProjection" + }, + { + "tag": "Not", + "discriminant": 1, + "type": "CompoundPredicate" + }, + { + "tag": "And", + "discriminant": 2, + "type": "Vec>" + }, + { + "tag": "Or", + "discriminant": 3, + "type": "Vec>" + } + ] + }, + "CompoundPredicate": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "TriggerProjection" + }, + { + "tag": "Not", + "discriminant": 1, + "type": "CompoundPredicate" + }, + { + "tag": "And", + "discriminant": 2, + "type": "Vec>" + }, + { + "tag": "Or", + "discriminant": 3, + "type": "Vec>" + } + ] + }, + "CompoundPredicate": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "TriggerIdProjection" + }, + { + "tag": "Not", + "discriminant": 1, + "type": "CompoundPredicate" + }, + { + "tag": "And", + "discriminant": 2, + "type": "Vec>" + }, + { + "tag": "Or", + "discriminant": 3, + "type": "Vec>" + } + ] + }, + "ConfigurationEvent": { + "Enum": [ + { + "tag": "Changed", + "discriminant": 0, + "type": "ParameterChanged" + } + ] + }, + "ConfigurationEventFilter": { + "Struct": [ + { + "name": "event_set", + "type": "ConfigurationEventSet" + } + ] + }, + "ConfigurationEventSet": { + "Bitmap": { + "repr": "u32", + "masks": [ + { + "name": "Changed", + "mask": 1 + } + ] + } + }, + "CustomInstruction": { + "Struct": [ + { + "name": "payload", + "type": "Json" + } + ] + }, + "CustomParameter": { + "Struct": [ + { + "name": "id", + "type": "CustomParameterId" + }, + { + "name": "payload", + "type": "Json" + } + ] + }, "CustomParameterId": "Name", "DataEvent": { "Enum": [ @@ -1262,6 +1902,42 @@ } ] }, + "DomainIdPredicateAtom": { + "Enum": [ + { + "tag": "Equals", + "discriminant": 0, + "type": "DomainId" + } + ] + }, + "DomainIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "DomainIdPredicateAtom" + }, + { + "tag": "Name", + "discriminant": 1, + "type": "NameProjection" + } + ] + }, + "DomainIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Name", + "discriminant": 1, + "type": "NameProjection" + } + ] + }, "DomainOwnerChanged": { "Struct": [ { @@ -1274,6 +1950,46 @@ } ] }, + "DomainPredicateAtom": { + "Enum": [] + }, + "DomainProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "DomainPredicateAtom" + }, + { + "tag": "Id", + "discriminant": 1, + "type": "DomainIdProjection" + }, + { + "tag": "Metadata", + "discriminant": 2, + "type": "MetadataProjection" + } + ] + }, + "DomainProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Id", + "discriminant": 1, + "type": "DomainIdProjection" + }, + { + "tag": "Metadata", + "discriminant": 2, + "type": "MetadataProjection" + } + ] + }, "EventBox": { "Enum": [ { @@ -1356,7 +2072,7 @@ }, { "name": "args", - "type": "Option" + "type": "Json" } ] }, @@ -1372,7 +2088,7 @@ }, { "name": "args", - "type": "Option" + "type": "Json" } ] }, @@ -1425,7 +2141,7 @@ }, { "name": "schema", - "type": "JsonString" + "type": "Json" } ] }, @@ -1469,38 +2185,11 @@ "Struct": [ { "name": "fetch_size", - "type": "Option>" - } - ] - }, - "FindAccountById": { - "Struct": [ - { - "name": "id", - "type": "AccountId" - } - ] - }, - "FindAccountKeyValueByIdAndKey": { - "Struct": [ - { - "name": "id", - "type": "AccountId" - }, - { - "name": "key", - "type": "Name" - } - ] - }, - "FindAccountsByDomainId": { - "Struct": [ - { - "name": "domain", - "type": "DomainId" + "type": "Option>" } ] }, + "FindAccounts": null, "FindAccountsWithAsset": { "Struct": [ { @@ -1509,138 +2198,12 @@ } ] }, - "FindAllAccounts": null, - "FindAllActiveTriggerIds": null, - "FindAllAssets": null, - "FindAllAssetsDefinitions": null, - "FindAllBlockHeaders": null, - "FindAllBlocks": null, - "FindAllDomains": null, - "FindAllParameters": null, - "FindAllPeers": null, - "FindAllRoleIds": null, - "FindAllRoles": null, - "FindAllTransactions": null, - "FindAssetById": { - "Struct": [ - { - "name": "id", - "type": "AssetId" - } - ] - }, - "FindAssetDefinitionById": { - "Struct": [ - { - "name": "id", - "type": "AssetDefinitionId" - } - ] - }, - "FindAssetDefinitionKeyValueByIdAndKey": { - "Struct": [ - { - "name": "id", - "type": "AssetDefinitionId" - }, - { - "name": "key", - "type": "Name" - } - ] - }, - "FindAssetKeyValueByIdAndKey": { - "Struct": [ - { - "name": "id", - "type": "AssetId" - }, - { - "name": "key", - "type": "Name" - } - ] - }, - "FindAssetQuantityById": { - "Struct": [ - { - "name": "id", - "type": "AssetId" - } - ] - }, - "FindAssetsByAccountId": { - "Struct": [ - { - "name": "account", - "type": "AccountId" - } - ] - }, - "FindAssetsByAssetDefinitionId": { - "Struct": [ - { - "name": "asset_definition", - "type": "AssetDefinitionId" - } - ] - }, - "FindAssetsByDomainId": { - "Struct": [ - { - "name": "domain", - "type": "DomainId" - } - ] - }, - "FindAssetsByDomainIdAndAssetDefinitionId": { - "Struct": [ - { - "name": "domain", - "type": "DomainId" - }, - { - "name": "asset_definition", - "type": "AssetDefinitionId" - } - ] - }, - "FindAssetsByName": { - "Struct": [ - { - "name": "name", - "type": "Name" - } - ] - }, - "FindBlockHeaderByHash": { - "Struct": [ - { - "name": "hash", - "type": "HashOf" - } - ] - }, - "FindDomainById": { - "Struct": [ - { - "name": "id", - "type": "DomainId" - } - ] - }, - "FindDomainKeyValueByIdAndKey": { - "Struct": [ - { - "name": "id", - "type": "DomainId" - }, - { - "name": "key", - "type": "Name" - } - ] - }, + "FindActiveTriggerIds": null, + "FindAssets": null, + "FindAssetsDefinitions": null, + "FindBlockHeaders": null, + "FindBlocks": null, + "FindDomains": null, "FindError": { "Enum": [ { @@ -1706,123 +2269,69 @@ ] }, "FindExecutorDataModel": null, + "FindParameters": null, + "FindPeers": null, "FindPermissionsByAccountId": { "Struct": [ { - "name": "id", - "type": "AccountId" - } - ] - }, - "FindRoleByRoleId": { - "Struct": [ - { - "name": "id", - "type": "RoleId" - } - ] - }, - "FindRolesByAccountId": { - "Struct": [ - { - "name": "id", - "type": "AccountId" - } - ] - }, - "FindTotalAssetQuantityByAssetDefinitionId": { - "Struct": [ - { - "name": "id", - "type": "AssetDefinitionId" - } - ] - }, - "FindTransactionByHash": { - "Struct": [ - { - "name": "hash", - "type": "HashOf" - } - ] - }, - "FindTransactionsByAccountId": { - "Struct": [ - { - "name": "account", - "type": "AccountId" - } - ] - }, - "FindTriggerById": { - "Struct": [ - { - "name": "id", - "type": "TriggerId" - } - ] - }, - "FindTriggerKeyValueByIdAndKey": { - "Struct": [ - { - "name": "id", - "type": "TriggerId" - }, - { - "name": "key", - "type": "Name" - } - ] - }, - "FindTriggersByAuthorityDomainId": { - "Struct": [ - { - "name": "domain", - "type": "DomainId" + "name": "id", + "type": "AccountId" } ] }, - "FindTriggersByAuthorityId": { + "FindRoleIds": null, + "FindRoles": null, + "FindRolesByAccountId": { "Struct": [ { - "name": "account", + "name": "id", "type": "AccountId" } ] }, + "FindTransactions": null, + "FindTriggers": null, "ForwardCursor": { "Struct": [ { "name": "query", - "type": "Option" + "type": "String" }, { "name": "cursor", - "type": "Option>" + "type": "NonZero" } ] }, - "GenericPredicateBox": { - "Enum": [ + "GenesisWasmAction": { + "Struct": [ { - "tag": "And", - "discriminant": 0, - "type": "NonTrivial>" + "name": "executable", + "type": "String" }, { - "tag": "Or", - "discriminant": 1, - "type": "NonTrivial>" + "name": "repeats", + "type": "Repeats" }, { - "tag": "Not", - "discriminant": 2, - "type": "GenericPredicateBox" + "name": "authority", + "type": "AccountId" }, { - "tag": "Raw", - "discriminant": 3, - "type": "QueryOutputPredicate" + "name": "filter", + "type": "EventFilterBox" + } + ] + }, + "GenesisWasmTrigger": { + "Struct": [ + { + "name": "id", + "type": "TriggerId" + }, + { + "name": "action", + "type": "GenesisWasmAction" } ] }, @@ -1885,6 +2394,7 @@ "HashOf": "Hash", "HashOf>": "Hash", "HashOf": "Hash", + "HashOf>": "Hash", "IdBox": { "Enum": [ { @@ -1934,70 +2444,6 @@ } ] }, - "IdentifiableBox": { - "Enum": [ - { - "tag": "NewDomain", - "discriminant": 0, - "type": "NewDomain" - }, - { - "tag": "NewAccount", - "discriminant": 1, - "type": "NewAccount" - }, - { - "tag": "NewAssetDefinition", - "discriminant": 2, - "type": "NewAssetDefinition" - }, - { - "tag": "NewRole", - "discriminant": 3, - "type": "Role" - }, - { - "tag": "Peer", - "discriminant": 4, - "type": "Peer" - }, - { - "tag": "Domain", - "discriminant": 5, - "type": "Domain" - }, - { - "tag": "Account", - "discriminant": 6, - "type": "Account" - }, - { - "tag": "AssetDefinition", - "discriminant": 7, - "type": "AssetDefinition" - }, - { - "tag": "Asset", - "discriminant": 8, - "type": "Asset" - }, - { - "tag": "Trigger", - "discriminant": 9, - "type": "Trigger" - }, - { - "tag": "Role", - "discriminant": 10, - "type": "Role" - }, - { - "tag": "CustomParameter", - "discriminant": 11, - "type": "CustomParameter" - } - ] - }, "InstructionBox": { "Enum": [ { @@ -2228,7 +2674,33 @@ "IpfsPath": "String", "Ipv4Addr": "Array", "Ipv6Addr": "Array", - "JsonString": "String", + "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": [ { @@ -2301,7 +2773,7 @@ "MerkleTree": { "Vec": "HashOf" }, - "Metadata": "SortedMap", + "Metadata": "SortedMap", "MetadataChanged": { "Struct": [ { @@ -2314,7 +2786,7 @@ }, { "name": "value", - "type": "JsonString" + "type": "Json" } ] }, @@ -2330,7 +2802,7 @@ }, { "name": "value", - "type": "JsonString" + "type": "Json" } ] }, @@ -2346,7 +2818,7 @@ }, { "name": "value", - "type": "JsonString" + "type": "Json" } ] }, @@ -2362,7 +2834,7 @@ }, { "name": "value", - "type": "JsonString" + "type": "Json" } ] }, @@ -2378,7 +2850,61 @@ }, { "name": "value", - "type": "JsonString" + "type": "Json" + } + ] + }, + "MetadataKeyProjection": { + "Struct": [ + { + "name": "key", + "type": "Name" + }, + { + "name": "projection", + "type": "JsonProjection" + } + ] + }, + "MetadataKeyProjection": { + "Struct": [ + { + "name": "key", + "type": "Name" + }, + { + "name": "projection", + "type": "JsonProjection" + } + ] + }, + "MetadataPredicateAtom": { + "Enum": [] + }, + "MetadataProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "MetadataPredicateAtom" + }, + { + "tag": "Key", + "discriminant": 1, + "type": "MetadataKeyProjection" + } + ] + }, + "MetadataProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Key", + "discriminant": 1, + "type": "MetadataKeyProjection" } ] }, @@ -2460,7 +2986,123 @@ } ] }, + "MultisigApprove": { + "Struct": [ + { + "name": "account", + "type": "AccountId" + }, + { + "name": "instructions_hash", + "type": "HashOf>" + } + ] + }, + "MultisigInstructionBox": { + "Enum": [ + { + "tag": "Register", + "discriminant": 0, + "type": "MultisigRegister" + }, + { + "tag": "Propose", + "discriminant": 1, + "type": "MultisigPropose" + }, + { + "tag": "Approve", + "discriminant": 2, + "type": "MultisigApprove" + } + ] + }, + "MultisigProposalValue": { + "Struct": [ + { + "name": "instructions", + "type": "Vec" + }, + { + "name": "proposed_at_ms", + "type": "NonZero" + }, + { + "name": "expires_at_ms", + "type": "NonZero" + }, + { + "name": "approvals", + "type": "SortedVec" + }, + { + "name": "is_relayed", + "type": "Option" + } + ] + }, + "MultisigPropose": { + "Struct": [ + { + "name": "account", + "type": "AccountId" + }, + { + "name": "instructions", + "type": "Vec" + }, + { + "name": "transaction_ttl_ms", + "type": "Option>" + } + ] + }, + "MultisigRegister": { + "Struct": [ + { + "name": "account", + "type": "AccountId" + }, + { + "name": "spec", + "type": "MultisigSpec" + } + ] + }, + "MultisigSpec": { + "Struct": [ + { + "name": "signatories", + "type": "SortedMap" + }, + { + "name": "quorum", + "type": "NonZero" + }, + { + "name": "transaction_ttl_ms", + "type": "NonZero" + } + ] + }, "Name": "String", + "NameProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "StringPredicateAtom" + } + ] + }, + "NameProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + } + ] + }, "NewAccount": { "Struct": [ { @@ -2513,7 +3155,19 @@ } ] }, - "NonTrivial>": "Vec>", + "NewRole": { + "Struct": [ + { + "name": "inner", + "type": "Role" + }, + { + "name": "grant_to", + "type": "AccountId" + } + ] + }, + "NonZero": "u16", "NonZero": "u32", "NonZero": "u64", "Numeric": { @@ -2528,6 +3182,26 @@ } ] }, + "NumericPredicateAtom": { + "Enum": [] + }, + "NumericProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "NumericPredicateAtom" + } + ] + }, + "NumericProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + } + ] + }, "NumericSpec": { "Struct": [ { @@ -2551,6 +3225,9 @@ "Option": { "Option": "DomainId" }, + "Option": { + "Option": "ForwardCursor" + }, "Option>": { "Option": "HashOf" }, @@ -2560,9 +3237,6 @@ "Option": { "Option": "IpfsPath" }, - "Option": { - "Option": "JsonString" - }, "Option": { "Option": "Name" }, @@ -2575,18 +3249,15 @@ "Option>>": { "Option": "Option>" }, + "Option": { + "Option": "Parameters" + }, "Option": { "Option": "PeerId" }, "Option": { "Option": "RoleId" }, - "Option": { - "Option": "String" - }, - "Option": { - "Option": "TimeInterval" - }, "Option": { "Option": "TransactionRejectionReason" }, @@ -2599,6 +3270,9 @@ "Option": { "Option": "TriggerId" }, + "Option": { + "Option": "bool" + }, "Option": { "Option": "u32" }, @@ -2609,11 +3283,11 @@ "Struct": [ { "name": "limit", - "type": "Option>" + "type": "Option>" }, { - "name": "start", - "type": "Option>" + "name": "offset", + "type": "u64" } ] }, @@ -2693,6 +3367,10 @@ }, "Peer": { "Struct": [ + { + "name": "address", + "type": "SocketAddr" + }, { "name": "id", "type": "PeerId" @@ -2742,16 +3420,42 @@ }, "PeerId": { "Struct": [ - { - "name": "address", - "type": "SocketAddr" - }, { "name": "public_key", "type": "PublicKey" } ] }, + "PeerIdPredicateAtom": { + "Enum": [] + }, + "PeerIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "PeerIdPredicateAtom" + }, + { + "tag": "PublicKey", + "discriminant": 1, + "type": "PublicKeyProjection" + } + ] + }, + "PeerIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "PublicKey", + "discriminant": 1, + "type": "PublicKeyProjection" + } + ] + }, "Permission": { "Struct": [ { @@ -2760,7 +3464,27 @@ }, { "name": "payload", - "type": "JsonString" + "type": "Json" + } + ] + }, + "PermissionPredicateAtom": { + "Enum": [] + }, + "PermissionProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "PermissionPredicateAtom" + } + ] + }, + "PermissionProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 } ] }, @@ -2804,333 +3528,641 @@ } ] }, + "PublicKeyPredicateAtom": { + "Enum": [ + { + "tag": "Equals", + "discriminant": 0, + "type": "PublicKey" + } + ] + }, + "PublicKeyProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "PublicKeyPredicateAtom" + } + ] + }, + "PublicKeyProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + } + ] + }, "QueryBox": { "Enum": [ { - "tag": "FindAllAccounts", + "tag": "FindDomains", "discriminant": 0, - "type": "FindAllAccounts" + "type": "QueryWithFilter" }, { - "tag": "FindAccountById", + "tag": "FindAccounts", "discriminant": 1, - "type": "FindAccountById" + "type": "QueryWithFilter" }, { - "tag": "FindAccountKeyValueByIdAndKey", + "tag": "FindAssets", "discriminant": 2, - "type": "FindAccountKeyValueByIdAndKey" + "type": "QueryWithFilter" }, { - "tag": "FindAccountsByDomainId", + "tag": "FindAssetsDefinitions", "discriminant": 3, - "type": "FindAccountsByDomainId" + "type": "QueryWithFilter" + }, + { + "tag": "FindRoles", + "discriminant": 4, + "type": "QueryWithFilter" + }, + { + "tag": "FindRoleIds", + "discriminant": 5, + "type": "QueryWithFilter" + }, + { + "tag": "FindPermissionsByAccountId", + "discriminant": 6, + "type": "QueryWithFilter" + }, + { + "tag": "FindRolesByAccountId", + "discriminant": 7, + "type": "QueryWithFilter" }, { "tag": "FindAccountsWithAsset", + "discriminant": 8, + "type": "QueryWithFilter" + }, + { + "tag": "FindPeers", + "discriminant": 9, + "type": "QueryWithFilter" + }, + { + "tag": "FindActiveTriggerIds", + "discriminant": 10, + "type": "QueryWithFilter" + }, + { + "tag": "FindTriggers", + "discriminant": 11, + "type": "QueryWithFilter" + }, + { + "tag": "FindTransactions", + "discriminant": 12, + "type": "QueryWithFilter" + }, + { + "tag": "FindBlocks", + "discriminant": 13, + "type": "QueryWithFilter" + }, + { + "tag": "FindBlockHeaders", + "discriminant": 14, + "type": "QueryWithFilter" + } + ] + }, + "QueryExecutionFail": { + "Enum": [ + { + "tag": "Find", + "discriminant": 0, + "type": "FindError" + }, + { + "tag": "Conversion", + "discriminant": 1, + "type": "String" + }, + { + "tag": "NotFound", + "discriminant": 2 + }, + { + "tag": "CursorMismatch", + "discriminant": 3 + }, + { + "tag": "CursorDone", + "discriminant": 4 + }, + { + "tag": "FetchSizeTooBig", + "discriminant": 5 + }, + { + "tag": "InvalidSingularParameters", + "discriminant": 6 + }, + { + "tag": "CapacityLimit", + "discriminant": 7 + } + ] + }, + "QueryOutput": { + "Struct": [ + { + "name": "batch", + "type": "QueryOutputBatchBoxTuple" + }, + { + "name": "remaining_items", + "type": "u64" + }, + { + "name": "continue_cursor", + "type": "Option" + } + ] + }, + "QueryOutputBatchBox": { + "Enum": [ + { + "tag": "PublicKey", + "discriminant": 0, + "type": "Vec" + }, + { + "tag": "String", + "discriminant": 1, + "type": "Vec" + }, + { + "tag": "Metadata", + "discriminant": 2, + "type": "Vec" + }, + { + "tag": "Json", + "discriminant": 3, + "type": "Vec" + }, + { + "tag": "Numeric", "discriminant": 4, - "type": "FindAccountsWithAsset" + "type": "Vec" }, { - "tag": "FindAllAssets", + "tag": "Name", "discriminant": 5, - "type": "FindAllAssets" + "type": "Vec" }, { - "tag": "FindAllAssetsDefinitions", + "tag": "DomainId", "discriminant": 6, - "type": "FindAllAssetsDefinitions" + "type": "Vec" }, { - "tag": "FindAssetById", + "tag": "Domain", "discriminant": 7, - "type": "FindAssetById" + "type": "Vec" }, { - "tag": "FindAssetDefinitionById", + "tag": "AccountId", "discriminant": 8, - "type": "FindAssetDefinitionById" + "type": "Vec" }, { - "tag": "FindAssetsByName", + "tag": "Account", "discriminant": 9, - "type": "FindAssetsByName" + "type": "Vec" }, { - "tag": "FindAssetsByAccountId", + "tag": "AssetId", "discriminant": 10, - "type": "FindAssetsByAccountId" + "type": "Vec" + }, + { + "tag": "Asset", + "discriminant": 11, + "type": "Vec" + }, + { + "tag": "AssetValue", + "discriminant": 12, + "type": "Vec" + }, + { + "tag": "AssetDefinitionId", + "discriminant": 13, + "type": "Vec" + }, + { + "tag": "AssetDefinition", + "discriminant": 14, + "type": "Vec" + }, + { + "tag": "Role", + "discriminant": 15, + "type": "Vec" + }, + { + "tag": "Parameter", + "discriminant": 16, + "type": "Vec" + }, + { + "tag": "Permission", + "discriminant": 17, + "type": "Vec" + }, + { + "tag": "CommittedTransaction", + "discriminant": 18, + "type": "Vec" + }, + { + "tag": "SignedTransaction", + "discriminant": 19, + "type": "Vec" + }, + { + "tag": "TransactionHash", + "discriminant": 20, + "type": "Vec>" + }, + { + "tag": "TransactionRejectionReason", + "discriminant": 21, + "type": "Vec>" + }, + { + "tag": "Peer", + "discriminant": 22, + "type": "Vec" + }, + { + "tag": "RoleId", + "discriminant": 23, + "type": "Vec" + }, + { + "tag": "TriggerId", + "discriminant": 24, + "type": "Vec" + }, + { + "tag": "Trigger", + "discriminant": 25, + "type": "Vec" + }, + { + "tag": "Action", + "discriminant": 26, + "type": "Vec" + }, + { + "tag": "Block", + "discriminant": 27, + "type": "Vec" + }, + { + "tag": "BlockHeader", + "discriminant": 28, + "type": "Vec" + }, + { + "tag": "BlockHeaderHash", + "discriminant": 29, + "type": "Vec>" + } + ] + }, + "QueryOutputBatchBoxTuple": { + "Struct": [ + { + "name": "tuple", + "type": "Vec" + } + ] + }, + "QueryParams": { + "Struct": [ + { + "name": "pagination", + "type": "Pagination" }, { - "tag": "FindAssetsByAssetDefinitionId", - "discriminant": 11, - "type": "FindAssetsByAssetDefinitionId" + "name": "sorting", + "type": "Sorting" }, { - "tag": "FindAssetsByDomainId", - "discriminant": 12, - "type": "FindAssetsByDomainId" - }, + "name": "fetch_size", + "type": "FetchSize" + } + ] + }, + "QueryRequest": { + "Enum": [ { - "tag": "FindAssetsByDomainIdAndAssetDefinitionId", - "discriminant": 13, - "type": "FindAssetsByDomainIdAndAssetDefinitionId" + "tag": "Singular", + "discriminant": 0, + "type": "SingularQueryBox" }, { - "tag": "FindAssetQuantityById", - "discriminant": 14, - "type": "FindAssetQuantityById" + "tag": "Start", + "discriminant": 1, + "type": "QueryWithParams" }, { - "tag": "FindTotalAssetQuantityByAssetDefinitionId", - "discriminant": 15, - "type": "FindTotalAssetQuantityByAssetDefinitionId" - }, + "tag": "Continue", + "discriminant": 2, + "type": "ForwardCursor" + } + ] + }, + "QueryRequestWithAuthority": { + "Struct": [ { - "tag": "FindAssetKeyValueByIdAndKey", - "discriminant": 16, - "type": "FindAssetKeyValueByIdAndKey" + "name": "authority", + "type": "AccountId" }, { - "tag": "FindAssetDefinitionKeyValueByIdAndKey", - "discriminant": 17, - "type": "FindAssetDefinitionKeyValueByIdAndKey" - }, + "name": "request", + "type": "QueryRequest" + } + ] + }, + "QueryResponse": { + "Enum": [ { - "tag": "FindAllDomains", - "discriminant": 18, - "type": "FindAllDomains" + "tag": "Singular", + "discriminant": 0, + "type": "SingularQueryOutputBox" }, { - "tag": "FindDomainById", - "discriminant": 19, - "type": "FindDomainById" - }, + "tag": "Iterable", + "discriminant": 1, + "type": "QueryOutput" + } + ] + }, + "QuerySignature": "SignatureOf", + "QueryWithFilter": { + "Struct": [ { - "tag": "FindDomainKeyValueByIdAndKey", - "discriminant": 20, - "type": "FindDomainKeyValueByIdAndKey" + "name": "query", + "type": "FindAccounts" }, { - "tag": "FindAllPeers", - "discriminant": 21, - "type": "FindAllPeers" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "FindAllBlocks", - "discriminant": 22, - "type": "FindAllBlocks" - }, + "name": "selector", + "type": "SelectorTuple" + } + ] + }, + "QueryWithFilter": { + "Struct": [ { - "tag": "FindAllBlockHeaders", - "discriminant": 23, - "type": "FindAllBlockHeaders" + "name": "query", + "type": "FindAccountsWithAsset" }, { - "tag": "FindBlockHeaderByHash", - "discriminant": 24, - "type": "FindBlockHeaderByHash" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "FindAllTransactions", - "discriminant": 25, - "type": "FindAllTransactions" - }, + "name": "selector", + "type": "SelectorTuple" + } + ] + }, + "QueryWithFilter": { + "Struct": [ { - "tag": "FindTransactionsByAccountId", - "discriminant": 26, - "type": "FindTransactionsByAccountId" + "name": "query", + "type": "FindActiveTriggerIds" }, { - "tag": "FindTransactionByHash", - "discriminant": 27, - "type": "FindTransactionByHash" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "FindPermissionsByAccountId", - "discriminant": 28, - "type": "FindPermissionsByAccountId" - }, + "name": "selector", + "type": "SelectorTuple" + } + ] + }, + "QueryWithFilter": { + "Struct": [ { - "tag": "FindExecutorDataModel", - "discriminant": 29, - "type": "FindExecutorDataModel" + "name": "query", + "type": "FindAssets" }, { - "tag": "FindAllActiveTriggerIds", - "discriminant": 30, - "type": "FindAllActiveTriggerIds" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "FindTriggerById", - "discriminant": 31, - "type": "FindTriggerById" - }, + "name": "selector", + "type": "SelectorTuple" + } + ] + }, + "QueryWithFilter": { + "Struct": [ { - "tag": "FindTriggerKeyValueByIdAndKey", - "discriminant": 32, - "type": "FindTriggerKeyValueByIdAndKey" + "name": "query", + "type": "FindAssetsDefinitions" }, { - "tag": "FindTriggersByAuthorityId", - "discriminant": 33, - "type": "FindTriggersByAuthorityId" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "FindTriggersByAuthorityDomainId", - "discriminant": 34, - "type": "FindTriggersByAuthorityDomainId" - }, + "name": "selector", + "type": "SelectorTuple" + } + ] + }, + "QueryWithFilter": { + "Struct": [ { - "tag": "FindAllRoles", - "discriminant": 35, - "type": "FindAllRoles" + "name": "query", + "type": "FindBlockHeaders" }, { - "tag": "FindAllRoleIds", - "discriminant": 36, - "type": "FindAllRoleIds" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "FindRoleByRoleId", - "discriminant": 37, - "type": "FindRoleByRoleId" + "name": "selector", + "type": "SelectorTuple" + } + ] + }, + "QueryWithFilter": { + "Struct": [ + { + "name": "query", + "type": "FindBlocks" }, { - "tag": "FindRolesByAccountId", - "discriminant": 38, - "type": "FindRolesByAccountId" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "FindAllParameters", - "discriminant": 39, - "type": "FindAllParameters" + "name": "selector", + "type": "SelectorTuple" } ] }, - "QueryExecutionFail": { - "Enum": [ + "QueryWithFilter": { + "Struct": [ { - "tag": "Find", - "discriminant": 0, - "type": "FindError" + "name": "query", + "type": "FindDomains" }, { - "tag": "Conversion", - "discriminant": 1, - "type": "String" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "UnknownCursor", - "discriminant": 2 - }, + "name": "selector", + "type": "SelectorTuple" + } + ] + }, + "QueryWithFilter": { + "Struct": [ { - "tag": "FetchSizeTooBig", - "discriminant": 3 + "name": "query", + "type": "FindPeers" }, { - "tag": "InvalidSingularParameters", - "discriminant": 4 + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "CapacityLimit", - "discriminant": 5 + "name": "selector", + "type": "SelectorTuple" } ] }, - "QueryOutputBox": { - "Enum": [ + "QueryWithFilter": { + "Struct": [ { - "tag": "Id", - "discriminant": 0, - "type": "IdBox" + "name": "query", + "type": "FindPermissionsByAccountId" }, { - "tag": "Identifiable", - "discriminant": 1, - "type": "IdentifiableBox" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "Transaction", - "discriminant": 2, - "type": "TransactionQueryOutput" - }, + "name": "selector", + "type": "SelectorTuple" + } + ] + }, + "QueryWithFilter": { + "Struct": [ { - "tag": "Permission", - "discriminant": 3, - "type": "Permission" + "name": "query", + "type": "FindRoleIds" }, { - "tag": "Parameters", - "discriminant": 4, - "type": "Parameters" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "Metadata", - "discriminant": 5, - "type": "JsonString" - }, + "name": "selector", + "type": "SelectorTuple" + } + ] + }, + "QueryWithFilter": { + "Struct": [ { - "tag": "Numeric", - "discriminant": 6, - "type": "Numeric" + "name": "query", + "type": "FindRoles" }, { - "tag": "BlockHeader", - "discriminant": 7, - "type": "BlockHeader" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "Block", - "discriminant": 8, - "type": "SignedBlock" + "name": "selector", + "type": "SelectorTuple" + } + ] + }, + "QueryWithFilter": { + "Struct": [ + { + "name": "query", + "type": "FindRolesByAccountId" }, { - "tag": "ExecutorDataModel", - "discriminant": 9, - "type": "ExecutorDataModel" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "Vec", - "discriminant": 10, - "type": "Vec" + "name": "selector", + "type": "SelectorTuple" } ] }, - "QueryOutputPredicate": { - "Enum": [ + "QueryWithFilter": { + "Struct": [ { - "tag": "Identifiable", - "discriminant": 0, - "type": "StringPredicate" + "name": "query", + "type": "FindTransactions" }, { - "tag": "Container", - "discriminant": 1, - "type": "Container" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "Display", - "discriminant": 2, - "type": "StringPredicate" + "name": "selector", + "type": "SelectorTuple" + } + ] + }, + "QueryWithFilter": { + "Struct": [ + { + "name": "query", + "type": "FindTriggers" }, { - "tag": "Numerical", - "discriminant": 3, - "type": "SemiRange" + "name": "predicate", + "type": "CompoundPredicate" }, { - "tag": "TimeStamp", - "discriminant": 4, - "type": "SemiInterval" + "name": "selector", + "type": "SelectorTuple" + } + ] + }, + "QueryWithParams": { + "Struct": [ + { + "name": "query", + "type": "QueryBox" }, { - "tag": "Pass", - "discriminant": 5 + "name": "params", + "type": "QueryParams" } ] }, - "QuerySignature": "SignatureOf", "RawGenesisTransaction": { "Struct": [ { @@ -3143,12 +4175,20 @@ }, { "name": "parameters", - "type": "Vec" + "type": "Option" }, { "name": "instructions", "type": "Vec" }, + { + "name": "wasm_dir", + "type": "String" + }, + { + "name": "wasm_triggers", + "type": "Vec" + }, { "name": "topology", "type": "Vec" @@ -3191,7 +4231,7 @@ "Struct": [ { "name": "object", - "type": "Peer" + "type": "PeerId" } ] }, @@ -3199,7 +4239,7 @@ "Struct": [ { "name": "object", - "type": "Role" + "type": "NewRole" } ] }, @@ -3498,63 +4538,109 @@ } ] }, - "RolePermissionChanged": { - "Struct": [ + "RoleIdPredicateAtom": { + "Enum": [ { - "name": "role", + "tag": "Equals", + "discriminant": 0, "type": "RoleId" + } + ] + }, + "RoleIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "RoleIdPredicateAtom" }, { - "name": "permission", - "type": "Permission" + "tag": "Name", + "discriminant": 1, + "type": "NameProjection" } ] }, - "Schedule": { - "Struct": [ + "RoleIdProjection": { + "Enum": [ { - "name": "start_ms", - "type": "u64" + "tag": "Atom", + "discriminant": 0 }, { - "name": "period_ms", - "type": "Option" + "tag": "Name", + "discriminant": 1, + "type": "NameProjection" } ] }, - "SemiInterval": { + "RolePermissionChanged": { "Struct": [ { - "name": "start", - "type": "Numeric" + "name": "role", + "type": "RoleId" }, { - "name": "limit", - "type": "Numeric" + "name": "permission", + "type": "Permission" } ] }, - "SemiInterval": { - "Struct": [ + "RolePredicateAtom": { + "Enum": [] + }, + "RoleProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "RolePredicateAtom" + }, + { + "tag": "Id", + "discriminant": 1, + "type": "RoleIdProjection" + } + ] + }, + "RoleProjection": { + "Enum": [ { - "name": "start", - "type": "u128" + "tag": "Atom", + "discriminant": 0 }, { - "name": "limit", - "type": "u128" + "tag": "Id", + "discriminant": 1, + "type": "RoleIdProjection" } ] }, - "SemiRange": { - "Enum": [ + "Schedule": { + "Struct": [ { - "tag": "Numeric", - "discriminant": 0, - "type": "SemiInterval" + "name": "start_ms", + "type": "u64" + }, + { + "name": "period_ms", + "type": "Option" } ] }, + "SelectorTuple": "Vec>", + "SelectorTuple": "Vec>", + "SelectorTuple": "Vec>", + "SelectorTuple": "Vec>", + "SelectorTuple": "Vec>", + "SelectorTuple": "Vec>", + "SelectorTuple": "Vec>", + "SelectorTuple": "Vec>", + "SelectorTuple": "Vec>", + "SelectorTuple": "Vec>", + "SelectorTuple": "Vec>", + "SelectorTuple": "Vec>", + "SelectorTuple": "Vec>", "SetKeyValue": { "Struct": [ { @@ -3567,7 +4653,7 @@ }, { "name": "value", - "type": "JsonString" + "type": "Json" } ] }, @@ -3583,7 +4669,7 @@ }, { "name": "value", - "type": "JsonString" + "type": "Json" } ] }, @@ -3599,7 +4685,7 @@ }, { "name": "value", - "type": "JsonString" + "type": "Json" } ] }, @@ -3615,7 +4701,7 @@ }, { "name": "value", - "type": "JsonString" + "type": "Json" } ] }, @@ -3631,7 +4717,7 @@ }, { "name": "value", - "type": "JsonString" + "type": "Json" } ] }, @@ -3674,7 +4760,7 @@ ] }, "SignatureOf": "Signature", - "SignatureOf": "Signature", + "SignatureOf": "Signature", "SignatureOf": "Signature", "SignedBlock": { "Enum": [ @@ -3685,6 +4771,36 @@ } ] }, + "SignedBlockPredicateAtom": { + "Enum": [] + }, + "SignedBlockProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "SignedBlockPredicateAtom" + }, + { + "tag": "Header", + "discriminant": 1, + "type": "BlockHeaderProjection" + } + ] + }, + "SignedBlockProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Header", + "discriminant": 1, + "type": "BlockHeaderProjection" + } + ] + }, "SignedBlockV1": { "Struct": [ { @@ -3694,6 +4810,10 @@ { "name": "payload", "type": "BlockPayload" + }, + { + "name": "errors", + "type": "SortedMap" } ] }, @@ -3714,7 +4834,7 @@ }, { "name": "payload", - "type": "ClientQueryPayload" + "type": "QueryRequestWithAuthority" } ] }, @@ -3727,6 +4847,46 @@ } ] }, + "SignedTransactionPredicateAtom": { + "Enum": [] + }, + "SignedTransactionProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "SignedTransactionPredicateAtom" + }, + { + "tag": "Hash", + "discriminant": 1, + "type": "TransactionHashProjection" + }, + { + "tag": "Authority", + "discriminant": 2, + "type": "AccountIdProjection" + } + ] + }, + "SignedTransactionProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Hash", + "discriminant": 1, + "type": "TransactionHashProjection" + }, + { + "tag": "Authority", + "discriminant": 2, + "type": "AccountIdProjection" + } + ] + }, "SignedTransactionV1": { "Struct": [ { @@ -3739,6 +4899,34 @@ } ] }, + "SingularQueryBox": { + "Enum": [ + { + "tag": "FindExecutorDataModel", + "discriminant": 0, + "type": "FindExecutorDataModel" + }, + { + "tag": "FindParameters", + "discriminant": 1, + "type": "FindParameters" + } + ] + }, + "SingularQueryOutputBox": { + "Enum": [ + { + "tag": "ExecutorDataModel", + "discriminant": 0, + "type": "ExecutorDataModel" + }, + { + "tag": "Parameters", + "discriminant": 1, + "type": "Parameters" + } + ] + }, "SmartContractParameter": { "Enum": [ { @@ -3820,18 +5008,33 @@ } ] }, + "SortedMap": { + "Map": { + "key": "AccountId", + "value": "u8" + } + }, "SortedMap": { "Map": { "key": "CustomParameterId", "value": "CustomParameter" } }, - "SortedMap": { + "SortedMap": { "Map": { "key": "Name", - "value": "JsonString" + "value": "Json" } }, + "SortedMap": { + "Map": { + "key": "u64", + "value": "TransactionRejectionReason" + } + }, + "SortedVec": { + "Vec": "AccountId" + }, "SortedVec": { "Vec": "Permission" }, @@ -3847,25 +5050,25 @@ ] }, "String": "String", - "StringPredicate": { + "StringPredicateAtom": { "Enum": [ { - "tag": "Contains", + "tag": "Equals", "discriminant": 0, "type": "String" }, { - "tag": "StartsWith", + "tag": "Contains", "discriminant": 1, "type": "String" }, { - "tag": "EndsWith", + "tag": "StartsWith", "discriminant": 2, "type": "String" }, { - "tag": "Is", + "tag": "EndsWith", "discriminant": 3, "type": "String" } @@ -3908,10 +5111,6 @@ }, "TimeEvent": { "Struct": [ - { - "name": "prev_interval", - "type": "Option" - }, { "name": "interval", "type": "TimeInterval" @@ -3931,6 +5130,31 @@ } ] }, + "TransactionErrorPredicateAtom": { + "Enum": [ + { + "tag": "IsSome", + "discriminant": 0 + } + ] + }, + "TransactionErrorProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "TransactionErrorPredicateAtom" + } + ] + }, + "TransactionErrorProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + } + ] + }, "TransactionEvent": { "Struct": [ { @@ -3963,6 +5187,32 @@ } ] }, + "TransactionHashPredicateAtom": { + "Enum": [ + { + "tag": "Equals", + "discriminant": 0, + "type": "HashOf" + } + ] + }, + "TransactionHashProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "TransactionHashPredicateAtom" + } + ] + }, + "TransactionHashProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + } + ] + }, "TransactionLimitError": { "Struct": [ { @@ -4029,18 +5279,6 @@ } ] }, - "TransactionQueryOutput": { - "Struct": [ - { - "name": "block_hash", - "type": "HashOf" - }, - { - "name": "transaction", - "type": "CommittedTransaction" - } - ] - }, "TransactionRejectionReason": { "Enum": [ { @@ -4321,6 +5559,42 @@ } ] }, + "TriggerIdPredicateAtom": { + "Enum": [ + { + "tag": "Equals", + "discriminant": 0, + "type": "TriggerId" + } + ] + }, + "TriggerIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "TriggerIdPredicateAtom" + }, + { + "tag": "Name", + "discriminant": 1, + "type": "NameProjection" + } + ] + }, + "TriggerIdProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Name", + "discriminant": 1, + "type": "NameProjection" + } + ] + }, "TriggerNumberOfExecutionsChanged": { "Struct": [ { @@ -4333,6 +5607,46 @@ } ] }, + "TriggerPredicateAtom": { + "Enum": [] + }, + "TriggerProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0, + "type": "TriggerPredicateAtom" + }, + { + "tag": "Id", + "discriminant": 1, + "type": "TriggerIdProjection" + }, + { + "tag": "Action", + "discriminant": 2, + "type": "ActionProjection" + } + ] + }, + "TriggerProjection": { + "Enum": [ + { + "tag": "Atom", + "discriminant": 0 + }, + { + "tag": "Id", + "discriminant": 1, + "type": "TriggerIdProjection" + }, + { + "tag": "Action", + "discriminant": 2, + "type": "ActionProjection" + } + ] + }, "TypeError": { "Enum": [ { @@ -4477,32 +5791,188 @@ } ] }, + "Vec": { + "Vec": "Account" + }, + "Vec": { + "Vec": "AccountId" + }, + "Vec>": { + "Vec": "AccountProjection" + }, + "Vec": { + "Vec": "Action" + }, + "Vec": { + "Vec": "Asset" + }, + "Vec": { + "Vec": "AssetDefinition" + }, + "Vec": { + "Vec": "AssetDefinitionId" + }, + "Vec>": { + "Vec": "AssetDefinitionProjection" + }, + "Vec": { + "Vec": "AssetId" + }, + "Vec>": { + "Vec": "AssetProjection" + }, + "Vec": { + "Vec": "AssetValue" + }, + "Vec": { + "Vec": "BlockHeader" + }, + "Vec>": { + "Vec": "BlockHeaderProjection" + }, "Vec": { "Vec": "BlockSignature" }, "Vec": { "Vec": "CommittedTransaction" }, - "Vec": { - "Vec": "EventBox" + "Vec>": { + "Vec": "CommittedTransactionProjection" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec>": { + "Vec": "CompoundPredicate" + }, + "Vec": { + "Vec": "Domain" + }, + "Vec": { + "Vec": "DomainId" + }, + "Vec>": { + "Vec": "DomainProjection" }, "Vec": { "Vec": "EventFilterBox" }, - "Vec>": { - "Vec": "GenericPredicateBox" + "Vec": { + "Vec": "GenesisWasmTrigger" + }, + "Vec>": { + "Vec": "HashOf" + }, + "Vec>": { + "Vec": "HashOf" }, "Vec": { "Vec": "InstructionBox" }, + "Vec": { + "Vec": "Json" + }, + "Vec": { + "Vec": "Metadata" + }, + "Vec": { + "Vec": "Name" + }, + "Vec": { + "Vec": "Numeric" + }, + "Vec>": { + "Vec": "Option" + }, "Vec": { "Vec": "Parameter" }, "Vec": { "Vec": "PeerId" }, - "Vec": { - "Vec": "QueryOutputBox" + "Vec>": { + "Vec": "PeerIdProjection" + }, + "Vec": { + "Vec": "Permission" + }, + "Vec>": { + "Vec": "PermissionProjection" + }, + "Vec": { + "Vec": "PublicKey" + }, + "Vec": { + "Vec": "QueryOutputBatchBox" + }, + "Vec": { + "Vec": "Role" + }, + "Vec": { + "Vec": "RoleId" + }, + "Vec>": { + "Vec": "RoleIdProjection" + }, + "Vec>": { + "Vec": "RoleProjection" + }, + "Vec": { + "Vec": "SignedBlock" + }, + "Vec>": { + "Vec": "SignedBlockProjection" + }, + "Vec": { + "Vec": "SignedTransaction" + }, + "Vec": { + "Vec": "String" + }, + "Vec": { + "Vec": "Trigger" + }, + "Vec": { + "Vec": "TriggerId" + }, + "Vec>": { + "Vec": "TriggerIdProjection" + }, + "Vec>": { + "Vec": "TriggerProjection" }, "Vec": { "Vec": "u8" @@ -4516,9 +5986,7 @@ ] }, "WasmSmartContract": "Vec", - "u128": { - "Int": "FixedWidth" - }, + "bool": "bool", "u16": { "Int": "FixedWidth" }, @@ -4531,4 +5999,4 @@ "u8": { "Int": "FixedWidth" } -} \ No newline at end of file +} diff --git a/modules/model/build.gradle b/modules/model/build.gradle index e8eba0fc6..0c859ef9c 100644 --- a/modules/model/build.gradle +++ b/modules/model/build.gradle @@ -1,3 +1,12 @@ +dependencies { + implementation "com.fasterxml.jackson.module:jackson-module-kotlin:$jacksonKotlinVer" + + // crypto + implementation "com.github.multiformats:java-multihash:$multihashVersion" + implementation "org.bouncycastle:bcprov-jdk15on:$bouncyCastleVer" + api "net.i2p.crypto:eddsa:$i2pCryptoEddsa" +} + jacocoTestReport { mustRunAfter(":admin-client:jacocoTestReport") mustRunAfter(":block:jacocoTestReport") diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Comparators.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Comparators.kt index ca4855f18..7d5e81786 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Comparators.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Comparators.kt @@ -83,7 +83,7 @@ fun SignatureOf.Companion.comparator() = Comparator> { o1, o2 -> fun Permission.Companion.comparator() = compareBy { it.name }.thenComparator { o1, o2 -> - o1.payload?.compareTo(o2.payload ?: "") ?: 0 + o1.payload.string.compareTo(o2.payload.string) } /** diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Constants.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Constants.kt similarity index 100% rename from modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Constants.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Constants.kt diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Crypto.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Crypto.kt similarity index 55% rename from modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Crypto.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Crypto.kt index 00d5af4ea..e62ad7d9d 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Crypto.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Crypto.kt @@ -27,26 +27,22 @@ enum class DigestFunction(val hashFunName: String, val index: Int) { * @throws CryptoException if key-pair cannot be generated */ @JvmOverloads -fun generateKeyPair(spec: EdDSAParameterSpec = DEFAULT_SPEC): KeyPair { - return try { - val seed = ByteArray(spec.curve.field.getb() / 8) - SecureRandom().nextBytes(seed) +fun generateKeyPair(spec: EdDSAParameterSpec = DEFAULT_SPEC): KeyPair = try { + val seed = ByteArray(spec.curve.field.getb() / 8) + SecureRandom().nextBytes(seed) - val privKey = EdDSAPrivateKeySpec(seed, spec) - val pubKey = EdDSAPublicKeySpec(privKey.a, spec) - KeyPair( - EdDSAPublicKey(pubKey), - EdDSAPrivateKey(privKey), - ) - } catch (ex: Exception) { - throw CryptoException("Cannot generate a key pair", ex) - } + val privKey = EdDSAPrivateKeySpec(seed, spec) + val pubKey = EdDSAPublicKeySpec(privKey.a, spec) + KeyPair( + EdDSAPublicKey(pubKey), + EdDSAPrivateKey(privKey), + ) +} catch (ex: Exception) { + throw CryptoException("Cannot generate a key pair", ex) } @JvmOverloads -fun generatePublicKey( - spec: EdDSAParameterSpec = DEFAULT_SPEC, -): PublicKey = generateKeyPair(spec).public.toIrohaPublicKey() +fun generatePublicKey(spec: EdDSAParameterSpec = DEFAULT_SPEC): PublicKey = generateKeyPair(spec).public.toIrohaPublicKey() /** * Create ED25519 key-pair from given hex of the public and private key @@ -54,8 +50,11 @@ fun generatePublicKey( * @throws CryptoException if key-pair cannot be created */ @JvmOverloads -fun keyPairFromHex(publicKeyHex: String, privateKeyHex: String, spec: EdDSAParameterSpec = DEFAULT_SPEC) = - KeyPair(publicKeyFromHex(publicKeyHex, spec), privateKeyFromHex(privateKeyHex, spec)) +fun keyPairFromHex( + publicKeyHex: String, + privateKeyHex: String, + spec: EdDSAParameterSpec = DEFAULT_SPEC, +) = KeyPair(publicKeyFromHex(publicKeyHex, spec), privateKeyFromHex(privateKeyHex, spec)) /** * Create ED25519 private key from a given hex @@ -63,12 +62,11 @@ fun keyPairFromHex(publicKeyHex: String, privateKeyHex: String, spec: EdDSAParam * @throws CryptoException if key cannot be created from hex */ @JvmOverloads -fun privateKeyFromHex(privateKeyHex: String, spec: EdDSAParameterSpec = DEFAULT_SPEC) = - try { - EdDSAPrivateKey(EdDSAPrivateKeySpec(privateKeyHex.fromHex(), spec)) - } catch (ex: Exception) { - throw CryptoException("Cannot create a private key from hex `$privateKeyHex`", ex) - } +fun privateKeyFromHex(privateKeyHex: String, spec: EdDSAParameterSpec = DEFAULT_SPEC) = try { + EdDSAPrivateKey(EdDSAPrivateKeySpec(privateKeyHex.fromHex(), spec)) +} catch (ex: Exception) { + throw CryptoException("Cannot create a private key from hex `$privateKeyHex`", ex) +} /** * Create ED25519 public key from a given hex @@ -76,15 +74,14 @@ fun privateKeyFromHex(privateKeyHex: String, spec: EdDSAParameterSpec = DEFAULT_ * @throws CryptoException if key cannot be created from hex */ @JvmOverloads -fun publicKeyFromHex(publicKeyHex: String, spec: EdDSAParameterSpec = DEFAULT_SPEC) = - try { - when (publicKeyHex.startsWith("ed0120")) { - true -> EdDSAPublicKey(EdDSAPublicKeySpec(publicKeyHex.drop(6).fromHex(), spec)) - false -> EdDSAPublicKey(EdDSAPublicKeySpec(publicKeyHex.fromHex(), spec)) - } - } catch (ex: Exception) { - throw CryptoException("Cannot create a public key from hex `$publicKeyHex`", ex) +fun publicKeyFromHex(publicKeyHex: String, spec: EdDSAParameterSpec = DEFAULT_SPEC) = try { + when (publicKeyHex.startsWith("ed0120")) { + true -> EdDSAPublicKey(EdDSAPublicKeySpec(publicKeyHex.drop(6).fromHex(), spec)) + false -> EdDSAPublicKey(EdDSAPublicKeySpec(publicKeyHex.fromHex(), spec)) } +} catch (ex: Exception) { + throw CryptoException("Cannot create a public key from hex `$publicKeyHex`", ex) +} /** * Return encoded representation of the key, which may be different from `java.security.Key.getEncoded()`. @@ -97,10 +94,18 @@ fun publicKeyFromHex(publicKeyHex: String, spec: EdDSAParameterSpec = DEFAULT_SP * @see java.security.Key.getFormat * @return bytes Encoding of the key (empty if encoding is not supported) */ -fun Key.bytes(): ByteArray { - return when (this) { - is EdDSAPublicKey -> abyte - is EdDSAPrivateKey -> seed - else -> this.encoded ?: ByteArray(0) - } +fun Key.bytes(): ByteArray = when (this) { + is EdDSAPublicKey -> abyte + is EdDSAPrivateKey -> seed + else -> this.encoded ?: ByteArray(0) } + +/** + * Throw if there is an exception related to cryptography + */ +class CryptoException(message: String? = null, cause: Throwable? = null) : IrohaSdkException(message, cause) + +/** + * Throw if there is an exception during hex encoding/decoding + */ +class HexCodecException(message: String? = null, cause: Throwable? = null) : IrohaSdkException(message, cause) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Exceptions.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Exceptions.kt index 36e2b2260..1a1a73eda 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Exceptions.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Exceptions.kt @@ -14,3 +14,17 @@ class ScaleCodecException(message: String? = null, cause: Throwable? = null) : I * Throw if there is an exception during conversion from or into a fixed-point number */ class FixedPointConversionException(message: String? = null, cause: Throwable? = null) : IrohaSdkException(message, cause) + +/** + * Throw if there is an issue with deserialization. + * + * @param message The explanation of the issue + */ +class DeserializationException(message: String) : RuntimeException(message) + +/** + * Throw if there is an issue with serialization + * + * @param message The explanation of the issue + */ +class SerializationException(message: String) : RuntimeException(message) diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Extensions.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Extensions.kt similarity index 64% rename from modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Extensions.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Extensions.kt index 947874311..83aa6ed43 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Extensions.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Extensions.kt @@ -1,12 +1,9 @@ +@file:Suppress("ktlint:standard:no-wildcard-imports") + package jp.co.soramitsu.iroha2 -import com.fasterxml.jackson.databind.JsonNode -import com.fasterxml.jackson.databind.node.NullNode -import com.fasterxml.jackson.databind.node.TextNode -import com.google.gson.GsonBuilder -import io.ktor.websocket.Frame -import jp.co.soramitsu.iroha2.generated.* // ktlint-disable no-wildcard-imports -import jp.co.soramitsu.iroha2.transaction.TransactionBuilder +import com.fasterxml.jackson.module.kotlin.readValue +import jp.co.soramitsu.iroha2.generated.* import net.i2p.crypto.eddsa.EdDSAEngine import org.bouncycastle.jcajce.provider.digest.Blake2b import org.bouncycastle.util.encoders.Hex @@ -15,8 +12,6 @@ import java.math.BigInteger import java.security.MessageDigest import java.security.PrivateKey import java.security.PublicKey -import java.util.Locale -import java.util.StringTokenizer import kotlin.experimental.or import jp.co.soramitsu.iroha2.generated.PublicKey as IrohaPublicKey @@ -58,8 +53,6 @@ fun String.asRoleId() = RoleId(Name(this)) fun String.asName() = Name(this) -fun ByteArray.toFrame(fin: Boolean = true) = Frame.Binary(fin, this) - fun ByteArray.toHex(withPrefix: Boolean = false): String = try { val prefix = when (withPrefix) { true -> "ed0120" @@ -79,16 +72,14 @@ fun String.fromHex(): ByteArray = try { /** * Convert a public key to an Iroha public key */ -fun PublicKey.toIrohaPublicKey(): IrohaPublicKey { - return IrohaPublicKey(Algorithm.Ed25519(), this.bytes()) -} +fun PublicKey.toIrohaPublicKey(): IrohaPublicKey = IrohaPublicKey(Algorithm.Ed25519(), this.bytes()) /** * Sign the [message] using the given private key * * Note: the message must not be prehashed */ -fun PrivateKey.sign(message: ByteArray): ByteArray = try { +fun PrivateKey.signAs(message: ByteArray): ByteArray = try { val sgr = EdDSAEngine(MessageDigest.getInstance(DEFAULT_SPEC.hashAlgorithm)) sgr.initSign(this) sgr.update(message.hash()) @@ -134,38 +125,30 @@ fun SignedTransaction.hash() = SignedTransaction.encode(this).hash() /** * Cast to another type */ -inline fun Any.cast(): B { - return this as? B - ?: throw ClassCastException("Could not cast `${this::class.qualifiedName}` to `${B::class.qualifiedName}`") -} +inline fun Any.cast(): B = this as? B + ?: throw ClassCastException("Could not cast `${this::class.qualifiedName}` to `${B::class.qualifiedName}`") fun AssetId.asString(withPrefix: Boolean = true) = this.definition.asString() + ASSET_ID_DELIMITER + this.account.asString(withPrefix) -fun AssetId.asJsonString(withPrefix: Boolean = true) = "{\"asset\": " + - "\"${this.definition.asString() + ASSET_ID_DELIMITER + this.account.asString(withPrefix)}\"}" - fun AssetDefinitionId.asString() = this.name.string + ASSET_ID_DELIMITER + this.domain.name.string -fun AssetDefinitionId.asJsonString() = "{\"asset_definition\": " + - "\"${this.name.string + ASSET_ID_DELIMITER + this.domain.name.string}\"}" - fun AccountId.asString(withPrefix: Boolean = true) = this.signatory.payload.toHex(withPrefix) + ACCOUNT_ID_DELIMITER + this.domain.name.string -fun AccountId.asJsonString(withPrefix: Boolean = true) = "{\"account\": \"${this.signatory.payload.toHex(withPrefix) + ACCOUNT_ID_DELIMITER + this.domain.name.string}\"}" - -fun DomainId.asString() = this.name.string +inline fun Json.readValue(): T = JSON_SERDE.readValue(this.string) +fun Json.Companion.writeValue(value: V): Json { + val value = JSON_SERDE.writeValueAsString(value) -fun DomainId.asJsonString() = "{\"domain\": \"${this.name.string}\"}" + if (value == "{ }") { + return Json("null") + } -fun RoleId.asString() = this.name.string + return Json(value) +} -fun RoleId.asJsonString() = "{\"role\": \"${this.name.string}\"}" +fun DomainId.asString() = this.name.string -fun String.fromJsonString() = when { - this.startsWith("\"") && this.endsWith("\"") -> this.drop(1).dropLast(1) - else -> this -} +fun RoleId.asString() = this.name.string fun SocketAddr.asString() = when (this) { is SocketAddr.Host -> this.socketAddrHost.let { "${it.host}:${it.port}" } @@ -179,21 +162,9 @@ fun Metadata.merge(extra: Metadata) = Metadata( this.sortedMapOfName.toMutableMap().also { it.putAll(extra.sortedMapOfName) }, ) -fun InstructionBox.Register.extractBox() = when (this.registerBox.discriminant()) { - 0 -> this.registerBox.cast() as RegisterBox - 1 -> this.registerBox.cast() as RegisterBox - 2 -> this.registerBox.cast() as RegisterBox - 3 -> this.registerBox.cast() as RegisterBox - 4 -> this.registerBox.cast() as RegisterBox - 5 -> this.registerBox.cast() as RegisterBox - 6 -> this.registerBox.cast() as RegisterBox - else -> null -} - fun Iterable.extractRegisterBoxes() = this.asSequence() .filterIsInstance() .map { it.registerBox } - fun IdBox.extractId(): Any = when (this) { is IdBox.RoleId -> this.roleId is IdBox.AccountId -> this.accountId @@ -271,18 +242,12 @@ fun BlockPayload.height() = this.header.height fun Asset.metadata() = this.value.cast().metadata.sortedMapOfName -fun TransactionBuilder.merge(other: TransactionBuilder) = this.instructions.value.addAll(other.instructions.value) - fun String.toSocketAddr() = this.split(":").let { parts -> if (parts.size != 2) throw IrohaSdkException("Incorrect address") SocketAddr.Host(SocketAddrHost(parts.first(), parts.last().toInt())) } -fun String.replace(oldValue: String) = this.replace(oldValue, "") - -fun String.replace(regex: Regex) = this.replace(regex, "") - fun FindError.extract() = when (this) { is FindError.Account -> this.accountId.asString() is FindError.Asset -> this.assetId.asString() @@ -291,46 +256,13 @@ fun FindError.extract() = when (this) { is FindError.Role -> this.roleId.asString() is FindError.Block -> this.hashOf.hash.arrayOfU8.toHex() is FindError.MetadataKey -> this.name.string - is FindError.Peer -> this.peerId.address.toString() + is FindError.Peer -> this.peerId.toString() is FindError.Permission -> this.permission.name is FindError.PublicKey -> this.publicKey.payload.toString() is FindError.Trigger -> this.triggerId.asString() is FindError.Transaction -> this.hashOf.hash.arrayOfU8.toHex() } -fun String.toCamelCase(name: String): String { - val tokenizer = StringTokenizer(name, "_") - return if (tokenizer.hasMoreTokens()) { - val resultBuilder = StringBuilder(tokenizer.nextToken()) - for (token in tokenizer) { - resultBuilder.append((token as String).replaceFirstChar(Char::uppercase)) - } - resultBuilder.toString() - } else { - name - } -} - -fun String.toCamelCase() = this.lowercase(Locale.getDefault()) - .split(" ", "_") - .withIndex() - .joinToString("") { value -> - when (value.index) { - 0 -> value.value - else -> value.value.replaceFirstChar { - when (it.isLowerCase()) { - true -> it.titlecase(Locale.getDefault()) - else -> it.toString() - } - } - } - } - -fun String.toSnakeCase() = this - .split("(?<=.)(?=\\p{Lu})|\\s".toRegex()) - .joinToString("_") - .lowercase(Locale.getDefault()) - fun Number.asNumeric() = when (this) { is Int -> this.asNumeric() is Long -> this.asNumeric() @@ -368,23 +300,56 @@ fun Numeric.asNumber() = when (this.scale) { fun Numeric.asString() = this.asNumber().toString() fun AssetType.Companion.numeric(scale: Long? = null) = AssetType.Numeric(NumericSpec(scale)) - -fun Metadata.getStringValue(key: String) = this.sortedMapOfName[key.asName()] - -fun Metadata.getBooleanValue(key: String) = this.sortedMapOfName[key.asName()] - -fun Metadata.getNameValue(key: String) = this.sortedMapOfName[key.asName()] - -fun Metadata.getFixedValue(key: String) = this.sortedMapOfName[key.asName()] - -fun JsonNode.asStringOrNull() = when (this) { - is NullNode -> null - is TextNode -> this.asText() - else -> this.toString() -} - -fun String.asPrettyJson(): String { - val gson = GsonBuilder().setPrettyPrinting().create() - val jsonElement = com.google.gson.JsonParser.parseString(this) - return gson.toJson(jsonElement) -} +fun RegisterOfPeer.asInstructionBoxExt() = InstructionBox.Register(RegisterBox.Peer(this)) +fun RegisterOfDomain.asInstructionBoxExt() = InstructionBox.Register(RegisterBox.Domain(this)) +fun RegisterOfAssetDefinition.asInstructionBoxExt() = InstructionBox.Register(RegisterBox.AssetDefinition(this)) +fun RegisterOfAccount.asInstructionBoxExt() = InstructionBox.Register(RegisterBox.Account(this)) +fun RegisterOfAsset.asInstructionBoxExt() = InstructionBox.Register(RegisterBox.Asset(this)) +fun RegisterOfRole.asInstructionBoxExt() = InstructionBox.Register(RegisterBox.Role(this)) +fun RegisterOfTrigger.asInstructionBoxExt() = InstructionBox.Register(RegisterBox.Trigger(this)) + +fun UnregisterOfPeer.asInstructionBoxExt() = InstructionBox.Unregister(UnregisterBox.Peer(this)) +fun UnregisterOfDomain.asInstructionBoxExt() = InstructionBox.Unregister(UnregisterBox.Domain(this)) +fun UnregisterOfAssetDefinition.asInstructionBoxExt() = InstructionBox.Unregister(UnregisterBox.AssetDefinition(this)) +fun UnregisterOfAccount.asInstructionBoxExt() = InstructionBox.Unregister(UnregisterBox.Account(this)) +fun UnregisterOfAsset.asInstructionBoxExt() = InstructionBox.Unregister(UnregisterBox.Asset(this)) +fun UnregisterOfRole.asInstructionBoxExt() = InstructionBox.Unregister(UnregisterBox.Role(this)) +fun UnregisterOfTrigger.asInstructionBoxExt() = InstructionBox.Unregister(UnregisterBox.Trigger(this)) + +fun SetKeyValueOfDomain.asInstructionBoxExt() = InstructionBox.SetKeyValue(SetKeyValueBox.Domain(this)) +fun SetKeyValueOfAssetDefinition.asInstructionBoxExt() = InstructionBox.SetKeyValue(SetKeyValueBox.AssetDefinition(this)) +fun SetKeyValueOfAccount.asInstructionBoxExt() = InstructionBox.SetKeyValue(SetKeyValueBox.Account(this)) +fun SetKeyValueOfAsset.asInstructionBoxExt() = InstructionBox.SetKeyValue(SetKeyValueBox.Asset(this)) +fun SetKeyValueOfTrigger.asInstructionBoxExt() = InstructionBox.SetKeyValue(SetKeyValueBox.Trigger(this)) + +fun RemoveKeyValueOfDomain.asInstructionBoxExt() = InstructionBox.RemoveKeyValue(RemoveKeyValueBox.Domain(this)) +fun RemoveKeyValueOfAssetDefinition.asInstructionBoxExt() = InstructionBox.RemoveKeyValue(RemoveKeyValueBox.AssetDefinition(this)) +fun RemoveKeyValueOfAccount.asInstructionBoxExt() = InstructionBox.RemoveKeyValue(RemoveKeyValueBox.Account(this)) +fun RemoveKeyValueOfAsset.asInstructionBoxExt() = InstructionBox.RemoveKeyValue(RemoveKeyValueBox.Asset(this)) +fun RemoveKeyValueOfTrigger.asInstructionBoxExt() = InstructionBox.RemoveKeyValue(RemoveKeyValueBox.Trigger(this)) + +fun MintOfNumericAndAsset.asInstructionBoxExt() = InstructionBox.Mint(MintBox.Asset(this)) +fun MintOfu32AndTrigger.asInstructionBoxExt() = InstructionBox.Mint(MintBox.TriggerRepetitions(this)) + +fun BurnOfNumericAndAsset.asInstructionBoxExt() = InstructionBox.Burn(BurnBox.Asset(this)) +fun BurnOfu32AndTrigger.asInstructionBoxExt() = InstructionBox.Burn(BurnBox.TriggerRepetitions(this)) + +fun TransferOfAccountAndDomainIdAndAccount.asInstructionBoxExt() = InstructionBox.Transfer(TransferBox.Domain(this)) +fun TransferOfAccountAndAssetDefinitionIdAndAccount.asInstructionBoxExt() = InstructionBox.Transfer(TransferBox.AssetDefinition(this)) +fun TransferOfAssetAndNumericAndAccount.asInstructionBoxExt() = InstructionBox.Transfer(TransferBox.Asset(AssetTransferBox.Numeric(this))) +fun TransferOfAssetAndMetadataAndAccount.asInstructionBoxExt() = InstructionBox.Transfer(TransferBox.Asset(AssetTransferBox.Store(this))) + +fun GrantOfPermissionAndAccount.asInstructionBoxExt() = InstructionBox.Grant(GrantBox.Permission(this)) +fun GrantOfRoleIdAndAccount.asInstructionBoxExt() = InstructionBox.Grant(GrantBox.Role(this)) +fun GrantOfPermissionAndRole.asInstructionBoxExt() = InstructionBox.Grant(GrantBox.RolePermission(this)) + +fun RevokeOfPermissionAndAccount.asInstructionBoxExt() = InstructionBox.Revoke(RevokeBox.Permission(this)) +fun RevokeOfRoleIdAndAccount.asInstructionBoxExt() = InstructionBox.Revoke(RevokeBox.Role(this)) +fun RevokeOfPermissionAndRole.asInstructionBoxExt() = InstructionBox.Revoke(RevokeBox.RolePermission(this)) + +fun ExecuteTrigger.asInstructionBoxExt() = InstructionBox.ExecuteTrigger(this) + +fun Upgrade.asInstructionBoxExt() = InstructionBox.Upgrade(this) +fun SetParameter.asInstructionBoxExt() = InstructionBox.SetParameter(this) + +fun I.asInstructionBoxExt() = InstructionBox.Custom(CustomInstruction(Json.writeValue(this))) \ No newline at end of file diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/ModelCustomInstruction.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/ModelCustomInstruction.kt new file mode 100644 index 000000000..9fa93a97b --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/ModelCustomInstruction.kt @@ -0,0 +1,3 @@ +package jp.co.soramitsu.iroha2 + +interface ModelCustomInstruction \ No newline at end of file diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/ModelParameter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/ModelParameter.kt new file mode 100644 index 000000000..f50a0ed85 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/ModelParameter.kt @@ -0,0 +1,3 @@ +package jp.co.soramitsu.iroha2 + +interface ModelParameter \ No newline at end of file diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/ModelPermission.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/ModelPermission.kt new file mode 100644 index 000000000..9976c4384 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/ModelPermission.kt @@ -0,0 +1,11 @@ +package jp.co.soramitsu.iroha2 + +import jp.co.soramitsu.iroha2.generated.Json +import jp.co.soramitsu.iroha2.generated.Permission + +/** + * Permission + */ +interface ModelPermission { + fun asRaw(): Permission = Permission(this.javaClass.simpleName, Json.writeValue(this)) +} diff --git a/modules/block/src/main/kotlin/jp/co/soramitsu/iroha2/Serde.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Serde.kt similarity index 66% rename from modules/block/src/main/kotlin/jp/co/soramitsu/iroha2/Serde.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Serde.kt index 6e2487cd2..819fe9b21 100644 --- a/modules/block/src/main/kotlin/jp/co/soramitsu/iroha2/Serde.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Serde.kt @@ -2,6 +2,7 @@ package jp.co.soramitsu.iroha2 import com.fasterxml.jackson.core.JsonGenerator import com.fasterxml.jackson.core.JsonParser +import com.fasterxml.jackson.core.type.TypeReference import com.fasterxml.jackson.databind.DeserializationContext import com.fasterxml.jackson.databind.JsonDeserializer import com.fasterxml.jackson.databind.JsonNode @@ -15,7 +16,6 @@ import com.fasterxml.jackson.databind.module.SimpleModule import com.fasterxml.jackson.databind.node.LongNode import com.fasterxml.jackson.databind.node.ObjectNode import com.fasterxml.jackson.databind.node.TextNode -import com.fasterxml.jackson.module.kotlin.KotlinFeature import com.fasterxml.jackson.module.kotlin.KotlinModule import io.ipfs.multihash.Multihash import jp.co.soramitsu.iroha2.DigestFunction.Ed25519 @@ -28,18 +28,16 @@ import jp.co.soramitsu.iroha2.generated.AssetId import jp.co.soramitsu.iroha2.generated.AssetTransferBox import jp.co.soramitsu.iroha2.generated.AssetType import jp.co.soramitsu.iroha2.generated.AssetValue -import jp.co.soramitsu.iroha2.generated.BlockHeader import jp.co.soramitsu.iroha2.generated.BlockParameter import jp.co.soramitsu.iroha2.generated.BurnBox import jp.co.soramitsu.iroha2.generated.BurnOfNumericAndAsset import jp.co.soramitsu.iroha2.generated.BurnOfu32AndTrigger import jp.co.soramitsu.iroha2.generated.ChainId -import jp.co.soramitsu.iroha2.generated.CustomInstruction import jp.co.soramitsu.iroha2.generated.CustomParameter +import jp.co.soramitsu.iroha2.generated.CustomParameterId import jp.co.soramitsu.iroha2.generated.DomainId import jp.co.soramitsu.iroha2.generated.EventFilterBox import jp.co.soramitsu.iroha2.generated.Executable -import jp.co.soramitsu.iroha2.generated.ExecuteTrigger import jp.co.soramitsu.iroha2.generated.ExecuteTriggerEventFilter import jp.co.soramitsu.iroha2.generated.ExecutionTime import jp.co.soramitsu.iroha2.generated.Executor @@ -47,14 +45,10 @@ import jp.co.soramitsu.iroha2.generated.GrantBox import jp.co.soramitsu.iroha2.generated.GrantOfPermissionAndAccount import jp.co.soramitsu.iroha2.generated.GrantOfPermissionAndRole import jp.co.soramitsu.iroha2.generated.GrantOfRoleIdAndAccount -import jp.co.soramitsu.iroha2.generated.Hash import jp.co.soramitsu.iroha2.generated.IdBox -import jp.co.soramitsu.iroha2.generated.IdentifiableBox import jp.co.soramitsu.iroha2.generated.InstructionBox import jp.co.soramitsu.iroha2.generated.IpfsPath -import jp.co.soramitsu.iroha2.generated.Ipv4Addr -import jp.co.soramitsu.iroha2.generated.Ipv6Addr -import jp.co.soramitsu.iroha2.generated.Log +import jp.co.soramitsu.iroha2.generated.Json import jp.co.soramitsu.iroha2.generated.Metadata import jp.co.soramitsu.iroha2.generated.MintBox import jp.co.soramitsu.iroha2.generated.MintOfNumericAndAsset @@ -64,6 +58,7 @@ import jp.co.soramitsu.iroha2.generated.Name import jp.co.soramitsu.iroha2.generated.NewAccount import jp.co.soramitsu.iroha2.generated.NewAssetDefinition import jp.co.soramitsu.iroha2.generated.NewDomain +import jp.co.soramitsu.iroha2.generated.NewRole import jp.co.soramitsu.iroha2.generated.NonZeroOfu64 import jp.co.soramitsu.iroha2.generated.Numeric import jp.co.soramitsu.iroha2.generated.NumericSpec @@ -71,7 +66,6 @@ import jp.co.soramitsu.iroha2.generated.Parameter import jp.co.soramitsu.iroha2.generated.Peer import jp.co.soramitsu.iroha2.generated.Permission import jp.co.soramitsu.iroha2.generated.PublicKey -import jp.co.soramitsu.iroha2.generated.RawGenesisTransaction import jp.co.soramitsu.iroha2.generated.RegisterBox import jp.co.soramitsu.iroha2.generated.RegisterOfAccount import jp.co.soramitsu.iroha2.generated.RegisterOfAsset @@ -80,9 +74,7 @@ import jp.co.soramitsu.iroha2.generated.RegisterOfDomain import jp.co.soramitsu.iroha2.generated.RegisterOfPeer import jp.co.soramitsu.iroha2.generated.RegisterOfRole import jp.co.soramitsu.iroha2.generated.RegisterOfTrigger -import jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox import jp.co.soramitsu.iroha2.generated.Repeats -import jp.co.soramitsu.iroha2.generated.RevokeBox import jp.co.soramitsu.iroha2.generated.Role import jp.co.soramitsu.iroha2.generated.RoleId import jp.co.soramitsu.iroha2.generated.Schedule @@ -92,25 +84,19 @@ import jp.co.soramitsu.iroha2.generated.SetKeyValueOfAsset import jp.co.soramitsu.iroha2.generated.SetKeyValueOfAssetDefinition import jp.co.soramitsu.iroha2.generated.SetKeyValueOfDomain import jp.co.soramitsu.iroha2.generated.SetKeyValueOfTrigger -import jp.co.soramitsu.iroha2.generated.SetParameter -import jp.co.soramitsu.iroha2.generated.SignedBlock import jp.co.soramitsu.iroha2.generated.SmartContractParameter import jp.co.soramitsu.iroha2.generated.SocketAddr import jp.co.soramitsu.iroha2.generated.SumeragiParameter import jp.co.soramitsu.iroha2.generated.TimeEventFilter import jp.co.soramitsu.iroha2.generated.TransactionParameter -import jp.co.soramitsu.iroha2.generated.TransactionQueryOutput import jp.co.soramitsu.iroha2.generated.TransferBox import jp.co.soramitsu.iroha2.generated.TransferOfAccountAndAssetDefinitionIdAndAccount import jp.co.soramitsu.iroha2.generated.TransferOfAccountAndDomainIdAndAccount import jp.co.soramitsu.iroha2.generated.Trigger import jp.co.soramitsu.iroha2.generated.TriggerId -import jp.co.soramitsu.iroha2.generated.UnregisterBox -import jp.co.soramitsu.iroha2.generated.Upgrade import jp.co.soramitsu.iroha2.generated.WasmSmartContract import java.io.ByteArrayOutputStream import java.math.BigInteger -import kotlin.reflect.KClass import kotlin.reflect.full.memberProperties import kotlin.reflect.full.primaryConstructor @@ -124,7 +110,6 @@ public val JSON_SERDE by lazy { // deserializers module.addDeserializer(AssetValue::class.java, AssetValueDeserializer) module.addDeserializer(PublicKey::class.java, PublicKeyDeserializer) - module.addDeserializer(IdBox::class.java, IdBoxDeserializer) module.addDeserializer(Name::class.java, NameDeserializer) module.addDeserializer(Mintable::class.java, MintableDeserializer) module.addDeserializer(DomainId::class.java, DomainIdDeserializer) @@ -135,8 +120,8 @@ public val JSON_SERDE by lazy { module.addDeserializer(RegisterBox::class.java, RegisterBoxDeserializer) module.addDeserializer(MintBox::class.java, MintBoxDeserializer) module.addDeserializer(Metadata::class.java, MetadataDeserializer) - module.addDeserializer(TriggerId::class.java, TriggerIdDeserializer) module.addDeserializer(InstructionBox::class.java, InstructionDeserializer) + module.addDeserializer(TriggerId::class.java, TriggerIdDeserializer) module.addDeserializer(GrantBox::class.java, GrantBoxDeserializer) module.addDeserializer(EventFilterBox::class.java, EventFilterBoxDeserializer) module.addDeserializer(SetKeyValueBox::class.java, SetKeyValueBoxDeserializer) @@ -149,6 +134,7 @@ public val JSON_SERDE by lazy { module.addDeserializer(ExecuteTriggerEventFilter::class.java, ExecuteTriggerEventFilterDeserializer) module.addDeserializer(Action::class.java, ActionDeserializer) module.addDeserializer(Executable::class.java, ExecutableDeserializer) + module.addDeserializer(Json::class.java, IrohaJsonDeserializer) module.addDeserializer(IpfsPath::class.java, IpfsPathDeserializer) module.addDeserializer(Repeats::class.java, RepeatsDeserializer) module.addDeserializer(Parameter::class.java, ParameterDeserializer) @@ -163,15 +149,18 @@ public val JSON_SERDE by lazy { module.addDeserializer(Numeric::class.java, NumericDeserializer) module.addDeserializer(Permission::class.java, PermissionDeserializer) module.addDeserializer(BurnBox::class.java, BurnBoxDeserializer) + module.addDeserializer(NonZeroOfu64::class.java, NonZeroOfu64Deserializer) + module.addDeserializer(NewRole::class.java, NewRoleDeserializer) module.addKeyDeserializer(AssetDefinitionId::class.java, AssetDefinitionIdKeyDeserializer) module.addKeyDeserializer(AccountId::class.java, AccountIdKeyDeserializer) module.addKeyDeserializer(AssetId::class.java, AssetIdKeyDeserializer) module.addKeyDeserializer(DomainId::class.java, DomainIdKeyDeserializer) + module.addKeyDeserializer(CustomParameterId::class.java, CustomParameterIdKeyDeserializer) // serializers - module.addKeySerializer(Name::class.java, NameAsKeySerializer) - module.addSerializer(RawGenesisTransaction::class.java, RawGenesisTransactionSerializer) + module.addSerializer(Metadata::class.java, MetadataSerializer) + module.addSerializer(ChainId::class.java, ChainIdSerializer) module.addSerializer(DomainId::class.java, DomainIdSerializer) module.addSerializer(AssetDefinitionId::class.java, AssetDefinitionIdSerializer) module.addSerializer(AccountId::class.java, AccountIdSerializer) @@ -183,13 +172,10 @@ public val JSON_SERDE by lazy { module.addSerializer(UInt::class.java, UIntSerializer) module.addSerializer(PublicKey::class.java, PublicKeySerializer) module.addSerializer(ModelEnum::class.java, EnumerationSerializer) - module.addSerializer(Metadata::class.java, MetadataSerializer) - module.addSerializer(IdentifiableBox.NewRole::class.java, IdentifiableBoxNewRoleSerializer) module.addSerializer(Parameter::class.java, ParameterSerializer) module.addSerializer(TimeEventFilter::class.java, TimeEventFilterSerializer) module.addSerializer(Schedule::class.java, ScheduleSerializer) module.addSerializer(Executor::class.java, ExecutorSerializer) - module.addSerializer(InstructionBox::class.java, InstructionBoxSerializer) module.addSerializer(RegisterOfDomain::class.java, RegisterOfDomainSerializer) module.addSerializer(RegisterOfTrigger::class.java, RegisterOfTriggerSerializer) module.addSerializer(RegisterOfRole::class.java, RegisterOfRoleSerializer) @@ -197,6 +183,7 @@ public val JSON_SERDE by lazy { module.addSerializer(RegisterOfAssetDefinition::class.java, RegisterOfAssetDefinitionSerializer) module.addSerializer(RegisterOfPeer::class.java, RegisterOfPeerSerializer) module.addSerializer(RegisterOfAccount::class.java, RegisterOfAccountSerializer) + module.addSerializer(NewRole::class.java, NewRoleSerializer) module.addSerializer(AssetTransferBox::class.java, AssetTransferBoxSerializer) module.addSerializer(NonZeroOfu64::class.java, NonZeroOfu64Serializer) module.addSerializer(Executable.Instructions::class.java, ExecutableInstructionsSerializer) @@ -204,14 +191,10 @@ public val JSON_SERDE by lazy { module.addSerializer(AssetType::class.java, AssetTypeSerializer) module.addSerializer(Numeric::class.java, NumericSerializer) module.addSerializer(Permission::class.java, PermissionSerializer) + module.addSerializer(Json::class.java, IrohaJsonSerializer) mapper.registerModule(module) - mapper.registerModule( - KotlinModule.Builder() - .configure(KotlinFeature.NullToEmptyCollection, true) - .configure(KotlinFeature.NullToEmptyMap, true) - .build(), - ) + mapper.registerModule(KotlinModule.Builder().build()) mapper.propertyNamingStrategy = PropertyNamingStrategies.SNAKE_CASE mapper.enable(SerializationFeature.INDENT_OUTPUT) } @@ -221,9 +204,8 @@ public val JSON_SERDE by lazy { * Deserializer for [Iroha Special Instructions][InstructionBox] */ object InstructionDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): InstructionBox { - return deserializeInstruction(p.readValueAsTree(), JSON_SERDE) - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): InstructionBox = + deserializeInstruction(p.readValueAsTree(), JSON_SERDE) private fun deserializeInstruction(jsonNode: JsonNode, mapper: ObjectMapper): InstructionBox { val node = jsonNode.fields().next() @@ -252,22 +234,18 @@ object GrantBoxDeserializer : JsonDeserializer() { return get(JSON_SERDE.convertValue(node.fields().next().value, paramClass)) } - private fun String.toArg(): Class<*> { - return when (this) { - "Permission" -> GrantOfPermissionAndAccount::class.java - "Role" -> GrantOfRoleIdAndAccount::class.java - "RolePermission" -> GrantOfPermissionAndRole::class.java - else -> throw DeserializationException("Unknown type: $this") - } + private fun String.toArg(): Class<*> = when (this) { + "Permission" -> GrantOfPermissionAndAccount::class.java + "Role" -> GrantOfRoleIdAndAccount::class.java + "RolePermission" -> GrantOfPermissionAndRole::class.java + else -> throw DeserializationException("Unknown type: $this") } - private fun get(arg: Any): GrantBox { - return when (arg) { - is GrantOfPermissionAndAccount -> GrantBox.Permission(arg) - is GrantOfRoleIdAndAccount -> GrantBox.Role(arg) - is GrantOfPermissionAndRole -> GrantBox.RolePermission(arg) - else -> throw DeserializationException("Grant box `$arg` not found") - } + private fun get(arg: Any): GrantBox = when (arg) { + is GrantOfPermissionAndAccount -> GrantBox.Permission(arg) + is GrantOfRoleIdAndAccount -> GrantBox.Role(arg) + is GrantOfPermissionAndRole -> GrantBox.RolePermission(arg) + else -> throw DeserializationException("Grant box `$arg` not found") } } @@ -285,9 +263,7 @@ object AssetValueDeserializer : JsonDeserializer() { * Deserializer for [IdBox] */ object IdBoxDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): IdBox { - return sealedDeserializeIdBox(p, JSON_SERDE) - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): IdBox = sealedDeserializeIdBox(p, JSON_SERDE) } object RegisterBoxDeserializer : JsonDeserializer() { @@ -300,30 +276,26 @@ object RegisterBoxDeserializer : JsonDeserializer() { return getRegisterBox(value) } - private fun String.toArg(): Class<*> { - return when (this) { - "Domain" -> NewDomain::class.java - "Peer" -> Peer::class.java - "Account" -> NewAccount::class.java - "AssetDefinition" -> NewAssetDefinition::class.java - "Asset" -> Asset::class.java - "Trigger" -> Trigger::class.java - "Role" -> Role::class.java - else -> throw DeserializationException("Unknown string type: $this") - } + private fun String.toArg(): Class<*> = when (this) { + "Domain" -> NewDomain::class.java + "Peer" -> Peer::class.java + "Account" -> NewAccount::class.java + "AssetDefinition" -> NewAssetDefinition::class.java + "Asset" -> Asset::class.java + "Trigger" -> Trigger::class.java + "Role" -> NewRole::class.java + else -> throw DeserializationException("Unknown string type: $this") } - private fun getRegisterBox(arg: Any): RegisterBox { - return when (arg) { - is NewDomain -> RegisterBox.Domain(RegisterOfDomain(arg)) - is NewAccount -> RegisterBox.Account(RegisterOfAccount(arg)) - is Peer -> RegisterBox.Peer(RegisterOfPeer(arg)) - is NewAssetDefinition -> RegisterBox.AssetDefinition(RegisterOfAssetDefinition(arg)) - is Asset -> RegisterBox.Asset(RegisterOfAsset(arg)) - is Trigger -> RegisterBox.Trigger(RegisterOfTrigger(arg)) - is Role -> RegisterBox.Role(RegisterOfRole(arg)) - else -> throw DeserializationException("Register box `$arg` not found") - } + private fun getRegisterBox(arg: Any): RegisterBox = when (arg) { + is NewDomain -> RegisterBox.Domain(RegisterOfDomain(arg)) + is NewAccount -> RegisterBox.Account(RegisterOfAccount(arg)) + is Peer -> RegisterBox.Peer(RegisterOfPeer(arg.id)) + is NewAssetDefinition -> RegisterBox.AssetDefinition(RegisterOfAssetDefinition(arg)) + is Asset -> RegisterBox.Asset(RegisterOfAsset(arg)) + is Trigger -> RegisterBox.Trigger(RegisterOfTrigger(arg)) + is NewRole -> RegisterBox.Role(RegisterOfRole(arg)) + else -> throw DeserializationException("Register box `$arg` not found") } } @@ -338,20 +310,16 @@ object BurnBoxDeserializer : JsonDeserializer() { return get(JSON_SERDE.convertValue(node.fields().next().value, paramClass)) } - private fun String.toArg(): Class<*> { - return when (this) { - "Asset" -> BurnOfNumericAndAsset::class.java - "TriggerRepetitions" -> BurnOfu32AndTrigger::class.java - else -> throw DeserializationException("Unknown type: $this") - } + private fun String.toArg(): Class<*> = when (this) { + "Asset" -> BurnOfNumericAndAsset::class.java + "TriggerRepetitions" -> BurnOfu32AndTrigger::class.java + else -> throw DeserializationException("Unknown type: $this") } - private fun get(arg: Any): BurnBox { - return when (arg) { - is BurnOfNumericAndAsset -> BurnBox.Asset(arg) - is BurnOfu32AndTrigger -> BurnBox.TriggerRepetitions(arg) - else -> throw DeserializationException("Burn box `$arg` not found") - } + private fun get(arg: Any): BurnBox = when (arg) { + is BurnOfNumericAndAsset -> BurnBox.Asset(arg) + is BurnOfu32AndTrigger -> BurnBox.TriggerRepetitions(arg) + else -> throw DeserializationException("Burn box `$arg` not found") } } @@ -363,20 +331,16 @@ object MintBoxDeserializer : JsonDeserializer() { return get(JSON_SERDE.convertValue(node.fields().next().value, paramClass)) } - private fun String.toArg(): Class<*> { - return when (this) { - "Asset" -> MintOfNumericAndAsset::class.java - "TriggerRepetitions" -> MintOfu32AndTrigger::class.java - else -> throw DeserializationException("Unknown type: $this") - } + private fun String.toArg(): Class<*> = when (this) { + "Asset" -> MintOfNumericAndAsset::class.java + "TriggerRepetitions" -> MintOfu32AndTrigger::class.java + else -> throw DeserializationException("Unknown type: $this") } - private fun get(arg: Any): MintBox { - return when (arg) { - is MintOfNumericAndAsset -> MintBox.Asset(arg) - is MintOfu32AndTrigger -> MintBox.TriggerRepetitions(arg) - else -> throw DeserializationException("Mint box `$arg` not found") - } + private fun get(arg: Any): MintBox = when (arg) { + is MintOfNumericAndAsset -> MintBox.Asset(arg) + is MintOfu32AndTrigger -> MintBox.TriggerRepetitions(arg) + else -> throw DeserializationException("Mint box `$arg` not found") } } @@ -386,20 +350,16 @@ object EventFilterBoxDeserializer : JsonDeserializer() { return getBox(JSON_SERDE.convertValue(node.value, node.key.toArg())) } - private fun String.toArg(): Class<*> { - return when (this) { - "ExecuteTrigger" -> ExecuteTriggerEventFilter::class.java - "Time" -> TimeEventFilter::class.java - else -> throw DeserializationException("Unknown type `$this`") - } + private fun String.toArg(): Class<*> = when (this) { + "ExecuteTrigger" -> ExecuteTriggerEventFilter::class.java + "Time" -> TimeEventFilter::class.java + else -> throw DeserializationException("Unknown type `$this`") } - private fun getBox(arg: Any): EventFilterBox { - return when (arg) { - is ExecuteTriggerEventFilter -> EventFilterBox.ExecuteTrigger(arg) - is TimeEventFilter -> EventFilterBox.Time(arg) - else -> throw DeserializationException("Unknown type `$this`") - } + private fun getBox(arg: Any): EventFilterBox = when (arg) { + is ExecuteTriggerEventFilter -> EventFilterBox.ExecuteTrigger(arg) + is TimeEventFilter -> EventFilterBox.Time(arg) + else -> throw DeserializationException("Unknown type `$this`") } } @@ -418,22 +378,18 @@ object TransferBoxDeserializer : JsonDeserializer() { return get(JSON_SERDE.convertValue(node.fields().next().value, paramClass)) } - private fun String.toArg(): Class<*> { - return when (this) { - "Domain" -> TransferOfAccountAndDomainIdAndAccount::class.java - "Asset" -> AssetTransferBox::class.java - "AssetDefinition" -> TransferOfAccountAndAssetDefinitionIdAndAccount::class.java - else -> throw DeserializationException("Unknown type: $this") - } + private fun String.toArg(): Class<*> = when (this) { + "Domain" -> TransferOfAccountAndDomainIdAndAccount::class.java + "Asset" -> AssetTransferBox::class.java + "AssetDefinition" -> TransferOfAccountAndAssetDefinitionIdAndAccount::class.java + else -> throw DeserializationException("Unknown type: $this") } - private fun get(arg: Any): TransferBox { - return when (arg) { - is TransferOfAccountAndDomainIdAndAccount -> TransferBox.Domain(arg) - is AssetTransferBox -> TransferBox.Asset(arg) - is TransferOfAccountAndAssetDefinitionIdAndAccount -> TransferBox.AssetDefinition(arg) - else -> throw DeserializationException("SetKeyValue box `$arg` not found") - } + private fun get(arg: Any): TransferBox = when (arg) { + is TransferOfAccountAndDomainIdAndAccount -> TransferBox.Domain(arg) + is AssetTransferBox -> TransferBox.Asset(arg) + is TransferOfAccountAndAssetDefinitionIdAndAccount -> TransferBox.AssetDefinition(arg) + else -> throw DeserializationException("Transfer box `$arg` not found") } } @@ -445,26 +401,22 @@ object SetKeyValueBoxDeserializer : JsonDeserializer() { return get(JSON_SERDE.convertValue(node.fields().next().value, paramClass)) } - private fun String.toArg(): Class<*> { - return when (this) { - "Domain" -> SetKeyValueOfDomain::class.java - "Account" -> SetKeyValueOfAccount::class.java - "Asset" -> SetKeyValueOfAsset::class.java - "AssetDefinition" -> SetKeyValueOfAssetDefinition::class.java - "Trigger" -> SetKeyValueOfTrigger::class.java - else -> throw DeserializationException("Unknown type: $this") - } + private fun String.toArg(): Class<*> = when (this) { + "Domain" -> SetKeyValueOfDomain::class.java + "Account" -> SetKeyValueOfAccount::class.java + "Asset" -> SetKeyValueOfAsset::class.java + "AssetDefinition" -> SetKeyValueOfAssetDefinition::class.java + "Trigger" -> SetKeyValueOfTrigger::class.java + else -> throw DeserializationException("Unknown type: $this") } - private fun get(arg: Any): SetKeyValueBox { - return when (arg) { - is SetKeyValueOfDomain -> SetKeyValueBox.Domain(arg) - is SetKeyValueOfAccount -> SetKeyValueBox.Account(arg) - is SetKeyValueOfAsset -> SetKeyValueBox.Asset(arg) - is SetKeyValueOfAssetDefinition -> SetKeyValueBox.AssetDefinition(arg) - is SetKeyValueOfTrigger -> SetKeyValueBox.Trigger(arg) - else -> throw DeserializationException("SetKeyValue box `$arg` not found") - } + private fun get(arg: Any): SetKeyValueBox = when (arg) { + is SetKeyValueOfDomain -> SetKeyValueBox.Domain(arg) + is SetKeyValueOfAccount -> SetKeyValueBox.Account(arg) + is SetKeyValueOfAsset -> SetKeyValueBox.Asset(arg) + is SetKeyValueOfAssetDefinition -> SetKeyValueBox.AssetDefinition(arg) + is SetKeyValueOfTrigger -> SetKeyValueBox.Trigger(arg) + else -> throw DeserializationException("SetKeyValue box `$arg` not found") } } @@ -472,9 +424,7 @@ object SetKeyValueBoxDeserializer : JsonDeserializer() { * Deserializer for [Metadata] */ object MetadataDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Metadata { - return deserializeMetadata(p, JSON_SERDE) - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Metadata = deserializeMetadata(p, JSON_SERDE) private fun deserializeMetadata(p: JsonParser, mapper: ObjectMapper): Metadata { val nodeMetadata = p.readValueAsTree().fields() @@ -483,8 +433,8 @@ object MetadataDeserializer : JsonDeserializer() { } val node = nodeMetadata.next() val key = node.key.asName() - val value = node.value.asStringOrNull() ?: "" - return Metadata(mapOf(Pair(key, value))) + val value = node.value.toString() + return Metadata(mapOf(Pair(key, Json(value)))) } } @@ -492,12 +442,10 @@ object MetadataDeserializer : JsonDeserializer() { * Deserializer for [AssetType] */ object AssetTypeDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): AssetType { - return when (p.readValueAsTree().textValue()) { - AssetType.Numeric::class.simpleName -> AssetType.Numeric(NumericSpec()) - AssetType.Store::class.simpleName -> AssetType.Store() - else -> throw DeserializationException("Unknown type: $this") - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): AssetType = when (p.readValueAsTree().textValue()) { + AssetType.Numeric::class.simpleName -> AssetType.Numeric(NumericSpec()) + AssetType.Store::class.simpleName -> AssetType.Store() + else -> throw DeserializationException("Unknown type: $this") } } @@ -505,18 +453,15 @@ object AssetTypeDeserializer : JsonDeserializer() { * Deserializer for [NumericSpec] */ object NumericSpecDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): NumericSpec { - return NumericSpec(p.readValueAsTree().longValue()) - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): NumericSpec = + NumericSpec(p.readValueAsTree().longValue()) } /** * Deserializer for [Numeric] */ object NumericDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Numeric { - return p.readValueAs(String::class.java).asNumeric() - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Numeric = p.readValueAs(String::class.java).asNumeric() } /** @@ -525,12 +470,29 @@ object NumericDeserializer : JsonDeserializer() { object PermissionDeserializer : JsonDeserializer() { override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Permission { val node = p.readValueAsTree() - var payloadValue = node.get("payload").asStringOrNull() + var payloadValue = node.get("payload").toString() when (payloadValue.isNullOrEmpty()) { true -> payloadValue = "null" else -> {} } - return Permission(node.get("name").asText(), payloadValue) + return Permission(node.get("name").asText(), Json(payloadValue)) + } +} + +/** + * Deserializer for [NewRole] + */ +object NewRoleDeserializer : JsonDeserializer() { + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): NewRole { + val node = p.readValueAsTree() + val roleId = JSON_SERDE.convertValue(node["id"], RoleId::class.java) + val permissions = JSON_SERDE.convertValue( + node["permissions"], + object : TypeReference>() {}, + ) + val grantTo = JSON_SERDE.convertValue(node["grant_to"], AccountId::class.java) + + return NewRole(Role(roleId, permissions), grantTo) } } @@ -538,9 +500,7 @@ object PermissionDeserializer : JsonDeserializer() { * Deserializer for [ChainId] */ object ChainIdDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): ChainId { - return ChainId(p.readValueAs(String::class.java)) - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): ChainId = ChainId(p.readValueAs(String::class.java)) } /** @@ -628,20 +588,16 @@ object ExecutableDeserializer : JsonDeserializer() { return getExecutable(value) } - private fun String.toArg(): Class<*> { - return when (this) { - "Wasm" -> WasmSmartContract::class.java - "Instructions" -> List::class.java - else -> throw DeserializationException("Unknown type: $this") - } + private fun String.toArg(): Class<*> = when (this) { + "Wasm" -> WasmSmartContract::class.java + "Instructions" -> List::class.java + else -> throw DeserializationException("Unknown type: $this") } - private fun getExecutable(arg: Any): Executable { - return when (arg) { - is WasmSmartContract -> Executable.Wasm(arg) - is List<*> -> Executable.Instructions(arg as List) - else -> throw DeserializationException("Executable `$arg` not found") - } + private fun getExecutable(arg: Any): Executable = when (arg) { + is WasmSmartContract -> Executable.Wasm(arg) + is List<*> -> Executable.Instructions(arg as List) + else -> throw DeserializationException("Executable `$arg` not found") } } @@ -649,25 +605,21 @@ object ExecutableDeserializer : JsonDeserializer() { * Deserializer for [IpfsPath] */ object IpfsPathDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): IpfsPath { - return IpfsPath(p.readValueAs(String::class.java)) - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): IpfsPath = IpfsPath(p.readValueAs(String::class.java)) } /** * Deserializer for [Repeats] */ object RepeatsDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Repeats { - return when (val node = p.readValueAsTree()) { - is TextNode -> Repeats.Indefinitely() - is ObjectNode -> { - val field = node.fields().next() - Repeats.Exactly(JSON_SERDE.convertValue(field.value, Long::class.java)) - } - - else -> throw DeserializationException("Unknown type: $this") + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Repeats = when (val node = p.readValueAsTree()) { + is TextNode -> Repeats.Indefinitely() + is ObjectNode -> { + val field = node.fields().next() + Repeats.Exactly(JSON_SERDE.convertValue(field.value, Long::class.java)) } + + else -> throw DeserializationException("Unknown type: $this") } } @@ -680,28 +632,24 @@ object ParameterDeserializer : JsonDeserializer() { return get(JSON_SERDE.convertValue(node.value, node.key.toArg()), node.key) } - private fun String.toArg(): Class<*> { - return when (this) { - "Sumeragi" -> SumeragiParameter::class.java - "Block" -> BlockParameter::class.java - "Transaction" -> TransactionParameter::class.java - "SmartContract" -> SmartContractParameter::class.java - "Executor" -> SmartContractParameter::class.java - "Custom" -> CustomParameter::class.java - else -> throw DeserializationException("Unknown type: $this") - } + private fun String.toArg(): Class<*> = when (this) { + "Sumeragi" -> SumeragiParameter::class.java + "Block" -> BlockParameter::class.java + "Transaction" -> TransactionParameter::class.java + "SmartContract" -> SmartContractParameter::class.java + "Executor" -> SmartContractParameter::class.java + "Custom" -> CustomParameter::class.java + else -> throw DeserializationException("Unknown type: $this") } - private fun get(arg: Any, type: String): Parameter { - return when (type) { - "Sumeragi" -> Parameter.Sumeragi(arg as SumeragiParameter) - "Block" -> Parameter.Block(arg as BlockParameter) - "Transaction" -> Parameter.Transaction(arg as TransactionParameter) - "Executor" -> Parameter.Executor(arg as SmartContractParameter) - "SmartContract" -> Parameter.SmartContract(arg as SmartContractParameter) - "CustomParameter" -> Parameter.Custom(arg as CustomParameter) - else -> throw DeserializationException("Unknown type: $this") - } + private fun get(arg: Any, type: String): Parameter = when (type) { + "Sumeragi" -> Parameter.Sumeragi(arg as SumeragiParameter) + "Block" -> Parameter.Block(arg as BlockParameter) + "Transaction" -> Parameter.Transaction(arg as TransactionParameter) + "Executor" -> Parameter.Executor(arg as SmartContractParameter) + "SmartContract" -> Parameter.SmartContract(arg as SmartContractParameter) + "CustomParameter" -> Parameter.Custom(arg as CustomParameter) + else -> throw DeserializationException("Unknown type: $this") } } @@ -715,12 +663,10 @@ object SumeragiParameterDeserializer : JsonDeserializer() { return get(arg, node.key) } - private fun get(arg: BigInteger, type: String): SumeragiParameter { - return when (type) { - "BlockTimeMs" -> SumeragiParameter.BlockTimeMs(arg) - "CommitTimeMs" -> SumeragiParameter.CommitTimeMs(arg) - else -> throw DeserializationException("Unknown type: $this") - } + private fun get(arg: BigInteger, type: String): SumeragiParameter = when (type) { + "BlockTimeMs" -> SumeragiParameter.BlockTimeMs(arg) + "CommitTimeMs" -> SumeragiParameter.CommitTimeMs(arg) + else -> throw DeserializationException("Unknown type: $this") } } @@ -745,12 +691,10 @@ object TransactionParameterDeserializer : JsonDeserializer return get(arg, node.key) } - private fun get(arg: BigInteger, type: String): TransactionParameter { - return when (type) { - "MaxInstructions" -> TransactionParameter.MaxInstructions(NonZeroOfu64(arg)) - "SmartContractSize" -> TransactionParameter.SmartContractSize(NonZeroOfu64(arg)) - else -> throw DeserializationException("Unknown type: $this") - } + private fun get(arg: BigInteger, type: String): TransactionParameter = when (type) { + "MaxInstructions" -> TransactionParameter.MaxInstructions(NonZeroOfu64(arg)) + "SmartContractSize" -> TransactionParameter.SmartContractSize(NonZeroOfu64(arg)) + else -> throw DeserializationException("Unknown type: $this") } } @@ -764,12 +708,10 @@ object SmartContractParameterDeserializer : JsonDeserializer SmartContractParameter.Fuel(NonZeroOfu64(arg)) - "Memory" -> SmartContractParameter.Memory(NonZeroOfu64(arg)) - else -> throw DeserializationException("Unknown type: $this") - } + private fun get(arg: BigInteger, type: String): SmartContractParameter = when (type) { + "Fuel" -> SmartContractParameter.Fuel(NonZeroOfu64(arg)) + "Memory" -> SmartContractParameter.Memory(NonZeroOfu64(arg)) + else -> throw DeserializationException("Unknown type: $this") } } @@ -790,12 +732,10 @@ object ScheduleDeserializer : JsonDeserializer() { * Deserializer for [ExecutionTime] */ object ExecutionTimeDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): ExecutionTime { - return when (val node = p.readValueAsTree()) { - is TextNode -> ExecutionTime.PreCommit() - is ObjectNode -> ExecutionTime.Schedule(JSON_SERDE.convertValue(node, Schedule::class.java)) - else -> throw DeserializationException("Unknown type: $this") - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): ExecutionTime = when (val node = p.readValueAsTree()) { + is TextNode -> ExecutionTime.PreCommit() + is ObjectNode -> ExecutionTime.Schedule(JSON_SERDE.convertValue(node, Schedule::class.java)) + else -> throw DeserializationException("Unknown type: $this") } } @@ -823,22 +763,18 @@ object PublicKeyDeserializer : JsonDeserializer() { * Deserializer for [Name] */ object NameDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Name { - return Name(p.readValueAs(String::class.java)) - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Name = Name(p.readValueAs(String::class.java)) } /** * Deserializer for [Mintable] */ object MintableDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Mintable { - return when (val value = p.readValueAs(String::class.java)) { - Mintable.Once::class.simpleName -> Mintable.Once() - Mintable.Not::class.simpleName -> Mintable.Not() - Mintable.Infinitely::class.simpleName -> Mintable.Infinitely() - else -> throw DeserializationException("Unknown Mintable type: $value") - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Mintable = when (val value = p.readValueAs(String::class.java)) { + Mintable.Once::class.simpleName -> Mintable.Once() + Mintable.Not::class.simpleName -> Mintable.Not() + Mintable.Infinitely::class.simpleName -> Mintable.Infinitely() + else -> throw DeserializationException("Unknown Mintable type: $value") } } @@ -846,100 +782,83 @@ object MintableDeserializer : JsonDeserializer() { * Deserializer for [asset ID][AssetId] */ object AssetIdDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): AssetId { - return p.readValueAs(String::class.java).asAssetId() - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): AssetId = p.readValueAs(String::class.java).asAssetId() } /** * Deserializer for [asset definition ID][AssetDefinitionId] */ object AssetDefinitionIdDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): AssetDefinitionId { - return p.readValueAs(String::class.java).asAssetDefinitionId() - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): AssetDefinitionId = + p.readValueAs(String::class.java).asAssetDefinitionId() } /** * Deserializer for [account ID][AccountId] */ object AccountIdDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): AccountId { - return p.readValueAs(String::class.java).asAccountId() - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): AccountId = p.readValueAs(String::class.java).asAccountId() } /** * Deserializer for [role ID][RoleId] */ object RoleIdDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): RoleId { - return p.readValueAs(String::class.java).asRoleId() - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): RoleId = p.readValueAs(String::class.java).asRoleId() } /** * Deserializer for [domain ID][DomainId] */ object DomainIdDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): DomainId { - return p.readValueAs(String::class.java).asDomainId() - } + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): DomainId = p.readValueAs(String::class.java).asDomainId() } /** * Deserializer for [asset definition ID][AssetDefinitionId] */ object AssetDefinitionIdKeyDeserializer : KeyDeserializer() { - override fun deserializeKey(key: String?, ctxt: DeserializationContext?): AssetDefinitionId? { - return JSON_SERDE.readValue(key, AssetDefinitionId::class.java) - } + override fun deserializeKey(key: String?, ctxt: DeserializationContext?): AssetDefinitionId? = + JSON_SERDE.readValue(key, AssetDefinitionId::class.java) } /** * Deserializer for [account ID][AccountId] */ object AccountIdKeyDeserializer : KeyDeserializer() { - override fun deserializeKey(key: String?, ctxt: DeserializationContext?): AccountId? { - return JSON_SERDE.readValue(key, AccountId::class.java) - } + override fun deserializeKey(key: String?, ctxt: DeserializationContext?): AccountId? = JSON_SERDE.readValue(key, AccountId::class.java) } /** * Deserializer for [asset ID][AssetId] */ object AssetIdKeyDeserializer : KeyDeserializer() { - override fun deserializeKey(key: String, ctxt: DeserializationContext?): AssetId? { - return JSON_SERDE.readValue(key, AssetId::class.java) - } + override fun deserializeKey(key: String, ctxt: DeserializationContext?): AssetId? = JSON_SERDE.readValue(key, AssetId::class.java) } /** * Deserializer for [domain ID][DomainId] */ object DomainIdKeyDeserializer : KeyDeserializer() { - override fun deserializeKey(key: String, ctxt: DeserializationContext?): DomainId? { - return JSON_SERDE.readValue(key, DomainId::class.java) - } + override fun deserializeKey(key: String, ctxt: DeserializationContext?): DomainId? = JSON_SERDE.readValue(key, DomainId::class.java) } +object CustomParameterIdKeyDeserializer : KeyDeserializer() { + override fun deserializeKey(key: String, ctxt: DeserializationContext?): CustomParameterId? = + JSON_SERDE.readValue(key, CustomParameterId::class.java) +} // ================================================== /** - * Serializer for [RawGenesisTransaction] + * Serializer for [ChainId] */ -object RawGenesisTransactionSerializer : JsonSerializer() { - override fun serialize(tx: RawGenesisTransaction, gen: JsonGenerator, serializers: SerializerProvider) { - gen.writeStartObject() - gen.writeObjectField("chain", tx.chain.string) - gen.writeObjectField("executor", tx.executor) - gen.writeObjectField("parameters", tx.parameters) - when (tx.instructions.isEmpty()) { - true -> gen.writeObjectField("instructions", listOf()) - false -> gen.writeObjectField("instructions", tx.instructions) - } - gen.writeObjectField("topology", tx.topology) - gen.writeEndObject() +object ChainIdSerializer : JsonSerializer() { + override fun serialize( + chainId: ChainId, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { + gen.writeString(chainId.string) } } @@ -947,7 +866,11 @@ object RawGenesisTransactionSerializer : JsonSerializer() * Serializer for [AssetDefinitionId] */ object AssetDefinitionIdSerializer : JsonSerializer() { - override fun serialize(value: AssetDefinitionId, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: AssetDefinitionId, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeString(value.asString()) } } @@ -956,7 +879,11 @@ object AssetDefinitionIdSerializer : JsonSerializer() { * Serializer for [AssetId] */ object AssetIdSerializer : JsonSerializer() { - override fun serialize(value: AssetId, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: AssetId, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeString(value.asString(true)) } } @@ -965,7 +892,11 @@ object AssetIdSerializer : JsonSerializer() { * Serializer for [AccountId] */ object AccountIdSerializer : JsonSerializer() { - override fun serialize(value: AccountId, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: AccountId, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeString(value.asString(true)) } } @@ -974,7 +905,11 @@ object AccountIdSerializer : JsonSerializer() { * Serializer for [DomainId] */ object DomainIdSerializer : JsonSerializer() { - override fun serialize(value: DomainId, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: DomainId, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeString(value.asString()) } } @@ -983,13 +918,21 @@ object DomainIdSerializer : JsonSerializer() { * Serializer for [RoleId] */ object RoleIdSerializer : JsonSerializer() { - override fun serialize(value: RoleId, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: RoleId, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeString(value.asString()) } } object SocketAddrSerializer : JsonSerializer() { - override fun serialize(value: SocketAddr, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: SocketAddr, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeString(value.asString()) } } @@ -998,7 +941,11 @@ object SocketAddrSerializer : JsonSerializer() { * Serializer for [TriggerId] */ object TriggerIdSerializer : JsonSerializer() { - override fun serialize(value: TriggerId, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: TriggerId, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeString(value.asString()) } } @@ -1007,7 +954,11 @@ object TriggerIdSerializer : JsonSerializer() { * Serializer for [TimeEventFilter] */ object TimeEventFilterSerializer : JsonSerializer() { - override fun serialize(value: TimeEventFilter, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: TimeEventFilter, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { value.serializeEnum(gen) } } @@ -1016,26 +967,25 @@ object TimeEventFilterSerializer : JsonSerializer() { * Serializer for [Schedule] */ object ScheduleSerializer : JsonSerializer() { - override fun serialize(value: Schedule, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: Schedule, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { val schedule = mapOf(Pair("start_ms", value.startMs), Pair("period_ms", value.periodMs)) gen.writeObject(schedule) } } -/** - * Serializer for [Name] as key - */ -object NameAsKeySerializer : JsonSerializer() { - override fun serialize(value: Name, gen: JsonGenerator, serializers: SerializerProvider) { - gen.writeFieldName(value.string) - } -} - /** * Serializer for [Name] */ object NameSerializer : JsonSerializer() { - override fun serialize(value: Name, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: Name, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeString(value.string) } } @@ -1044,7 +994,11 @@ object NameSerializer : JsonSerializer() { * Serializer for [Executor] */ object ExecutorSerializer : JsonSerializer() { - override fun serialize(value: Executor, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: Executor, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { when (value) { // is Executor -> gen.writeString(value.wasm) else -> throw IrohaSdkException("Unsupported type ${this::class}") @@ -1052,28 +1006,15 @@ object ExecutorSerializer : JsonSerializer() { } } -/** - * Serializer for [InstructionBox] - */ -object InstructionBoxSerializer : JsonSerializer() { - override fun serialize(value: InstructionBox, gen: JsonGenerator, serializers: SerializerProvider) { - when (value) { - is InstructionBox.Register -> value.serializeBox(gen) - is InstructionBox.SetKeyValue -> value.serializeBox(gen) - is InstructionBox.Mint -> value.serializeBox(gen) - is InstructionBox.Burn -> value.serializeBox(gen) - is InstructionBox.Transfer -> value.serializeBox(gen) - is InstructionBox.Grant -> value.serializeBox(gen) - else -> throw IrohaSdkException("Unsupported type ${this::class}") - } - } -} - /** * Serializer for [RegisterOfDomain] */ object RegisterOfDomainSerializer : JsonSerializer() { - override fun serialize(value: RegisterOfDomain, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: RegisterOfDomain, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeObject(value.`object`) } } @@ -1082,7 +1023,11 @@ object RegisterOfDomainSerializer : JsonSerializer() { * Serializer for [RegisterOfTrigger] */ object RegisterOfTriggerSerializer : JsonSerializer() { - override fun serialize(value: RegisterOfTrigger, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: RegisterOfTrigger, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeObject(value.`object`) } } @@ -1091,7 +1036,11 @@ object RegisterOfTriggerSerializer : JsonSerializer() { * Serializer for [RegisterOfRole] */ object RegisterOfRoleSerializer : JsonSerializer() { - override fun serialize(value: RegisterOfRole, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: RegisterOfRole, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeObject(value.`object`) } } @@ -1100,7 +1049,11 @@ object RegisterOfRoleSerializer : JsonSerializer() { * Serializer for [RegisterOfAsset] */ object RegisterOfAssetSerializer : JsonSerializer() { - override fun serialize(value: RegisterOfAsset, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: RegisterOfAsset, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeObject(value.`object`) } } @@ -1109,7 +1062,11 @@ object RegisterOfAssetSerializer : JsonSerializer() { * Serializer for [RegisterOfAssetDefinition] */ object RegisterOfAssetDefinitionSerializer : JsonSerializer() { - override fun serialize(value: RegisterOfAssetDefinition, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: RegisterOfAssetDefinition, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeObject(value.`object`) } } @@ -1118,7 +1075,11 @@ object RegisterOfAssetDefinitionSerializer : JsonSerializer() { - override fun serialize(value: RegisterOfPeer, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: RegisterOfPeer, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeObject(value.`object`) } } @@ -1127,29 +1088,75 @@ object RegisterOfPeerSerializer : JsonSerializer() { * Serializer for [RegisterOfAccount] */ object RegisterOfAccountSerializer : JsonSerializer() { - override fun serialize(value: RegisterOfAccount, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: RegisterOfAccount, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeObject(value.`object`) } } +/** + * Serializer for [NewRole] + */ +object NewRoleSerializer : JsonSerializer() { + override fun serialize( + value: NewRole, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { + gen.writeStartObject() + gen.writeObjectField("id", value.inner.id) + gen.writeObjectField("permissions", value.inner.permissions) + gen.writeObjectField("grant_to", value.grantTo) + gen.writeEndObject() + } +} + /** * Serializer for [AssetTransferBox] */ object AssetTransferBoxSerializer : JsonSerializer() { - override fun serialize(value: AssetTransferBox, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: AssetTransferBox, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { when (value) { is AssetTransferBox.Numeric -> gen.writeObject(value.transferOfAssetAndNumericAndAccount) is AssetTransferBox.Store -> gen.writeObject(value.transferOfAssetAndMetadataAndAccount) - else -> throw IrohaSdkException("Unexpected type ${value::class}") } } } +/** + * Deserializer for [NonZeroOfu64] + */ +object IrohaJsonDeserializer : JsonDeserializer() { + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Json { + val node = p.readValueAsTree() + return Json(node.toString()) + } +} + +/** + * Deserializer for [NonZeroOfu64] + */ +object NonZeroOfu64Deserializer : JsonDeserializer() { + override fun deserialize(p: JsonParser, ctxt: DeserializationContext): NonZeroOfu64 = + NonZeroOfu64(p.readValueAs(BigInteger::class.java)) +} + /** * Serializer for [NonZeroOfu64] */ object NonZeroOfu64Serializer : JsonSerializer() { - override fun serialize(value: NonZeroOfu64, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: NonZeroOfu64, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeObject(value.u64) } } @@ -1158,7 +1165,11 @@ object NonZeroOfu64Serializer : JsonSerializer() { * Serializer for [Executable.Instructions] */ object ExecutableInstructionsSerializer : JsonSerializer() { - override fun serialize(value: Executable.Instructions, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: Executable.Instructions, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeStartObject() gen.writeObjectField(Executable.Instructions::class.simpleName, value.vec) gen.writeEndObject() @@ -1169,7 +1180,11 @@ object ExecutableInstructionsSerializer : JsonSerializer() { - override fun serialize(value: ExecuteTriggerEventFilter, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: ExecuteTriggerEventFilter, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeStartObject() gen.writeObjectField("trigger", value.triggerId) gen.writeObjectField("authority", value.authority) @@ -1181,7 +1196,11 @@ object ExecuteTriggerEventFilterSerializer : JsonSerializer() { - override fun serialize(value: AssetType, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: AssetType, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeObject(value::class.simpleName) } } @@ -1190,7 +1209,11 @@ object AssetTypeSerializer : JsonSerializer() { * Serializer for [Numeric] */ object NumericSerializer : JsonSerializer() { - override fun serialize(value: Numeric, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: Numeric, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeObject(value.asString()) } } @@ -1199,8 +1222,12 @@ object NumericSerializer : JsonSerializer() { * Serializer for [Permission] */ object PermissionSerializer : JsonSerializer() { - override fun serialize(value: Permission, gen: JsonGenerator, serializers: SerializerProvider) { - val payload = JSON_SERDE.readTree(value.payload) + override fun serialize( + value: Permission, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { + val payload = JSON_SERDE.readTree(value.payload.string) gen.writeStartObject() gen.writeObjectField(Permission::name.name, value.name) gen.writeObjectField(Permission::payload.name, payload) @@ -1212,7 +1239,11 @@ object PermissionSerializer : JsonSerializer() { * Custom serializer for [UInt] */ object UIntSerializer : JsonSerializer() { - override fun serialize(value: UInt, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: UInt, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeNumber(value.toLong()) } } @@ -1221,7 +1252,11 @@ object UIntSerializer : JsonSerializer() { * Custom serializer for [PublicKey] */ object PublicKeySerializer : JsonSerializer() { - override fun serialize(value: PublicKey, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: PublicKey, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { val res = ByteArrayOutputStream() Multihash.putUvarint(res, Ed25519.index.toLong()) Multihash.putUvarint(res, value.payload.size.toLong()) @@ -1230,33 +1265,45 @@ object PublicKeySerializer : JsonSerializer() { } } +/** + * Custom serializer for [Json] + */ +object IrohaJsonSerializer : JsonSerializer() { + override fun serialize( + value: Json, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { + gen.writeRawValue(value.string) + } +} + /** * Custom serializer for [Metadata] */ object MetadataSerializer : JsonSerializer() { - override fun serialize(value: Metadata, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: Metadata, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeStartObject() value.sortedMapOfName.forEach { (k, v) -> - gen.writeStringField(k.string, v) + serializers.defaultSerializeField(k.string, v, gen) } gen.writeEndObject() } } -/** - * Custom serializer for [IdentifiableBox.NewRole] - */ -object IdentifiableBoxNewRoleSerializer : JsonSerializer() { - override fun serialize(value: IdentifiableBox.NewRole, gen: JsonGenerator, serializers: SerializerProvider) { - serializeSingleMember(gen, value.role) - } -} - /** * Custom serializer for [Parameter] */ object ParameterSerializer : JsonSerializer() { - override fun serialize(value: Parameter, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: Parameter, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { gen.writeStartObject() when (value) { is Parameter.Block -> gen.writeObjectField(Parameter.Block::class.simpleName, value.blockParameter) @@ -1269,7 +1316,6 @@ object ParameterSerializer : JsonSerializer() { is Parameter.Sumeragi -> gen.writeObjectField(Parameter.Sumeragi::class.simpleName, value.sumeragiParameter) is Parameter.Transaction -> gen.writeObjectField(Parameter.Transaction::class.simpleName, value.transactionParameter) - else -> throw IrohaSdkException("Unexpected type ${value::class}") } gen.writeEndObject() } @@ -1279,7 +1325,11 @@ object ParameterSerializer : JsonSerializer() { * Custom serializer for Iroha2 enumeration types */ object EnumerationSerializer : JsonSerializer() { - override fun serialize(value: ModelEnum, gen: JsonGenerator, serializers: SerializerProvider) { + override fun serialize( + value: ModelEnum, + gen: JsonGenerator, + serializers: SerializerProvider, + ) { when (value) { is InstructionBox.Grant -> value.serialize(gen) is InstructionBox.Burn -> value.serialize(gen) @@ -1321,9 +1371,7 @@ private inline fun InstructionBox.serializeBox(gen: JsonGenerator) { } } -private inline fun B.serializeBox( - gen: JsonGenerator, -) = when (B::class) { +private inline fun B.serializeBox(gen: JsonGenerator) = when (B::class) { BurnBox::class -> this?.cast()?.serializeBox(gen) MintBox::class -> this?.cast()?.serializeBox(gen) GrantBox::class -> this?.cast()?.serializeBox(gen) @@ -1396,30 +1444,6 @@ private fun String.asClass() = runCatching { } } ?: throw DeserializationException("Class $this not found") -private fun getClazzByParam(param: String): KClass { - return when (param) { - "SetKeyValue" -> SetKeyValueBox::class - "Bool" -> Boolean::class - "String" -> String::class - "Name" -> Name::class - "LimitedMetadata" -> Metadata::class - "Id" -> IdBox::class - "Identifiable" -> IdentifiableBox::class - "PublicKey" -> PublicKey::class - "TransactionQueryOutput" -> TransactionQueryOutput::class - "Hash" -> Hash::class - "Block" -> SignedBlock::class - "BlockHeader" -> BlockHeader::class - "Ipv4Addr" -> Ipv4Addr::class - "Ipv6Addr" -> Ipv6Addr::class - "U32" -> Numeric::class - "U64" -> Numeric::class - "U128" -> Numeric::class - "Fixed" -> Numeric::class - else -> throw DeserializationException("Value key $param not found") - } -} - private fun sealedDeserializeIdBox(p: JsonParser, mapper: ObjectMapper): IdBox { val node = p.readValueAsTree().fields().next() val param = node.key @@ -1436,29 +1460,7 @@ private fun sealedDeserializeIdBox(p: JsonParser, mapper: ObjectMapper): IdBox { return subtype.primaryConstructor?.call(arg) as IdBox } -private fun getTriggerId(triggerName: String): TriggerId { - return when (triggerName.contains("$")) { - true -> TriggerId(name = triggerName.split("$")[0].asName()) - false -> TriggerId(name = triggerName.asName()) - } -} - -private fun Any.toInstructionBox(): InstructionBox { - return when (this) { - is GrantBox -> InstructionBox.Grant(this) - is RevokeBox -> InstructionBox.Revoke(this) - is ExecuteTrigger -> InstructionBox.ExecuteTrigger(this) - is SetParameter -> InstructionBox.SetParameter(this) - is Upgrade -> InstructionBox.Upgrade(this) - is Log -> InstructionBox.Log(this) - is CustomInstruction -> InstructionBox.Custom(this) - is SetKeyValueBox -> InstructionBox.SetKeyValue(this) - is RemoveKeyValueBox -> InstructionBox.RemoveKeyValue(this) - is TransferBox -> InstructionBox.Transfer(this) - is BurnBox -> InstructionBox.Burn(this) - is MintBox -> InstructionBox.Mint(this) - is RegisterBox -> InstructionBox.Register(this) - is UnregisterBox -> InstructionBox.Unregister(this) - else -> throw DeserializationException("Unknown type: $this") - } -} +private fun getTriggerId(triggerName: String): TriggerId = when (triggerName.contains("$")) { + true -> TriggerId(name = triggerName.split("$")[0].asName()) + false -> TriggerId(name = triggerName.asName()) +} \ No newline at end of file diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/TriggerArgs.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/TriggerArgs.kt new file mode 100644 index 000000000..261297523 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/TriggerArgs.kt @@ -0,0 +1,3 @@ +package jp.co.soramitsu.iroha2 + +interface TriggerArgs \ No newline at end of file diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Util.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Util.kt index 0ea87e192..8eb1e7311 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Util.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Util.kt @@ -13,9 +13,7 @@ const val U32_MAX_VALUE = (1L shl 32) - 1 /** * Wrap an [exception][ex] in `ScaleCodecException` */ -fun wrapException(ex: Exception): Exception { - return when (ex) { - is ScaleCodecException -> ex - else -> ScaleCodecException(cause = ex) - } +fun wrapException(ex: Exception): Exception = when (ex) { + is ScaleCodecException -> ex + else -> ScaleCodecException(cause = ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/CompactMode.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/CompactMode.kt index e7608a4f9..1ee69bd84 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/CompactMode.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/CompactMode.kt @@ -6,24 +6,24 @@ import java.math.BigInteger * Compact mode for SCALE codec writers and readers */ enum class CompactMode(val value: Byte) { - SINGLE(0.toByte()), TWO(1.toByte()), FOUR(2.toByte()), BIGINT(3.toByte()); + SINGLE(0.toByte()), + TWO(1.toByte()), + FOUR(2.toByte()), + BIGINT(3.toByte()), + ; companion object { private val MAX = BigInteger.valueOf(2).pow(536).subtract(BigInteger.ONE) @JvmStatic - fun byValue(value: Byte): CompactMode { - return when (value) { - SINGLE.value -> SINGLE - TWO.value -> TWO - FOUR.value -> FOUR - else -> BIGINT - } + fun byValue(value: Byte): CompactMode = when (value) { + SINGLE.value -> SINGLE + TWO.value -> TWO + FOUR.value -> FOUR + else -> BIGINT } - fun forNumber(number: Int): CompactMode { - return forNumber(number.toLong()) - } + fun forNumber(number: Int): CompactMode = forNumber(number.toLong()) fun forNumber(number: Long): CompactMode { require(number >= 0) { "Negative numbers are not supported" } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/IntMax.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/IntMax.kt index 62ec14514..23c723d6d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/IntMax.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/IntMax.kt @@ -14,22 +14,18 @@ enum class IntMax(val max: BigInteger) { ; companion object { - fun uintMaxValue(bit: Int): BigInteger { - return when (bit) { - 64 -> U64 - 128 -> U128 - 256 -> U256 - else -> throw IllegalArgumentException("Unsupported type $bit") - }.max - } + fun uintMaxValue(bit: Int): BigInteger = when (bit) { + 64 -> U64 + 128 -> U128 + 256 -> U256 + else -> throw IllegalArgumentException("Unsupported type $bit") + }.max - fun intMaxValue(bit: Int): BigInteger { - return when (bit) { - 128 -> I128 - 256 -> I256 - else -> throw IllegalArgumentException("Unsupported type $bit") - }.max - } + fun intMaxValue(bit: Int): BigInteger = when (bit) { + 128 -> I128 + 256 -> I256 + else -> throw IllegalArgumentException("Unsupported type $bit") + }.max } } @@ -42,12 +38,10 @@ enum class IntMin(val min: BigInteger) { ; companion object { - fun intMinValue(bit: Int): BigInteger { - return when (bit) { - 128 -> I128 - 256 -> I256 - else -> throw IllegalArgumentException("Unsupported type $bit") - }.min - } + fun intMinValue(bit: Int): BigInteger = when (bit) { + 128 -> I128 + 256 -> I256 + else -> throw IllegalArgumentException("Unsupported type $bit") + }.min } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/ScaleCodecReader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/ScaleCodecReader.kt index 8f5ef34df..bab929fb8 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/ScaleCodecReader.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/ScaleCodecReader.kt @@ -25,9 +25,7 @@ class ScaleCodecReader(private val source: ByteArray) { /** * @return true if there are still elements to read */ - operator fun hasNext(): Boolean { - return pos < source.size - } + operator fun hasNext(): Boolean = pos < source.size /** * Move the reader's position forward (or backward for negative value) @@ -78,111 +76,89 @@ class ScaleCodecReader(private val source: ByteArray) { } } - inline fun readNullable(): T? { - return when (T::class) { - BigInteger::class -> when (readBoolean()) { - true -> readUint64() - else -> null - } as T? - Long::class -> when (readBoolean()) { - true -> readUint32() - else -> null - } as T? - Int::class -> when (readBoolean()) { - true -> readUint16() - else -> null - } as T? - String::class -> when (readBoolean()) { - true -> readString() - else -> null - } as T? - else -> throw IllegalArgumentException("Unsupported value type `${T::class.qualifiedName}`") - } + inline fun readNullable(): T? = when (T::class) { + BigInteger::class -> when (readBoolean()) { + true -> readUint64() + else -> null + } as T? + Boolean::class -> when (readBoolean()) { + true -> readBoolean() + else -> null + } as T? + Long::class -> when (readBoolean()) { + true -> readUint32() + else -> null + } as T? + Int::class -> when (readBoolean()) { + true -> readUint16() + else -> null + } as T? + String::class -> when (readBoolean()) { + true -> readString() + else -> null + } as T? + else -> throw IllegalArgumentException("Unsupported value type `${T::class.qualifiedName}`") } /** * Read Java Integer encoded as unsigned byte SCALE value */ - fun readUByte(): Int { - return UBYTE.read(this) - } + fun readUByte(): Int = UBYTE.read(this) /** * Read Java Integer encoded as unsigned 16-bit integer SCALE value */ - fun readUint16(): Int { - return UINT16.read(this) - } + fun readUint16(): Int = UINT16.read(this) /** * Read Java Long Integer encoded as unsigned 32-bit integer SCALE value */ - fun readUint32(): Long { - return UINT32.read(this) - } + fun readUint32(): Long = UINT32.read(this) /** * Read Java Big Integer encoded as unsigned 64-bit integer SCALE value */ - fun readUint64(): BigInteger { - return UINT64.read(this) - } + fun readUint64(): BigInteger = UINT64.read(this) /** * Read Java Big Integer encoded as unsigned 128-bit integer SCALE value */ - fun readUint128(): BigInteger { - return UINT128.read(this) - } + fun readUint128(): BigInteger = UINT128.read(this) /** * Read Java Big Integer encoded as unsigned 256-bit integer SCALE value */ - fun readUint256(): BigInteger { - return UINT256.read(this) - } + fun readUint256(): BigInteger = UINT256.read(this) /** * Read Java Integer encoded as 32-bit integer SCALE value */ - fun readInt32(): Int { - return INT32.read(this) - } + fun readInt32(): Int = INT32.read(this) /** * Read a Java Long Integer encoded as 64-bit integer SCALE value */ - fun readInt64(): Long { - return INT64.read(this) - } + fun readInt64(): Long = INT64.read(this) /** * Read a Java Big Integer encoded as 128-bit integer SCALE value */ - fun readInt128(): BigInteger { - return INT128.read(this) - } + fun readInt128(): BigInteger = INT128.read(this) /** * Read a Java Big Integer encoded as 256-bit integer SCALE value */ - fun readInt256(): BigInteger { - return INT256.read(this) - } + fun readInt256(): BigInteger = INT256.read(this) /** * Read an unsigned integer */ - fun readCompactInt(): Int { - return COMPACT_UINT.read(this) - } + fun readCompactInt(): Int = COMPACT_UINT.read(this) /** * Read a Boolean value */ - fun readBoolean(): Boolean { - return BOOL.read(this) - } + fun readBoolean(): Boolean = BOOL.read(this) /** * Read a byte array @@ -216,7 +192,11 @@ class ScaleCodecReader(private val source: ByteArray) { /** * Read a map */ - fun readMap(size: Int, key: () -> K, value: () -> V): MutableMap { + fun readMap( + size: Int, + key: () -> K, + value: () -> V, + ): MutableMap { val map = HashMap(capacity(size)) for (index in 0 until size) { map[key()] = value() @@ -227,33 +207,25 @@ class ScaleCodecReader(private val source: ByteArray) { /** * Read an array of a specified [size] */ - inline fun readArray(size: Int, supplier: () -> T): Array { - return Array(size) { supplier() } - } + inline fun readArray(size: Int, supplier: () -> T): Array = Array(size) { supplier() } /** * Read a vector of a specified [size] */ - fun readVec(size: Int, supplier: () -> T): List { - return List(size) { supplier() } - } + fun readVec(size: Int, supplier: () -> T): List = List(size) { supplier() } /** * Read a string encoded as UTF-8 bytes * * @return String value */ - fun readString(): String { - return String(readByteArray()) - } + fun readString(): String = String(readByteArray()) - private fun capacity(expectedSize: Int): Int { - return when { - expectedSize < 0 -> throw IllegalArgumentException("Expected size cannot be negative but was: $expectedSize") - expectedSize < 3 -> expectedSize + 1 - expectedSize < MAX_POWER_OF_TWO -> (expectedSize.toFloat() / 0.75f + 1.0f).toInt() - else -> Int.MAX_VALUE - } + private fun capacity(expectedSize: Int): Int = when { + expectedSize < 0 -> throw IllegalArgumentException("Expected size cannot be negative but was: $expectedSize") + expectedSize < 3 -> expectedSize + 1 + expectedSize < MAX_POWER_OF_TWO -> (expectedSize.toFloat() / 0.75f + 1.0f).toInt() + else -> Int.MAX_VALUE } companion object { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/ScaleCodecWriter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/ScaleCodecWriter.kt index c0d00be31..4fcf28d38 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/ScaleCodecWriter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/ScaleCodecWriter.kt @@ -58,7 +58,11 @@ class ScaleCodecWriter(private val out: OutputStream) : Closeable { * Write the bytes into output stream as-is directly with the given [offset]. * The input is supposed to be already encoded. */ - fun directWrite(bytes: ByteArray, offset: Int, length: Int) { + fun directWrite( + bytes: ByteArray, + offset: Int, + length: Int, + ) { out.write(bytes, offset, length) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/UnionValue.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/UnionValue.kt index 03cc8b119..b41b2be02 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/UnionValue.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/UnionValue.kt @@ -17,20 +17,14 @@ class UnionValue(index: Int, value: T) { value == that.value } - fun canEquals(o: Any?): Boolean { - return o is UnionValue<*> - } + fun canEquals(o: Any?): Boolean = o is UnionValue<*> - override fun hashCode(): Int { - return Objects.hash(index, value) - } + override fun hashCode(): Int = Objects.hash(index, value) - override fun toString(): String { - return "UnionValue{" + - "index=" + index + - ", value=" + value + - '}' - } + override fun toString(): String = "UnionValue{" + + "index=" + index + + ", value=" + value + + '}' init { require(index >= 0) { "Index cannot be negative number: $index" } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/BoolReader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/BoolReader.kt index ecbec56c4..0e618cf03 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/BoolReader.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/BoolReader.kt @@ -7,12 +7,10 @@ import jp.co.soramitsu.iroha2.codec.ScaleReader * SCALE codec reader for Boolean values encoded as SCALE values */ class BoolReader : ScaleReader { - override fun read(reader: ScaleCodecReader): Boolean { - return when (val b = reader.readByte().toInt()) { - 0 -> false - 1 -> true - else -> throw IllegalStateException("Not a boolean option: $b") - } + override fun read(reader: ScaleCodecReader): Boolean = when (val b = reader.readByte().toInt()) { + 0 -> false + 1 -> true + else -> throw IllegalStateException("Not a boolean option: $b") } } @@ -20,12 +18,10 @@ class BoolReader : ScaleReader { * SCALE codec reader for Nullable Boolean values encoded as SCALE values */ class BoolNullableReader : ScaleReader { - override fun read(reader: ScaleCodecReader): Boolean? { - return when (val b = reader.readByte().toInt()) { - 0 -> null - 1 -> false - 2 -> true - else -> throw IllegalStateException("Not a boolean option: $b") - } + override fun read(reader: ScaleCodecReader): Boolean? = when (val b = reader.readByte().toInt()) { + 0 -> null + 1 -> false + 2 -> true + else -> throw IllegalStateException("Not a boolean option: $b") } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/IntReader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/IntReader.kt index 72e433f23..17e47429a 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/IntReader.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/IntReader.kt @@ -48,7 +48,11 @@ class IntReader(private val bit: Int) : ScaleReader { } } -private fun putBytes(buf: ByteBuffer, capacity: Int, rdr: ScaleCodecReader) { +private fun putBytes( + buf: ByteBuffer, + capacity: Int, + rdr: ScaleCodecReader, +) { for (i in 1..capacity) { buf.put(rdr.readByte()) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/StringReader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/StringReader.kt index 31d473fca..71cfeb092 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/StringReader.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/StringReader.kt @@ -7,7 +7,5 @@ import jp.co.soramitsu.iroha2.codec.ScaleReader * Read string, encoded as UTF-8 bytes */ class StringReader : ScaleReader { - override fun read(reader: ScaleCodecReader): String { - return reader.readString() - } + override fun read(reader: ScaleCodecReader): String = reader.readString() } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/UnsupportedReader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/UnsupportedReader.kt index 98c24239a..eef4bde20 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/UnsupportedReader.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/UnsupportedReader.kt @@ -8,9 +8,6 @@ import jp.co.soramitsu.iroha2.codec.ScaleReader * * @throws IllegalStateException */ -class UnsupportedReader @JvmOverloads constructor(private val message: String = "Reading an unsupported value") : - ScaleReader { - override fun read(reader: ScaleCodecReader): T { - throw IllegalStateException(message) - } +class UnsupportedReader @JvmOverloads constructor(private val message: String = "Reading an unsupported value") : ScaleReader { + override fun read(reader: ScaleCodecReader): T = throw IllegalStateException(message) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Account.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Account.kt index ed68718cc..71bf2ef76 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Account.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Account.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'Account' regular structure */ -public data class Account( - public val id: AccountId, - public val metadata: Metadata, -) { +public data class Account(public val id: AccountId, public val metadata: Metadata) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Account = try { Account( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountEvent.kt index cc6e3b0e0..446b052bf 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountEvent.kt @@ -26,9 +26,7 @@ public sealed class AccountEvent : ModelEnum { /** * 'Created' variant */ - public data class Created( - public val account: Account, - ) : AccountEvent() { + public data class Created(public val account: Account) : AccountEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class AccountEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountEvent.Created, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AccountEvent.Created): Unit = try { Account.write(writer, instance.account) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class AccountEvent : ModelEnum { /** * 'Deleted' variant */ - public data class Deleted( - public val accountId: AccountId, - ) : AccountEvent() { + public data class Deleted(public val accountId: AccountId) : AccountEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class AccountEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountEvent.Deleted, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AccountEvent.Deleted): Unit = try { AccountId.write(writer, instance.accountId) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class AccountEvent : ModelEnum { /** * 'Asset' variant */ - public data class Asset( - public val assetEvent: AssetEvent, - ) : AccountEvent() { + public data class Asset(public val assetEvent: AssetEvent) : AccountEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,10 +96,7 @@ public sealed class AccountEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountEvent.Asset, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AccountEvent.Asset): Unit = try { AssetEvent.write(writer, instance.assetEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -122,9 +107,7 @@ public sealed class AccountEvent : ModelEnum { /** * 'PermissionAdded' variant */ - public data class PermissionAdded( - public val accountPermissionChanged: AccountPermissionChanged, - ) : AccountEvent() { + public data class PermissionAdded(public val accountPermissionChanged: AccountPermissionChanged) : AccountEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,23 +123,19 @@ public sealed class AccountEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountEvent.PermissionAdded, - ): Unit = try { - AccountPermissionChanged.write(writer, instance.accountPermissionChanged) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AccountEvent.PermissionAdded): Unit = + try { + AccountPermissionChanged.write(writer, instance.accountPermissionChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'PermissionRemoved' variant */ - public data class PermissionRemoved( - public val accountPermissionChanged: AccountPermissionChanged, - ) : AccountEvent() { + public data class PermissionRemoved(public val accountPermissionChanged: AccountPermissionChanged) : AccountEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -172,23 +151,19 @@ public sealed class AccountEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountEvent.PermissionRemoved, - ): Unit = try { - AccountPermissionChanged.write(writer, instance.accountPermissionChanged) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AccountEvent.PermissionRemoved): Unit = + try { + AccountPermissionChanged.write(writer, instance.accountPermissionChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'RoleGranted' variant */ - public data class RoleGranted( - public val accountRoleChanged: AccountRoleChanged, - ) : AccountEvent() { + public data class RoleGranted(public val accountRoleChanged: AccountRoleChanged) : AccountEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -204,10 +179,7 @@ public sealed class AccountEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountEvent.RoleGranted, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AccountEvent.RoleGranted): Unit = try { AccountRoleChanged.write(writer, instance.accountRoleChanged) } catch (ex: Exception) { throw wrapException(ex) @@ -218,9 +190,7 @@ public sealed class AccountEvent : ModelEnum { /** * 'RoleRevoked' variant */ - public data class RoleRevoked( - public val accountRoleChanged: AccountRoleChanged, - ) : AccountEvent() { + public data class RoleRevoked(public val accountRoleChanged: AccountRoleChanged) : AccountEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -236,10 +206,7 @@ public sealed class AccountEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountEvent.RoleRevoked, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AccountEvent.RoleRevoked): Unit = try { AccountRoleChanged.write(writer, instance.accountRoleChanged) } catch (ex: Exception) { throw wrapException(ex) @@ -250,9 +217,7 @@ public sealed class AccountEvent : ModelEnum { /** * 'MetadataInserted' variant */ - public data class MetadataInserted( - public val metadataChangedOfAccountId: MetadataChangedOfAccountId, - ) : AccountEvent() { + public data class MetadataInserted(public val metadataChangedOfAccountId: MetadataChangedOfAccountId) : AccountEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -268,23 +233,19 @@ public sealed class AccountEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountEvent.MetadataInserted, - ): Unit = try { - MetadataChangedOfAccountId.write(writer, instance.metadataChangedOfAccountId) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AccountEvent.MetadataInserted): Unit = + try { + MetadataChangedOfAccountId.write(writer, instance.metadataChangedOfAccountId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'MetadataRemoved' variant */ - public data class MetadataRemoved( - public val metadataChangedOfAccountId: MetadataChangedOfAccountId, - ) : AccountEvent() { + public data class MetadataRemoved(public val metadataChangedOfAccountId: MetadataChangedOfAccountId) : AccountEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -300,22 +261,17 @@ public sealed class AccountEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountEvent.MetadataRemoved, - ): Unit = try { - MetadataChangedOfAccountId.write(writer, instance.metadataChangedOfAccountId) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AccountEvent.MetadataRemoved): Unit = + try { + MetadataChangedOfAccountId.write(writer, instance.metadataChangedOfAccountId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AccountEvent = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): AccountEvent = when (val discriminant = reader.readUByte()) { 0 -> Created.read(reader) 1 -> Deleted.read(reader) 2 -> Asset.read(reader) @@ -325,7 +281,8 @@ public sealed class AccountEvent : ModelEnum { 6 -> RoleRevoked.read(reader) 7 -> MetadataInserted.read(reader) 8 -> MetadataRemoved.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: AccountEvent) { writer.directWrite(instance.discriminant()) @@ -339,7 +296,8 @@ public sealed class AccountEvent : ModelEnum { 6 -> RoleRevoked.write(writer, instance as RoleRevoked) 7 -> MetadataInserted.write(writer, instance as MetadataInserted) 8 -> MetadataRemoved.write(writer, instance as MetadataRemoved) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountEventFilter.kt index a5355bfe3..0230e71c5 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountEventFilter.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'AccountEventFilter' regular structure */ -public data class AccountEventFilter( - public val idMatcher: AccountId? = null, - public val eventSet: Long, -) { +public data class AccountEventFilter(public val idMatcher: AccountId? = null, public val eventSet: Long) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): AccountEventFilter = try { AccountEventFilter( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountId.kt index 3dbdc2f0d..ebd27fcb2 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountId.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'AccountId' regular structure */ -public data class AccountId( - public val domain: DomainId, - public val signatory: PublicKey, -) { +public data class AccountId(public val domain: DomainId, public val signatory: PublicKey) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): AccountId = try { AccountId( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdPredicateAtom.kt new file mode 100644 index 000000000..2b8727e41 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdPredicateAtom.kt @@ -0,0 +1,70 @@ +// +// 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 + +/** + * AccountIdPredicateAtom + * + * Generated from 'AccountIdPredicateAtom' enum + */ +public sealed class AccountIdPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Equals' variant + */ + public data class Equals(public val accountId: AccountId) : AccountIdPredicateAtom() { + 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.AccountIdPredicateAtom.Equals = try { + Equals( + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AccountIdPredicateAtom.Equals): Unit = + try { + AccountId.write(writer, instance.accountId) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AccountIdPredicateAtom = 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: AccountIdPredicateAtom) { + 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/AccountIdPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdProjectionOfPredicateMarker.kt similarity index 53% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdProjectionOfPredicateMarker.kt index 8c67a2eb7..6fc573bbb 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdProjectionOfPredicateMarker.kt @@ -13,32 +13,30 @@ import kotlin.Int import kotlin.Unit /** - * AccountIdPredicateBox + * AccountIdProjectionOfPredicateMarker * - * Generated from 'AccountIdPredicateBox' enum + * Generated from 'AccountIdProjectionOfPredicateMarker' enum */ -public sealed class AccountIdPredicateBox : ModelEnum { +public sealed class AccountIdProjectionOfPredicateMarker : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int /** - * 'Equals' variant + * 'Atom' variant */ - public data class Equals( - public val accountId: AccountId, - ) : AccountIdPredicateBox() { + public data class Atom(public val accountIdPredicateAtom: AccountIdPredicateAtom) : AccountIdProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountIdPredicateBox.Equals = try { - Equals( - AccountId.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker.Atom = try { + Atom( + AccountIdPredicateAtom.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -46,9 +44,9 @@ public sealed class AccountIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountIdPredicateBox.Equals, + instance: jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker.Atom, ): Unit = try { - AccountId.write(writer, instance.accountId) + AccountIdPredicateAtom.write(writer, instance.accountIdPredicateAtom) } catch (ex: Exception) { throw wrapException(ex) } @@ -56,31 +54,31 @@ public sealed class AccountIdPredicateBox : ModelEnum { } /** - * 'DomainId' variant + * 'Domain' variant */ - public data class DomainId( - public val domainIdPredicateBox: DomainIdPredicateBox, - ) : AccountIdPredicateBox() { + public data class Domain(public val domainIdProjectionOfPredicateMarker: DomainIdProjectionOfPredicateMarker) : + AccountIdProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountIdPredicateBox.DomainId = try { - DomainId( - DomainIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker.Domain = + try { + Domain( + DomainIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountIdPredicateBox.DomainId, + instance: jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker.Domain, ): Unit = try { - DomainIdPredicateBox.write(writer, instance.domainIdPredicateBox) + DomainIdProjectionOfPredicateMarker.write(writer, instance.domainIdProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } @@ -90,52 +88,53 @@ public sealed class AccountIdPredicateBox : ModelEnum { /** * 'Signatory' variant */ - public data class Signatory( - public val publicKeyPredicateBox: PublicKeyPredicateBox, - ) : AccountIdPredicateBox() { + public data class Signatory(public val publicKeyProjectionOfPredicateMarker: PublicKeyProjectionOfPredicateMarker) : + AccountIdProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountIdPredicateBox.Signatory = try { - Signatory( - PublicKeyPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker.Signatory = + try { + Signatory( + PublicKeyProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountIdPredicateBox.Signatory, + instance: jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker.Signatory, ): Unit = try { - PublicKeyPredicateBox.write(writer, instance.publicKeyPredicateBox) + PublicKeyProjectionOfPredicateMarker.write(writer, instance.publicKeyProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } } } - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AccountIdPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Equals.read(reader) - 1 -> DomainId.read(reader) + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AccountIdProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Domain.read(reader) 2 -> Signatory.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: AccountIdPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: AccountIdProjectionOfPredicateMarker) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Equals.write(writer, instance as Equals) - 1 -> DomainId.write(writer, instance as DomainId) + 0 -> Atom.write(writer, instance as Atom) + 1 -> Domain.write(writer, instance as Domain) 2 -> Signatory.write(writer, instance as Signatory) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..b57f2b023 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdProjectionOfSelectorMarker.kt @@ -0,0 +1,156 @@ +// +// 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 + +/** + * AccountIdProjectionOfSelectorMarker + * + * Generated from 'AccountIdProjectionOfSelectorMarker' enum + */ +public sealed class AccountIdProjectionOfSelectorMarker : 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 : AccountIdProjectionOfSelectorMarker() { + 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.AccountIdProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".AccountIdProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Domain' variant + */ + public data class Domain(public val domainIdProjectionOfSelectorMarker: DomainIdProjectionOfSelectorMarker) : + AccountIdProjectionOfSelectorMarker() { + 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.AccountIdProjectionOfSelectorMarker.Domain = try { + Domain( + DomainIdProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfSelectorMarker.Domain, + ): Unit = try { + DomainIdProjectionOfSelectorMarker.write(writer, instance.domainIdProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Signatory' variant + */ + public data class Signatory(public val publicKeyProjectionOfSelectorMarker: PublicKeyProjectionOfSelectorMarker) : + AccountIdProjectionOfSelectorMarker() { + 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.AccountIdProjectionOfSelectorMarker.Signatory = + try { + Signatory( + PublicKeyProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfSelectorMarker.Signatory, + ): Unit = try { + PublicKeyProjectionOfSelectorMarker.write(writer, instance.publicKeyProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AccountIdProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Domain.read(reader) + 2 -> Signatory.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AccountIdProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Domain.write(writer, instance as Domain) + 2 -> Signatory.write(writer, instance as Signatory) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPermissionChanged.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPermissionChanged.kt index 9957dc0d9..ed9ccdc2b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPermissionChanged.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPermissionChanged.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'AccountPermissionChanged' regular structure */ -public data class AccountPermissionChanged( - public val account: AccountId, - public val permission: Permission, -) { +public data class AccountPermissionChanged(public val account: AccountId, public val permission: Permission) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValuePredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPredicateAtom.kt similarity index 60% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValuePredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPredicateAtom.kt index b6746406a..f45c54bf1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValuePredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPredicateAtom.kt @@ -11,27 +11,26 @@ import jp.co.soramitsu.iroha2.codec.ScaleWriter import kotlin.Int /** - * AssetValuePredicateBox + * AccountPredicateAtom * - * Generated from 'AssetValuePredicateBox' enum + * Generated from 'AccountPredicateAtom' enum */ -public sealed class AssetValuePredicateBox : ModelEnum { +public sealed class AccountPredicateAtom : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetValuePredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): AccountPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: AssetValuePredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: AccountPredicateAtom) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..0a999b092 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountProjectionOfPredicateMarker.kt @@ -0,0 +1,139 @@ +// +// 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 + +/** + * AccountProjectionOfPredicateMarker + * + * Generated from 'AccountProjectionOfPredicateMarker' enum + */ +public sealed class AccountProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val accountPredicateAtom: AccountPredicateAtom) : AccountProjectionOfPredicateMarker() { + 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.AccountProjectionOfPredicateMarker.Atom = try { + Atom( + AccountPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AccountProjectionOfPredicateMarker.Atom, + ): Unit = try { + AccountPredicateAtom.write(writer, instance.accountPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Id' variant + */ + public data class Id(public val accountIdProjectionOfPredicateMarker: AccountIdProjectionOfPredicateMarker) : + AccountProjectionOfPredicateMarker() { + 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.AccountProjectionOfPredicateMarker.Id = try { + Id( + AccountIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AccountProjectionOfPredicateMarker.Id, + ): Unit = try { + AccountIdProjectionOfPredicateMarker.write(writer, instance.accountIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Metadata' variant + */ + public data class Metadata(public val metadataProjectionOfPredicateMarker: MetadataProjectionOfPredicateMarker) : + AccountProjectionOfPredicateMarker() { + 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.AccountProjectionOfPredicateMarker.Metadata = + try { + Metadata( + MetadataProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AccountProjectionOfPredicateMarker.Metadata, + ): Unit = try { + MetadataProjectionOfPredicateMarker.write(writer, instance.metadataProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AccountProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Id.read(reader) + 2 -> Metadata.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AccountProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Id.write(writer, instance as Id) + 2 -> 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/AccountProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..654ed8430 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountProjectionOfSelectorMarker.kt @@ -0,0 +1,154 @@ +// +// 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 + +/** + * AccountProjectionOfSelectorMarker + * + * Generated from 'AccountProjectionOfSelectorMarker' enum + */ +public sealed class AccountProjectionOfSelectorMarker : 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 : AccountProjectionOfSelectorMarker() { + 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.AccountProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AccountProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.AccountProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".AccountProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Id' variant + */ + public data class Id(public val accountIdProjectionOfSelectorMarker: AccountIdProjectionOfSelectorMarker) : + AccountProjectionOfSelectorMarker() { + 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.AccountProjectionOfSelectorMarker.Id = try { + Id( + AccountIdProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AccountProjectionOfSelectorMarker.Id, + ): Unit = try { + AccountIdProjectionOfSelectorMarker.write(writer, instance.accountIdProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Metadata' variant + */ + public data class Metadata(public val metadataProjectionOfSelectorMarker: MetadataProjectionOfSelectorMarker) : + AccountProjectionOfSelectorMarker() { + 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.AccountProjectionOfSelectorMarker.Metadata = try { + Metadata( + MetadataProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AccountProjectionOfSelectorMarker.Metadata, + ): Unit = try { + MetadataProjectionOfSelectorMarker.write(writer, instance.metadataProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AccountProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Id.read(reader) + 2 -> Metadata.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AccountProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Id.write(writer, instance as Id) + 2 -> 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/AccountRoleChanged.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountRoleChanged.kt index f3d9abe99..dbe58d6fb 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountRoleChanged.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountRoleChanged.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'AccountRoleChanged' regular structure */ -public data class AccountRoleChanged( - public val account: AccountId, - public val role: RoleId, -) { +public data class AccountRoleChanged(public val account: AccountId, public val role: RoleId) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): AccountRoleChanged = try { AccountRoleChanged( 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/AccountPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfPredicateMarker.kt similarity index 50% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfPredicateMarker.kt index 1636d2ec0..160d44f8e 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfPredicateMarker.kt @@ -13,32 +13,30 @@ import kotlin.Int import kotlin.Unit /** - * AccountPredicateBox + * ActionProjectionOfPredicateMarker * - * Generated from 'AccountPredicateBox' enum + * Generated from 'ActionProjectionOfPredicateMarker' enum */ -public sealed class AccountPredicateBox : ModelEnum { +public sealed class ActionProjectionOfPredicateMarker : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int /** - * 'Id' variant + * 'Atom' variant */ - public data class Id( - public val accountIdPredicateBox: AccountIdPredicateBox, - ) : AccountPredicateBox() { + public data class Atom(public val actionPredicateAtom: ActionPredicateAtom) : ActionProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountPredicateBox.Id = try { - Id( - AccountIdPredicateBox.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ActionProjectionOfPredicateMarker.Atom = try { + Atom( + ActionPredicateAtom.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -46,9 +44,9 @@ public sealed class AccountPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountPredicateBox.Id, + instance: jp.co.soramitsu.iroha2.generated.ActionProjectionOfPredicateMarker.Atom, ): Unit = try { - AccountIdPredicateBox.write(writer, instance.accountIdPredicateBox) + ActionPredicateAtom.write(writer, instance.actionPredicateAtom) } catch (ex: Exception) { throw wrapException(ex) } @@ -58,19 +56,18 @@ public sealed class AccountPredicateBox : ModelEnum { /** * 'Metadata' variant */ - public data class Metadata( - public val metadataPredicateBox: MetadataPredicateBox, - ) : AccountPredicateBox() { + public data class Metadata(public val metadataProjectionOfPredicateMarker: MetadataProjectionOfPredicateMarker) : + ActionProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountPredicateBox.Metadata = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ActionProjectionOfPredicateMarker.Metadata = try { Metadata( - MetadataPredicateBox.read(reader), + MetadataProjectionOfPredicateMarker.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -78,30 +75,31 @@ public sealed class AccountPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountPredicateBox.Metadata, + instance: jp.co.soramitsu.iroha2.generated.ActionProjectionOfPredicateMarker.Metadata, ): Unit = try { - MetadataPredicateBox.write(writer, instance.metadataPredicateBox) + MetadataProjectionOfPredicateMarker.write(writer, instance.metadataProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } } } - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AccountPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Id.read(reader) + 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") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: AccountPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: ActionProjectionOfPredicateMarker) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Id.write(writer, instance as Id) + 0 -> Atom.write(writer, instance as Atom) 1 -> Metadata.write(writer, instance as Metadata) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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/Algorithm.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Algorithm.kt index b11eb10b5..cd9c6679a 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Algorithm.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Algorithm.kt @@ -30,14 +30,16 @@ public sealed class Algorithm : ModelEnum { is Secp256k1 -> Secp256k1.equals(this, other) is BlsNormal -> BlsNormal.equals(this, other) is BlsSmall -> BlsSmall.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is Ed25519 -> Ed25519.hashCode() is Secp256k1 -> Secp256k1.hashCode() is BlsNormal -> BlsNormal.hashCode() is BlsSmall -> BlsSmall.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'Ed25519' variant @@ -56,19 +58,15 @@ public sealed class Algorithm : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Algorithm.Ed25519, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Algorithm.Ed25519): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: jp.co.soramitsu.iroha2.generated.Algorithm.Ed25519, o2: Any?): Boolean = - when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals(o1: jp.co.soramitsu.iroha2.generated.Algorithm.Ed25519, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Algorithm.Ed25519".hashCode() } @@ -91,10 +89,7 @@ public sealed class Algorithm : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Algorithm.Secp256k1, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Algorithm.Secp256k1): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -125,10 +120,7 @@ public sealed class Algorithm : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Algorithm.BlsNormal, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Algorithm.BlsNormal): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -159,10 +151,7 @@ public sealed class Algorithm : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Algorithm.BlsSmall, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Algorithm.BlsSmall): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -177,15 +166,13 @@ public sealed class Algorithm : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Algorithm = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): Algorithm = when (val discriminant = reader.readUByte()) { 0 -> Ed25519.read(reader) 1 -> Secp256k1.read(reader) 2 -> BlsNormal.read(reader) 3 -> BlsSmall.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: Algorithm) { writer.directWrite(instance.discriminant()) @@ -194,7 +181,8 @@ public sealed class Algorithm : ModelEnum { 1 -> Secp256k1.write(writer, instance as Secp256k1) 2 -> BlsNormal.write(writer, instance as BlsNormal) 3 -> BlsSmall.write(writer, instance as BlsSmall) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Asset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Asset.kt index 2769ea857..eda0c20f0 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Asset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Asset.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'Asset' regular structure */ -public data class Asset( - public val id: AssetId, - public val `value`: AssetValue, -) { +public data class Asset(public val id: AssetId, public val `value`: AssetValue) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Asset = try { Asset( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetChanged.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetChanged.kt index 0c74cd6e7..b4cb5c1a3 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetChanged.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetChanged.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'AssetChanged' regular structure */ -public data class AssetChanged( - public val asset: AssetId, - public val amount: AssetValue, -) { +public data class AssetChanged(public val asset: AssetId, public val amount: AssetValue) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): AssetChanged = try { AssetChanged( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinition.kt index 87f4be6e8..1004a026c 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinition.kt @@ -22,6 +22,7 @@ public data class AssetDefinition( public val logo: IpfsPath? = null, public val metadata: Metadata, public val ownedBy: AccountId, + public val totalQuantity: Numeric, ) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): AssetDefinition = try { @@ -32,6 +33,7 @@ public data class AssetDefinition( reader.readNullable(IpfsPath) as IpfsPath?, Metadata.read(reader), AccountId.read(reader), + Numeric.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -44,6 +46,7 @@ public data class AssetDefinition( writer.writeNullable(IpfsPath, instance.logo) Metadata.write(writer, instance.metadata) AccountId.write(writer, instance.ownedBy) + Numeric.write(writer, instance.totalQuantity) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionEvent.kt index bb6ca7be5..7e1cb983f 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionEvent.kt @@ -26,9 +26,7 @@ public sealed class AssetDefinitionEvent : ModelEnum { /** * 'Created' variant */ - public data class Created( - public val assetDefinition: AssetDefinition, - ) : AssetDefinitionEvent() { + public data class Created(public val assetDefinition: AssetDefinition) : AssetDefinitionEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,23 +42,19 @@ public sealed class AssetDefinitionEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.Created, - ): Unit = try { - AssetDefinition.write(writer, instance.assetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.Created): Unit = + try { + AssetDefinition.write(writer, instance.assetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Deleted' variant */ - public data class Deleted( - public val assetDefinitionId: AssetDefinitionId, - ) : AssetDefinitionEvent() { + public data class Deleted(public val assetDefinitionId: AssetDefinitionId) : AssetDefinitionEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,23 +70,20 @@ public sealed class AssetDefinitionEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.Deleted, - ): Unit = try { - AssetDefinitionId.write(writer, instance.assetDefinitionId) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.Deleted): Unit = + try { + AssetDefinitionId.write(writer, instance.assetDefinitionId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'MetadataInserted' variant */ - public data class MetadataInserted( - public val metadataChangedOfAssetDefinitionId: MetadataChangedOfAssetDefinitionId, - ) : AssetDefinitionEvent() { + public data class MetadataInserted(public val metadataChangedOfAssetDefinitionId: MetadataChangedOfAssetDefinitionId) : + AssetDefinitionEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -111,24 +102,19 @@ public sealed class AssetDefinitionEvent : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.MetadataInserted, - ): Unit = - try { - MetadataChangedOfAssetDefinitionId.write( - writer, - instance.metadataChangedOfAssetDefinitionId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = try { + MetadataChangedOfAssetDefinitionId.write(writer, instance.metadataChangedOfAssetDefinitionId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'MetadataRemoved' variant */ - public data class MetadataRemoved( - public val metadataChangedOfAssetDefinitionId: MetadataChangedOfAssetDefinitionId, - ) : AssetDefinitionEvent() { + public data class MetadataRemoved(public val metadataChangedOfAssetDefinitionId: MetadataChangedOfAssetDefinitionId) : + AssetDefinitionEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -147,24 +133,18 @@ public sealed class AssetDefinitionEvent : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.MetadataRemoved, - ): Unit = - try { - MetadataChangedOfAssetDefinitionId.write( - writer, - instance.metadataChangedOfAssetDefinitionId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = try { + MetadataChangedOfAssetDefinitionId.write(writer, instance.metadataChangedOfAssetDefinitionId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'MintabilityChanged' variant */ - public data class MintabilityChanged( - public val assetDefinitionId: AssetDefinitionId, - ) : AssetDefinitionEvent() { + public data class MintabilityChanged(public val assetDefinitionId: AssetDefinitionId) : AssetDefinitionEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -194,9 +174,8 @@ public sealed class AssetDefinitionEvent : ModelEnum { /** * 'TotalQuantityChanged' variant */ - public data class TotalQuantityChanged( - public val assetDefinitionTotalQuantityChanged: AssetDefinitionTotalQuantityChanged, - ) : AssetDefinitionEvent() { + public data class TotalQuantityChanged(public val assetDefinitionTotalQuantityChanged: AssetDefinitionTotalQuantityChanged) : + AssetDefinitionEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -216,10 +195,7 @@ public sealed class AssetDefinitionEvent : ModelEnum { writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.TotalQuantityChanged, ): Unit = try { - AssetDefinitionTotalQuantityChanged.write( - writer, - instance.assetDefinitionTotalQuantityChanged, - ) + AssetDefinitionTotalQuantityChanged.write(writer, instance.assetDefinitionTotalQuantityChanged) } catch (ex: Exception) { throw wrapException(ex) } @@ -229,9 +205,7 @@ public sealed class AssetDefinitionEvent : ModelEnum { /** * 'OwnerChanged' variant */ - public data class OwnerChanged( - public val assetDefinitionOwnerChanged: AssetDefinitionOwnerChanged, - ) : AssetDefinitionEvent() { + public data class OwnerChanged(public val assetDefinitionOwnerChanged: AssetDefinitionOwnerChanged) : AssetDefinitionEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -259,10 +233,7 @@ public sealed class AssetDefinitionEvent : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetDefinitionEvent = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): AssetDefinitionEvent = when (val discriminant = reader.readUByte()) { 0 -> Created.read(reader) 1 -> Deleted.read(reader) 2 -> MetadataInserted.read(reader) @@ -270,7 +241,8 @@ public sealed class AssetDefinitionEvent : ModelEnum { 4 -> MintabilityChanged.read(reader) 5 -> TotalQuantityChanged.read(reader) 6 -> OwnerChanged.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionEvent) { writer.directWrite(instance.discriminant()) @@ -282,7 +254,8 @@ public sealed class AssetDefinitionEvent : ModelEnum { 4 -> MintabilityChanged.write(writer, instance as MintabilityChanged) 5 -> TotalQuantityChanged.write(writer, instance as TotalQuantityChanged) 6 -> OwnerChanged.write(writer, instance as OwnerChanged) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionEventFilter.kt index c92a5b292..fb695b508 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionEventFilter.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'AssetDefinitionEventFilter' regular structure */ -public data class AssetDefinitionEventFilter( - public val idMatcher: AssetDefinitionId? = null, - public val eventSet: Long, -) { +public data class AssetDefinitionEventFilter(public val idMatcher: AssetDefinitionId? = null, public val eventSet: Long) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionId.kt index 137949bc7..6398cf5c2 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionId.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'AssetDefinitionId' regular structure */ -public data class AssetDefinitionId( - public val domain: DomainId, - public val name: Name, -) { +public data class AssetDefinitionId(public val domain: DomainId, public val name: Name) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): AssetDefinitionId = try { AssetDefinitionId( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdPredicateAtom.kt new file mode 100644 index 000000000..0a1fd7aaf --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdPredicateAtom.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 + +/** + * AssetDefinitionIdPredicateAtom + * + * Generated from 'AssetDefinitionIdPredicateAtom' enum + */ +public sealed class AssetDefinitionIdPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Equals' variant + */ + public data class Equals(public val assetDefinitionId: AssetDefinitionId) : AssetDefinitionIdPredicateAtom() { + 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.AssetDefinitionIdPredicateAtom.Equals = try { + Equals( + AssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionIdPredicateAtom.Equals, + ): Unit = try { + AssetDefinitionId.write(writer, instance.assetDefinitionId) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AssetDefinitionIdPredicateAtom = 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: AssetDefinitionIdPredicateAtom) { + 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/AssetDefinitionIdPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdPredicateBox.kt deleted file mode 100644 index b0bccd122..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdPredicateBox.kt +++ /dev/null @@ -1,145 +0,0 @@ -// -// 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 - -/** - * AssetDefinitionIdPredicateBox - * - * Generated from 'AssetDefinitionIdPredicateBox' enum - */ -public sealed class AssetDefinitionIdPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Equals' variant - */ - public data class Equals( - public val assetDefinitionId: AssetDefinitionId, - ) : AssetDefinitionIdPredicateBox() { - 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.AssetDefinitionIdPredicateBox.Equals = try { - Equals( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionIdPredicateBox.Equals, - ): Unit = - try { - AssetDefinitionId.write(writer, instance.assetDefinitionId) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'DomainId' variant - */ - public data class DomainId( - public val domainIdPredicateBox: DomainIdPredicateBox, - ) : AssetDefinitionIdPredicateBox() { - 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.AssetDefinitionIdPredicateBox.DomainId = try { - DomainId( - DomainIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionIdPredicateBox.DomainId, - ): Unit = - try { - DomainIdPredicateBox.write(writer, instance.domainIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Name' variant - */ - public data class Name( - public val stringPredicateBox: StringPredicateBox, - ) : AssetDefinitionIdPredicateBox() { - 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.AssetDefinitionIdPredicateBox.Name = try { - Name( - StringPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionIdPredicateBox.Name, - ): Unit = try { - StringPredicateBox.write(writer, instance.stringPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetDefinitionIdPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { - 0 -> Equals.read(reader) - 1 -> DomainId.read(reader) - 2 -> Name.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionIdPredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Equals.write(writer, instance as Equals) - 1 -> DomainId.write(writer, instance as DomainId) - 2 -> Name.write(writer, instance as Name) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..dde28d5b7 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdProjectionOfPredicateMarker.kt @@ -0,0 +1,146 @@ +// +// 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 + +/** + * AssetDefinitionIdProjectionOfPredicateMarker + * + * Generated from 'AssetDefinitionIdProjectionOfPredicateMarker' enum + */ +public sealed class AssetDefinitionIdProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val assetDefinitionIdPredicateAtom: AssetDefinitionIdPredicateAtom) : + AssetDefinitionIdProjectionOfPredicateMarker() { + 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.AssetDefinitionIdProjectionOfPredicateMarker.Atom = try { + Atom( + AssetDefinitionIdPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionIdProjectionOfPredicateMarker.Atom, + ): Unit = try { + AssetDefinitionIdPredicateAtom.write(writer, instance.assetDefinitionIdPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Domain' variant + */ + public data class Domain(public val domainIdProjectionOfPredicateMarker: DomainIdProjectionOfPredicateMarker) : + AssetDefinitionIdProjectionOfPredicateMarker() { + 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.AssetDefinitionIdProjectionOfPredicateMarker.Domain = try { + Domain( + DomainIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionIdProjectionOfPredicateMarker.Domain, + ): Unit = try { + DomainIdProjectionOfPredicateMarker.write(writer, instance.domainIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Name' variant + */ + public data class Name(public val nameProjectionOfPredicateMarker: NameProjectionOfPredicateMarker) : + AssetDefinitionIdProjectionOfPredicateMarker() { + 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.AssetDefinitionIdProjectionOfPredicateMarker.Name = try { + Name( + NameProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionIdProjectionOfPredicateMarker.Name, + ): Unit = try { + NameProjectionOfPredicateMarker.write(writer, instance.nameProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AssetDefinitionIdProjectionOfPredicateMarker = + when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Domain.read(reader) + 2 -> Name.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionIdProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Domain.write(writer, instance as Domain) + 2 -> Name.write(writer, instance as Name) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..b10b57ee8 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdProjectionOfSelectorMarker.kt @@ -0,0 +1,160 @@ +// +// 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 + +/** + * AssetDefinitionIdProjectionOfSelectorMarker + * + * Generated from 'AssetDefinitionIdProjectionOfSelectorMarker' enum + */ +public sealed class AssetDefinitionIdProjectionOfSelectorMarker : 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 : AssetDefinitionIdProjectionOfSelectorMarker() { + 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.AssetDefinitionIdProjectionOfSelectorMarker.Atom = + try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionIdProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.AssetDefinitionIdProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".AssetDefinitionIdProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Domain' variant + */ + public data class Domain(public val domainIdProjectionOfSelectorMarker: DomainIdProjectionOfSelectorMarker) : + AssetDefinitionIdProjectionOfSelectorMarker() { + 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.AssetDefinitionIdProjectionOfSelectorMarker.Domain = try { + Domain( + DomainIdProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionIdProjectionOfSelectorMarker.Domain, + ): Unit = try { + DomainIdProjectionOfSelectorMarker.write(writer, instance.domainIdProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Name' variant + */ + public data class Name(public val nameProjectionOfSelectorMarker: NameProjectionOfSelectorMarker) : + AssetDefinitionIdProjectionOfSelectorMarker() { + 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.AssetDefinitionIdProjectionOfSelectorMarker.Name = + try { + Name( + NameProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionIdProjectionOfSelectorMarker.Name, + ): Unit = try { + NameProjectionOfSelectorMarker.write(writer, instance.nameProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AssetDefinitionIdProjectionOfSelectorMarker = + when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Domain.read(reader) + 2 -> Name.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionIdProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Domain.write(writer, instance as Domain) + 2 -> Name.write(writer, instance as Name) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionOwnerChanged.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionOwnerChanged.kt index 31a7926c6..4a513e5f9 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionOwnerChanged.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionOwnerChanged.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'AssetDefinitionOwnerChanged' regular structure */ -public data class AssetDefinitionOwnerChanged( - public val assetDefinition: AssetDefinitionId, - public val newOwner: AccountId, -) { +public data class AssetDefinitionOwnerChanged(public val assetDefinition: AssetDefinitionId, public val newOwner: AccountId) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionPredicateAtom.kt new file mode 100644 index 000000000..255d32b22 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionPredicateAtom.kt @@ -0,0 +1,38 @@ +// +// 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 + +/** + * AssetDefinitionPredicateAtom + * + * Generated from 'AssetDefinitionPredicateAtom' enum + */ +public sealed class AssetDefinitionPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AssetDefinitionPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionPredicateAtom) { + 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/AssetDefinitionPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionProjectionOfPredicateMarker.kt similarity index 52% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionProjectionOfPredicateMarker.kt index b020e0d45..3fdb45a34 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionProjectionOfPredicateMarker.kt @@ -13,42 +13,42 @@ import kotlin.Int import kotlin.Unit /** - * AssetDefinitionPredicateBox + * AssetDefinitionProjectionOfPredicateMarker * - * Generated from 'AssetDefinitionPredicateBox' enum + * Generated from 'AssetDefinitionProjectionOfPredicateMarker' enum */ -public sealed class AssetDefinitionPredicateBox : ModelEnum { +public sealed class AssetDefinitionProjectionOfPredicateMarker : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int /** - * 'Id' variant + * 'Atom' variant */ - public data class Id( - public val assetDefinitionIdPredicateBox: AssetDefinitionIdPredicateBox, - ) : AssetDefinitionPredicateBox() { + public data class Atom(public val assetDefinitionPredicateAtom: AssetDefinitionPredicateAtom) : + AssetDefinitionProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionPredicateBox.Id = try { - Id( - AssetDefinitionIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfPredicateMarker.Atom = + try { + Atom( + AssetDefinitionPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionPredicateBox.Id, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfPredicateMarker.Atom, ): Unit = try { - AssetDefinitionIdPredicateBox.write(writer, instance.assetDefinitionIdPredicateBox) + AssetDefinitionPredicateAtom.write(writer, instance.assetDefinitionPredicateAtom) } catch (ex: Exception) { throw wrapException(ex) } @@ -56,54 +56,54 @@ public sealed class AssetDefinitionPredicateBox : ModelEnum { } /** - * 'Metadata' variant + * 'Id' variant */ - public data class Metadata( - public val metadataPredicateBox: MetadataPredicateBox, - ) : AssetDefinitionPredicateBox() { + public data class Id(public val assetDefinitionIdProjectionOfPredicateMarker: AssetDefinitionIdProjectionOfPredicateMarker) : + AssetDefinitionProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionPredicateBox.Metadata = try { - Metadata( - MetadataPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionPredicateBox.Metadata, - ): Unit = + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfPredicateMarker.Id = try { - MetadataPredicateBox.write(writer, instance.metadataPredicateBox) + Id( + AssetDefinitionIdProjectionOfPredicateMarker.read(reader), + ) } catch (ex: Exception) { throw wrapException(ex) } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfPredicateMarker.Id, + ): Unit = try { + AssetDefinitionIdProjectionOfPredicateMarker.write(writer, instance.assetDefinitionIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'OwnedBy' variant + * 'Metadata' variant */ - public data class OwnedBy( - public val accountIdPredicateBox: AccountIdPredicateBox, - ) : AssetDefinitionPredicateBox() { + public data class Metadata(public val metadataProjectionOfPredicateMarker: MetadataProjectionOfPredicateMarker) : + AssetDefinitionProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionPredicateBox.OwnedBy = try { - OwnedBy( - AccountIdPredicateBox.read(reader), + override fun read( + reader: ScaleCodecReader, + ): jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfPredicateMarker.Metadata = try { + Metadata( + MetadataProjectionOfPredicateMarker.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -111,35 +111,34 @@ public sealed class AssetDefinitionPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionPredicateBox.OwnedBy, - ): Unit = - try { - AccountIdPredicateBox.write(writer, instance.accountIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfPredicateMarker.Metadata, + ): Unit = try { + MetadataProjectionOfPredicateMarker.write(writer, instance.metadataProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetDefinitionPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Id.read(reader) - 1 -> Metadata.read(reader) - 2 -> OwnedBy.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionPredicateBox) { + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AssetDefinitionProjectionOfPredicateMarker = + when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Id.read(reader) + 2 -> Metadata.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionProjectionOfPredicateMarker) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Id.write(writer, instance as Id) - 1 -> Metadata.write(writer, instance as Metadata) - 2 -> OwnedBy.write(writer, instance as OwnedBy) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 0 -> Atom.write(writer, instance as Atom) + 1 -> Id.write(writer, instance as Id) + 2 -> 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/AssetDefinitionProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..ecd3f6f51 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionProjectionOfSelectorMarker.kt @@ -0,0 +1,160 @@ +// +// 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 + +/** + * AssetDefinitionProjectionOfSelectorMarker + * + * Generated from 'AssetDefinitionProjectionOfSelectorMarker' enum + */ +public sealed class AssetDefinitionProjectionOfSelectorMarker : 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 : AssetDefinitionProjectionOfSelectorMarker() { + 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.AssetDefinitionProjectionOfSelectorMarker.Atom = + try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".AssetDefinitionProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Id' variant + */ + public data class Id(public val assetDefinitionIdProjectionOfSelectorMarker: AssetDefinitionIdProjectionOfSelectorMarker) : + AssetDefinitionProjectionOfSelectorMarker() { + 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.AssetDefinitionProjectionOfSelectorMarker.Id = + try { + Id( + AssetDefinitionIdProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfSelectorMarker.Id, + ): Unit = try { + AssetDefinitionIdProjectionOfSelectorMarker.write(writer, instance.assetDefinitionIdProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Metadata' variant + */ + public data class Metadata(public val metadataProjectionOfSelectorMarker: MetadataProjectionOfSelectorMarker) : + AssetDefinitionProjectionOfSelectorMarker() { + 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.AssetDefinitionProjectionOfSelectorMarker.Metadata = try { + Metadata( + MetadataProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfSelectorMarker.Metadata, + ): Unit = try { + MetadataProjectionOfSelectorMarker.write(writer, instance.metadataProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AssetDefinitionProjectionOfSelectorMarker = + when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Id.read(reader) + 2 -> Metadata.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Id.write(writer, instance as Id) + 2 -> 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/AssetDefinitionTotalQuantityChanged.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionTotalQuantityChanged.kt index cff71594e..21ac7df8d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionTotalQuantityChanged.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionTotalQuantityChanged.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'AssetDefinitionTotalQuantityChanged' regular structure */ -public data class AssetDefinitionTotalQuantityChanged( - public val assetDefinition: AssetDefinitionId, - public val totalAmount: Numeric, -) { +public data class AssetDefinitionTotalQuantityChanged(public val assetDefinition: AssetDefinitionId, public val totalAmount: Numeric) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetEvent.kt index bbfc5887f..12a7a71e2 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetEvent.kt @@ -26,9 +26,7 @@ public sealed class AssetEvent : ModelEnum { /** * 'Created' variant */ - public data class Created( - public val asset: Asset, - ) : AssetEvent() { + public data class Created(public val asset: Asset) : AssetEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class AssetEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetEvent.Created, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetEvent.Created): Unit = try { Asset.write(writer, instance.asset) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class AssetEvent : ModelEnum { /** * 'Deleted' variant */ - public data class Deleted( - public val assetId: AssetId, - ) : AssetEvent() { + public data class Deleted(public val assetId: AssetId) : AssetEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class AssetEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetEvent.Deleted, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetEvent.Deleted): Unit = try { AssetId.write(writer, instance.assetId) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class AssetEvent : ModelEnum { /** * 'Added' variant */ - public data class Added( - public val assetChanged: AssetChanged, - ) : AssetEvent() { + public data class Added(public val assetChanged: AssetChanged) : AssetEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,10 +96,7 @@ public sealed class AssetEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetEvent.Added, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetEvent.Added): Unit = try { AssetChanged.write(writer, instance.assetChanged) } catch (ex: Exception) { throw wrapException(ex) @@ -122,9 +107,7 @@ public sealed class AssetEvent : ModelEnum { /** * 'Removed' variant */ - public data class Removed( - public val assetChanged: AssetChanged, - ) : AssetEvent() { + public data class Removed(public val assetChanged: AssetChanged) : AssetEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,10 +123,7 @@ public sealed class AssetEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetEvent.Removed, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetEvent.Removed): Unit = try { AssetChanged.write(writer, instance.assetChanged) } catch (ex: Exception) { throw wrapException(ex) @@ -154,9 +134,7 @@ public sealed class AssetEvent : ModelEnum { /** * 'MetadataInserted' variant */ - public data class MetadataInserted( - public val metadataChangedOfAssetId: MetadataChangedOfAssetId, - ) : AssetEvent() { + public data class MetadataInserted(public val metadataChangedOfAssetId: MetadataChangedOfAssetId) : AssetEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -172,23 +150,19 @@ public sealed class AssetEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetEvent.MetadataInserted, - ): Unit = try { - MetadataChangedOfAssetId.write(writer, instance.metadataChangedOfAssetId) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetEvent.MetadataInserted): Unit = + try { + MetadataChangedOfAssetId.write(writer, instance.metadataChangedOfAssetId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'MetadataRemoved' variant */ - public data class MetadataRemoved( - public val metadataChangedOfAssetId: MetadataChangedOfAssetId, - ) : AssetEvent() { + public data class MetadataRemoved(public val metadataChangedOfAssetId: MetadataChangedOfAssetId) : AssetEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -204,29 +178,25 @@ public sealed class AssetEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetEvent.MetadataRemoved, - ): Unit = try { - MetadataChangedOfAssetId.write(writer, instance.metadataChangedOfAssetId) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetEvent.MetadataRemoved): Unit = + try { + MetadataChangedOfAssetId.write(writer, instance.metadataChangedOfAssetId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetEvent = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): AssetEvent = when (val discriminant = reader.readUByte()) { 0 -> Created.read(reader) 1 -> Deleted.read(reader) 2 -> Added.read(reader) 3 -> Removed.read(reader) 4 -> MetadataInserted.read(reader) 5 -> MetadataRemoved.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: AssetEvent) { writer.directWrite(instance.discriminant()) @@ -237,7 +207,8 @@ public sealed class AssetEvent : ModelEnum { 3 -> Removed.write(writer, instance as Removed) 4 -> MetadataInserted.write(writer, instance as MetadataInserted) 5 -> MetadataRemoved.write(writer, instance as MetadataRemoved) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetEventFilter.kt index 19d220c19..78b90d40d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetEventFilter.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'AssetEventFilter' regular structure */ -public data class AssetEventFilter( - public val idMatcher: AssetId? = null, - public val eventSet: Long, -) { +public data class AssetEventFilter(public val idMatcher: AssetId? = null, public val eventSet: Long) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): AssetEventFilter = try { AssetEventFilter( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetId.kt index 1c7b14900..aa3784f85 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetId.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'AssetId' regular structure */ -public data class AssetId( - public val account: AccountId, - public val definition: AssetDefinitionId, -) { +public data class AssetId(public val account: AccountId, public val definition: AssetDefinitionId) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): AssetId = try { AssetId( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdPredicateAtom.kt new file mode 100644 index 000000000..d5bcf1501 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdPredicateAtom.kt @@ -0,0 +1,68 @@ +// +// 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 + +/** + * AssetIdPredicateAtom + * + * Generated from 'AssetIdPredicateAtom' enum + */ +public sealed class AssetIdPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Equals' variant + */ + public data class Equals(public val assetId: AssetId) : AssetIdPredicateAtom() { + 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.AssetIdPredicateAtom.Equals = try { + Equals( + AssetId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetIdPredicateAtom.Equals): Unit = + try { + AssetId.write(writer, instance.assetId) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): AssetIdPredicateAtom = 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: AssetIdPredicateAtom) { + 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/AssetIdPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdProjectionOfPredicateMarker.kt similarity index 52% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdProjectionOfPredicateMarker.kt index 0150bef74..891bca49d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdProjectionOfPredicateMarker.kt @@ -13,32 +13,30 @@ import kotlin.Int import kotlin.Unit /** - * AssetIdPredicateBox + * AssetIdProjectionOfPredicateMarker * - * Generated from 'AssetIdPredicateBox' enum + * Generated from 'AssetIdProjectionOfPredicateMarker' enum */ -public sealed class AssetIdPredicateBox : ModelEnum { +public sealed class AssetIdProjectionOfPredicateMarker : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int /** - * 'Equals' variant + * 'Atom' variant */ - public data class Equals( - public val assetId: AssetId, - ) : AssetIdPredicateBox() { + public data class Atom(public val assetIdPredicateAtom: AssetIdPredicateAtom) : AssetIdProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetIdPredicateBox.Equals = try { - Equals( - AssetId.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker.Atom = try { + Atom( + AssetIdPredicateAtom.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -46,9 +44,9 @@ public sealed class AssetIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetIdPredicateBox.Equals, + instance: jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker.Atom, ): Unit = try { - AssetId.write(writer, instance.assetId) + AssetIdPredicateAtom.write(writer, instance.assetIdPredicateAtom) } catch (ex: Exception) { throw wrapException(ex) } @@ -56,21 +54,20 @@ public sealed class AssetIdPredicateBox : ModelEnum { } /** - * 'DefinitionId' variant + * 'Account' variant */ - public data class DefinitionId( - public val assetDefinitionIdPredicateBox: AssetDefinitionIdPredicateBox, - ) : AssetIdPredicateBox() { + public data class Account(public val accountIdProjectionOfPredicateMarker: AccountIdProjectionOfPredicateMarker) : + AssetIdProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetIdPredicateBox.DefinitionId = try { - DefinitionId( - AssetDefinitionIdPredicateBox.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker.Account = try { + Account( + AccountIdProjectionOfPredicateMarker.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -78,9 +75,9 @@ public sealed class AssetIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetIdPredicateBox.DefinitionId, + instance: jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker.Account, ): Unit = try { - AssetDefinitionIdPredicateBox.write(writer, instance.assetDefinitionIdPredicateBox) + AccountIdProjectionOfPredicateMarker.write(writer, instance.accountIdProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } @@ -88,54 +85,55 @@ public sealed class AssetIdPredicateBox : ModelEnum { } /** - * 'AccountId' variant + * 'Definition' variant */ - public data class AccountId( - public val accountIdPredicateBox: AccountIdPredicateBox, - ) : AssetIdPredicateBox() { + public data class Definition(public val assetDefinitionIdProjectionOfPredicateMarker: AssetDefinitionIdProjectionOfPredicateMarker) : + AssetIdProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetIdPredicateBox.AccountId = try { - AccountId( - AccountIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker.Definition = + try { + Definition( + AssetDefinitionIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetIdPredicateBox.AccountId, + instance: jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker.Definition, ): Unit = try { - AccountIdPredicateBox.write(writer, instance.accountIdPredicateBox) + AssetDefinitionIdProjectionOfPredicateMarker.write(writer, instance.assetDefinitionIdProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } } } - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetIdPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Equals.read(reader) - 1 -> DefinitionId.read(reader) - 2 -> AccountId.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: AssetIdPredicateBox) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AssetIdProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Account.read(reader) + 2 -> Definition.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AssetIdProjectionOfPredicateMarker) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Equals.write(writer, instance as Equals) - 1 -> DefinitionId.write(writer, instance as DefinitionId) - 2 -> AccountId.write(writer, instance as AccountId) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 0 -> Atom.write(writer, instance as Atom) + 1 -> Account.write(writer, instance as Account) + 2 -> Definition.write(writer, instance as Definition) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..79d7a50c9 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdProjectionOfSelectorMarker.kt @@ -0,0 +1,155 @@ +// +// 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 + +/** + * AssetIdProjectionOfSelectorMarker + * + * Generated from 'AssetIdProjectionOfSelectorMarker' enum + */ +public sealed class AssetIdProjectionOfSelectorMarker : 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 : AssetIdProjectionOfSelectorMarker() { + 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.AssetIdProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".AssetIdProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Account' variant + */ + public data class Account(public val accountIdProjectionOfSelectorMarker: AccountIdProjectionOfSelectorMarker) : + AssetIdProjectionOfSelectorMarker() { + 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.AssetIdProjectionOfSelectorMarker.Account = try { + Account( + AccountIdProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfSelectorMarker.Account, + ): Unit = try { + AccountIdProjectionOfSelectorMarker.write(writer, instance.accountIdProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Definition' variant + */ + public data class Definition(public val assetDefinitionIdProjectionOfSelectorMarker: AssetDefinitionIdProjectionOfSelectorMarker) : + AssetIdProjectionOfSelectorMarker() { + 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.AssetIdProjectionOfSelectorMarker.Definition = + try { + Definition( + AssetDefinitionIdProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfSelectorMarker.Definition, + ): Unit = try { + AssetDefinitionIdProjectionOfSelectorMarker.write(writer, instance.assetDefinitionIdProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AssetIdProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Account.read(reader) + 2 -> Definition.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AssetIdProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Account.write(writer, instance as Account) + 2 -> Definition.write(writer, instance as Definition) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetPredicateAtom.kt new file mode 100644 index 000000000..ca4123cbe --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetPredicateAtom.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 + +/** + * AssetPredicateAtom + * + * Generated from 'AssetPredicateAtom' enum + */ +public sealed class AssetPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): AssetPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AssetPredicateAtom) { + 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/AssetPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetPredicateBox.kt deleted file mode 100644 index 470905e05..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetPredicateBox.kt +++ /dev/null @@ -1,107 +0,0 @@ -// -// 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 - -/** - * AssetPredicateBox - * - * Generated from 'AssetPredicateBox' enum - */ -public sealed class AssetPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Id' variant - */ - public data class Id( - public val assetIdPredicateBox: AssetIdPredicateBox, - ) : AssetPredicateBox() { - 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.AssetPredicateBox.Id = try { - Id( - AssetIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetPredicateBox.Id, - ): Unit = try { - AssetIdPredicateBox.write(writer, instance.assetIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Value' variant - */ - public data class Value( - public val assetValuePredicateBox: AssetValuePredicateBox, - ) : AssetPredicateBox() { - 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.AssetPredicateBox.Value = try { - Value( - AssetValuePredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetPredicateBox.Value, - ): Unit = try { - AssetValuePredicateBox.write(writer, instance.assetValuePredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Id.read(reader) - 1 -> Value.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: AssetPredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Id.write(writer, instance as Id) - 1 -> Value.write(writer, instance as Value) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..5bd889179 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetProjectionOfPredicateMarker.kt @@ -0,0 +1,138 @@ +// +// 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 + +/** + * AssetProjectionOfPredicateMarker + * + * Generated from 'AssetProjectionOfPredicateMarker' enum + */ +public sealed class AssetProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val assetPredicateAtom: AssetPredicateAtom) : AssetProjectionOfPredicateMarker() { + 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.AssetProjectionOfPredicateMarker.Atom = try { + Atom( + AssetPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetProjectionOfPredicateMarker.Atom, + ): Unit = try { + AssetPredicateAtom.write(writer, instance.assetPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Id' variant + */ + public data class Id(public val assetIdProjectionOfPredicateMarker: AssetIdProjectionOfPredicateMarker) : + AssetProjectionOfPredicateMarker() { + 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.AssetProjectionOfPredicateMarker.Id = try { + Id( + AssetIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetProjectionOfPredicateMarker.Id, + ): Unit = try { + AssetIdProjectionOfPredicateMarker.write(writer, instance.assetIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Value' variant + */ + public data class Value(public val assetValueProjectionOfPredicateMarker: AssetValueProjectionOfPredicateMarker) : + AssetProjectionOfPredicateMarker() { + 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.AssetProjectionOfPredicateMarker.Value = try { + Value( + AssetValueProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetProjectionOfPredicateMarker.Value, + ): Unit = try { + AssetValueProjectionOfPredicateMarker.write(writer, instance.assetValueProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AssetProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Id.read(reader) + 2 -> Value.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AssetProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Id.write(writer, instance as Id) + 2 -> Value.write(writer, instance as Value) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..f92518c95 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetProjectionOfSelectorMarker.kt @@ -0,0 +1,154 @@ +// +// 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 + +/** + * AssetProjectionOfSelectorMarker + * + * Generated from 'AssetProjectionOfSelectorMarker' enum + */ +public sealed class AssetProjectionOfSelectorMarker : 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 : AssetProjectionOfSelectorMarker() { + 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.AssetProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.AssetProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".AssetProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Id' variant + */ + public data class Id(public val assetIdProjectionOfSelectorMarker: AssetIdProjectionOfSelectorMarker) : + AssetProjectionOfSelectorMarker() { + 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.AssetProjectionOfSelectorMarker.Id = try { + Id( + AssetIdProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetProjectionOfSelectorMarker.Id, + ): Unit = try { + AssetIdProjectionOfSelectorMarker.write(writer, instance.assetIdProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Value' variant + */ + public data class Value(public val assetValueProjectionOfSelectorMarker: AssetValueProjectionOfSelectorMarker) : + AssetProjectionOfSelectorMarker() { + 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.AssetProjectionOfSelectorMarker.Value = try { + Value( + AssetValueProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetProjectionOfSelectorMarker.Value, + ): Unit = try { + AssetValueProjectionOfSelectorMarker.write(writer, instance.assetValueProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): AssetProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Id.read(reader) + 2 -> Value.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: AssetProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Id.write(writer, instance as Id) + 2 -> Value.write(writer, instance as Value) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetTransferBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetTransferBox.kt index b3c7c1fba..10e91b272 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetTransferBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetTransferBox.kt @@ -26,9 +26,7 @@ public sealed class AssetTransferBox : ModelEnum { /** * 'Numeric' variant */ - public data class Numeric( - public val transferOfAssetAndNumericAndAccount: TransferOfAssetAndNumericAndAccount, - ) : AssetTransferBox() { + public data class Numeric(public val transferOfAssetAndNumericAndAccount: TransferOfAssetAndNumericAndAccount) : AssetTransferBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,14 +42,8 @@ public sealed class AssetTransferBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetTransferBox.Numeric, - ): Unit = try { - TransferOfAssetAndNumericAndAccount.write( - writer, - instance.transferOfAssetAndNumericAndAccount, - ) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetTransferBox.Numeric): Unit = try { + TransferOfAssetAndNumericAndAccount.write(writer, instance.transferOfAssetAndNumericAndAccount) } catch (ex: Exception) { throw wrapException(ex) } @@ -61,9 +53,7 @@ public sealed class AssetTransferBox : ModelEnum { /** * 'Store' variant */ - public data class Store( - public val transferOfAssetAndMetadataAndAccount: TransferOfAssetAndMetadataAndAccount, - ) : AssetTransferBox() { + public data class Store(public val transferOfAssetAndMetadataAndAccount: TransferOfAssetAndMetadataAndAccount) : AssetTransferBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -79,14 +69,8 @@ public sealed class AssetTransferBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetTransferBox.Store, - ): Unit = try { - TransferOfAssetAndMetadataAndAccount.write( - writer, - instance.transferOfAssetAndMetadataAndAccount, - ) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetTransferBox.Store): Unit = try { + TransferOfAssetAndMetadataAndAccount.write(writer, instance.transferOfAssetAndMetadataAndAccount) } catch (ex: Exception) { throw wrapException(ex) } @@ -94,20 +78,19 @@ public sealed class AssetTransferBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetTransferBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): AssetTransferBox = when (val discriminant = reader.readUByte()) { 0 -> Numeric.read(reader) 1 -> Store.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: AssetTransferBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Numeric.write(writer, instance as Numeric) 1 -> Store.write(writer, instance as Store) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetType.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetType.kt index e44697b25..84b1ce908 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetType.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetType.kt @@ -27,18 +27,18 @@ public sealed class AssetType : ModelEnum { override fun equals(other: Any?): Boolean = when (this) { is Store -> Store.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is Store -> Store.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'Numeric' variant */ - public data class Numeric( - public val numericSpec: NumericSpec, - ) : AssetType() { + public data class Numeric(public val numericSpec: NumericSpec) : AssetType() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -54,10 +54,7 @@ public sealed class AssetType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetType.Numeric, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetType.Numeric): Unit = try { NumericSpec.write(writer, instance.numericSpec) } catch (ex: Exception) { throw wrapException(ex) @@ -82,39 +79,34 @@ public sealed class AssetType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetType.Store, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetType.Store): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: jp.co.soramitsu.iroha2.generated.AssetType.Store, o2: Any?): Boolean = - when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals(o1: jp.co.soramitsu.iroha2.generated.AssetType.Store, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".AssetType.Store".hashCode() } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetType = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): AssetType = when (val discriminant = reader.readUByte()) { 0 -> Numeric.read(reader) 1 -> Store.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: AssetType) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Numeric.write(writer, instance as Numeric) 1 -> Store.write(writer, instance as Store) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValue.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValue.kt index c0a991359..7f94740d7 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValue.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValue.kt @@ -26,9 +26,7 @@ public sealed class AssetValue : ModelEnum { /** * 'Numeric' variant */ - public data class Numeric( - public val numeric: jp.co.soramitsu.iroha2.generated.Numeric, - ) : AssetValue() { + public data class Numeric(public val numeric: jp.co.soramitsu.iroha2.generated.Numeric) : AssetValue() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class AssetValue : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetValue.Numeric, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetValue.Numeric): Unit = try { jp.co.soramitsu.iroha2.generated.Numeric.write(writer, instance.numeric) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class AssetValue : ModelEnum { /** * 'Store' variant */ - public data class Store( - public val metadata: Metadata, - ) : AssetValue() { + public data class Store(public val metadata: Metadata) : AssetValue() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class AssetValue : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetValue.Store, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetValue.Store): Unit = try { Metadata.write(writer, instance.metadata) } catch (ex: Exception) { throw wrapException(ex) @@ -88,20 +78,19 @@ public sealed class AssetValue : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetValue = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): AssetValue = when (val discriminant = reader.readUByte()) { 0 -> Numeric.read(reader) 1 -> Store.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: AssetValue) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Numeric.write(writer, instance as Numeric) 1 -> Store.write(writer, instance as Store) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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 new file mode 100644 index 000000000..55bf945b4 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValuePredicateAtom.kt @@ -0,0 +1,124 @@ +// +// 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 + +/** + * AssetValuePredicateAtom + * + * Generated from 'AssetValuePredicateAtom' enum + */ +public sealed class AssetValuePredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + 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 new file mode 100644 index 000000000..50daba8dc --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValueProjectionOfPredicateMarker.kt @@ -0,0 +1,140 @@ +// +// 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 + +/** + * AssetValueProjectionOfPredicateMarker + * + * Generated from 'AssetValueProjectionOfPredicateMarker' enum + */ +public sealed class AssetValueProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val assetValuePredicateAtom: AssetValuePredicateAtom) : AssetValueProjectionOfPredicateMarker() { + 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.AssetValueProjectionOfPredicateMarker.Atom = try { + Atom( + AssetValuePredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetValueProjectionOfPredicateMarker.Atom, + ): Unit = try { + AssetValuePredicateAtom.write(writer, instance.assetValuePredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * '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") + } + + override fun write(writer: ScaleCodecWriter, instance: AssetValueProjectionOfPredicateMarker) { + 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 new file mode 100644 index 000000000..afcad4b20 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValueProjectionOfSelectorMarker.kt @@ -0,0 +1,156 @@ +// +// 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 + +/** + * AssetValueProjectionOfSelectorMarker + * + * Generated from 'AssetValueProjectionOfSelectorMarker' enum + */ +public sealed class AssetValueProjectionOfSelectorMarker : 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 : AssetValueProjectionOfSelectorMarker() { + 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.AssetValueProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetValueProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.AssetValueProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".AssetValueProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * '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") + } + + override fun write(writer: ScaleCodecWriter, instance: AssetValueProjectionOfSelectorMarker) { + 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/AtIndex.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AtIndex.kt deleted file mode 100644 index 3a375d74b..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AtIndex.kt +++ /dev/null @@ -1,40 +0,0 @@ -// -// 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.Long -import kotlin.Unit - -/** - * AtIndex - * - * Generated from 'AtIndex' regular structure - */ -public data class AtIndex( - public val index: Long, - public val predicate: QueryOutputPredicate, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AtIndex = try { - AtIndex( - reader.readUint32(), - QueryOutputPredicate.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: AtIndex): Unit = try { - writer.writeUint32(instance.index) - QueryOutputPredicate.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BatchedResponse.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BatchedResponse.kt deleted file mode 100644 index 31d4a8873..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BatchedResponse.kt +++ /dev/null @@ -1,76 +0,0 @@ -// -// 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.Int -import kotlin.Unit - -/** - * BatchedResponse - * - * Generated from 'BatchedResponse' enum - */ -public sealed class BatchedResponse : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'V1' variant - */ - public data class V1( - public val batchedResponseV1: BatchedResponseV1, - ) : BatchedResponse() { - 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.BatchedResponse.V1 = try { - V1( - BatchedResponseV1.read(reader) as BatchedResponseV1, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.BatchedResponse.V1, - ): Unit = try { - BatchedResponseV1.write(writer, instance.batchedResponseV1) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader>, - ScaleWriter> { - override fun read(reader: ScaleCodecReader): BatchedResponse = when ( - val discriminant = - reader.readUByte() - ) { - 1 -> V1.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: BatchedResponse) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 1 -> V1.write(writer, instance as V1) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BatchedResponseV1.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BatchedResponseV1.kt deleted file mode 100644 index d613c9b68..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BatchedResponseV1.kt +++ /dev/null @@ -1,42 +0,0 @@ -// -// 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.Any -import kotlin.Unit - -/** - * BatchedResponseV1 - * - * Generated from 'BatchedResponseV1' regular structure - */ -public data class BatchedResponseV1( - public val batch: QueryOutputBox, - public val cursor: ForwardCursor, -) { - public companion object : - ScaleReader>, - ScaleWriter> { - override fun read(reader: ScaleCodecReader): BatchedResponseV1 = try { - BatchedResponseV1( - QueryOutputBox.read(reader), - ForwardCursor.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: BatchedResponseV1): Unit = try { - QueryOutputBox.write(writer, instance.batch) - ForwardCursor.write(writer, instance.cursor) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockEvent.kt index a8bf43229..016f627b1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockEvent.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'BlockEvent' regular structure */ -public data class BlockEvent( - public val `header`: BlockHeader, - public val status: BlockStatus, -) { +public data class BlockEvent(public val `header`: BlockHeader, public val status: BlockStatus) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): BlockEvent = try { BlockEvent( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockEventFilter.kt index c67b86812..0a8256108 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockEventFilter.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'BlockEventFilter' regular structure */ -public data class BlockEventFilter( - public val height: NonZeroOfu64? = null, - public val status: BlockStatus? = null, -) { +public data class BlockEventFilter(public val height: NonZeroOfu64? = null, public val status: BlockStatus? = null) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): BlockEventFilter = try { BlockEventFilter( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeader.kt index 7393cf9c7..92bd88a51 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeader.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeader.kt @@ -24,7 +24,6 @@ public data class BlockHeader( public val transactionsHash: HashOf>, public val creationTimeMs: BigInteger, public val viewChangeIndex: Long, - public val consensusEstimationMs: BigInteger, ) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): BlockHeader = try { @@ -34,7 +33,6 @@ public data class BlockHeader( HashOf.read(reader) as HashOf>, reader.readUint64(), reader.readUint32(), - reader.readUint64(), ) } catch (ex: Exception) { throw wrapException(ex) @@ -46,7 +44,6 @@ public data class BlockHeader( HashOf.write(writer, instance.transactionsHash) writer.writeUint64(instance.creationTimeMs) writer.writeUint32(instance.viewChangeIndex) - writer.writeUint64(instance.consensusEstimationMs) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHashPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashPredicateAtom.kt similarity index 64% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHashPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashPredicateAtom.kt index a40986bcb..2cebdce85 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHashPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashPredicateAtom.kt @@ -13,11 +13,11 @@ import kotlin.Int import kotlin.Unit /** - * BlockHashPredicateBox + * BlockHeaderHashPredicateAtom * - * Generated from 'BlockHashPredicateBox' enum + * Generated from 'BlockHeaderHashPredicateAtom' enum */ -public sealed class BlockHashPredicateBox : ModelEnum { +public sealed class BlockHeaderHashPredicateAtom : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -26,17 +26,15 @@ public sealed class BlockHashPredicateBox : ModelEnum { /** * 'Equals' variant */ - public data class Equals( - public val hashOf: HashOf, - ) : BlockHashPredicateBox() { + public data class Equals(public val hashOf: HashOf) : BlockHeaderHashPredicateAtom() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockHashPredicateBox.Equals = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockHeaderHashPredicateAtom.Equals = try { Equals( HashOf.read(reader) as HashOf, ) @@ -46,7 +44,7 @@ public sealed class BlockHashPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.BlockHashPredicateBox.Equals, + instance: jp.co.soramitsu.iroha2.generated.BlockHeaderHashPredicateAtom.Equals, ): Unit = try { HashOf.write(writer, instance.hashOf) } catch (ex: Exception) { @@ -55,19 +53,20 @@ public sealed class BlockHashPredicateBox : ModelEnum { } } - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): BlockHashPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): BlockHeaderHashPredicateAtom = when (val discriminant = reader.readUByte()) { 0 -> Equals.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: BlockHashPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: BlockHeaderHashPredicateAtom) { 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") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashProjectionOfPredicateMarker.kt similarity index 51% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashProjectionOfPredicateMarker.kt index 62559f878..1ff0bfb85 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashProjectionOfPredicateMarker.kt @@ -13,42 +13,42 @@ import kotlin.Int import kotlin.Unit /** - * BlockHeaderPredicateBox + * BlockHeaderHashProjectionOfPredicateMarker * - * Generated from 'BlockHeaderPredicateBox' enum + * Generated from 'BlockHeaderHashProjectionOfPredicateMarker' enum */ -public sealed class BlockHeaderPredicateBox : ModelEnum { +public sealed class BlockHeaderHashProjectionOfPredicateMarker : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int /** - * 'Hash' variant + * 'Atom' variant */ - public data class Hash( - public val blockHashPredicateBox: BlockHashPredicateBox, - ) : BlockHeaderPredicateBox() { + public data class Atom(public val blockHeaderHashPredicateAtom: BlockHeaderHashPredicateAtom) : + BlockHeaderHashProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockHeaderPredicateBox.Hash = try { - Hash( - BlockHashPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockHeaderHashProjectionOfPredicateMarker.Atom = + try { + Atom( + BlockHeaderHashPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.BlockHeaderPredicateBox.Hash, + instance: jp.co.soramitsu.iroha2.generated.BlockHeaderHashProjectionOfPredicateMarker.Atom, ): Unit = try { - BlockHashPredicateBox.write(writer, instance.blockHashPredicateBox) + BlockHeaderHashPredicateAtom.write(writer, instance.blockHeaderHashPredicateAtom) } catch (ex: Exception) { throw wrapException(ex) } @@ -56,20 +56,20 @@ public sealed class BlockHeaderPredicateBox : ModelEnum { } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): BlockHeaderPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Hash.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): BlockHeaderHashProjectionOfPredicateMarker = + 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: BlockHeaderPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: BlockHeaderHashProjectionOfPredicateMarker) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Hash.write(writer, instance as Hash) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $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/BlockHeaderHashProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..e5d7e8207 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashProjectionOfSelectorMarker.kt @@ -0,0 +1,91 @@ +// +// 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 + +/** + * BlockHeaderHashProjectionOfSelectorMarker + * + * Generated from 'BlockHeaderHashProjectionOfSelectorMarker' enum + */ +public sealed class BlockHeaderHashProjectionOfSelectorMarker : 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 : BlockHeaderHashProjectionOfSelectorMarker() { + 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.BlockHeaderHashProjectionOfSelectorMarker.Atom = + try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.BlockHeaderHashProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.BlockHeaderHashProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".BlockHeaderHashProjectionOfSelectorMarker.Atom".hashCode() + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): BlockHeaderHashProjectionOfSelectorMarker = + 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: BlockHeaderHashProjectionOfSelectorMarker) { + 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/BlockHeaderPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderPredicateAtom.kt new file mode 100644 index 000000000..9218d4777 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderPredicateAtom.kt @@ -0,0 +1,38 @@ +// +// 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 + +/** + * BlockHeaderPredicateAtom + * + * Generated from 'BlockHeaderPredicateAtom' enum + */ +public sealed class BlockHeaderPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): BlockHeaderPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: BlockHeaderPredicateAtom) { + 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/BlockHeaderProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..a8f14e88f --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderProjectionOfPredicateMarker.kt @@ -0,0 +1,107 @@ +// +// 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 + +/** + * BlockHeaderProjectionOfPredicateMarker + * + * Generated from 'BlockHeaderProjectionOfPredicateMarker' enum + */ +public sealed class BlockHeaderProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val blockHeaderPredicateAtom: BlockHeaderPredicateAtom) : BlockHeaderProjectionOfPredicateMarker() { + 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.BlockHeaderProjectionOfPredicateMarker.Atom = + try { + Atom( + BlockHeaderPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.BlockHeaderProjectionOfPredicateMarker.Atom, + ): Unit = try { + BlockHeaderPredicateAtom.write(writer, instance.blockHeaderPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Hash' variant + */ + public data class Hash(public val blockHeaderHashProjectionOfPredicateMarker: BlockHeaderHashProjectionOfPredicateMarker) : + BlockHeaderProjectionOfPredicateMarker() { + 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.BlockHeaderProjectionOfPredicateMarker.Hash = + try { + Hash( + BlockHeaderHashProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.BlockHeaderProjectionOfPredicateMarker.Hash, + ): Unit = try { + BlockHeaderHashProjectionOfPredicateMarker.write(writer, instance.blockHeaderHashProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): BlockHeaderProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Hash.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: BlockHeaderProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Hash.write(writer, instance as Hash) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..1fa88ecb0 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderProjectionOfSelectorMarker.kt @@ -0,0 +1,122 @@ +// +// 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 + +/** + * BlockHeaderProjectionOfSelectorMarker + * + * Generated from 'BlockHeaderProjectionOfSelectorMarker' enum + */ +public sealed class BlockHeaderProjectionOfSelectorMarker : 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 : BlockHeaderProjectionOfSelectorMarker() { + 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.BlockHeaderProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.BlockHeaderProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.BlockHeaderProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".BlockHeaderProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Hash' variant + */ + public data class Hash(public val blockHeaderHashProjectionOfSelectorMarker: BlockHeaderHashProjectionOfSelectorMarker) : + BlockHeaderProjectionOfSelectorMarker() { + 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.BlockHeaderProjectionOfSelectorMarker.Hash = try { + Hash( + BlockHeaderHashProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.BlockHeaderProjectionOfSelectorMarker.Hash, + ): Unit = try { + BlockHeaderHashProjectionOfSelectorMarker.write(writer, instance.blockHeaderHashProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): BlockHeaderProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Hash.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: BlockHeaderProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Hash.write(writer, instance as Hash) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockMessage.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockMessage.kt index 5c968e2fa..912026495 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockMessage.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockMessage.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'BlockMessage' regular structure */ -public data class BlockMessage( - public val signedBlock: SignedBlock, -) { +public data class BlockMessage(public val signedBlock: SignedBlock) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): BlockMessage = try { BlockMessage( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockParameter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockParameter.kt index 718476f2b..1b010ce8a 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockParameter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockParameter.kt @@ -26,9 +26,7 @@ public sealed class BlockParameter : ModelEnum { /** * 'MaxTransactions' variant */ - public data class MaxTransactions( - public val nonZeroOfu64: NonZeroOfu64, - ) : BlockParameter() { + public data class MaxTransactions(public val nonZeroOfu64: NonZeroOfu64) : BlockParameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,30 +42,27 @@ public sealed class BlockParameter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.BlockParameter.MaxTransactions, - ): Unit = try { - NonZeroOfu64.write(writer, instance.nonZeroOfu64) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.BlockParameter.MaxTransactions): Unit = + try { + NonZeroOfu64.write(writer, instance.nonZeroOfu64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): BlockParameter = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): BlockParameter = when (val discriminant = reader.readUByte()) { 0 -> MaxTransactions.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: BlockParameter) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> MaxTransactions.write(writer, instance as MaxTransactions) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockParameters.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockParameters.kt index a6f725dc9..2ee385dde 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockParameters.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockParameters.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'BlockParameters' regular structure */ -public data class BlockParameters( - public val maxTransactions: NonZeroOfu64, -) { +public data class BlockParameters(public val maxTransactions: NonZeroOfu64) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): BlockParameters = try { BlockParameters( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockPayload.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockPayload.kt index 4c64170cb..11fc89cc0 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockPayload.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockPayload.kt @@ -16,17 +16,12 @@ import kotlin.collections.List * * Generated from 'BlockPayload' regular structure */ -public data class BlockPayload( - public val `header`: BlockHeader, - public val transactions: List, - public val eventRecommendations: List, -) { +public data class BlockPayload(public val `header`: BlockHeader, public val transactions: List) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): BlockPayload = try { BlockPayload( BlockHeader.read(reader), - reader.readVec(reader.readCompactInt()) { CommittedTransaction.read(reader) }, - reader.readVec(reader.readCompactInt()) { EventBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { SignedTransaction.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -36,11 +31,7 @@ public data class BlockPayload( BlockHeader.write(writer, instance.`header`) writer.writeCompact(instance.transactions.size) instance.transactions.forEach { value -> - CommittedTransaction.write(writer, value) - } - writer.writeCompact(instance.eventRecommendations.size) - instance.eventRecommendations.forEach { value -> - EventBox.write(writer, value) + SignedTransaction.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockRejectionReason.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockRejectionReason.kt index 30acd9ad9..14f2bdbf7 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockRejectionReason.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockRejectionReason.kt @@ -27,11 +27,13 @@ public sealed class BlockRejectionReason : ModelEnum { override fun equals(other: Any?): Boolean = when (this) { is ConsensusBlockRejection -> ConsensusBlockRejection.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is ConsensusBlockRejection -> ConsensusBlockRejection.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'ConsensusBlockRejection' variant @@ -44,11 +46,12 @@ public sealed class BlockRejectionReason : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockRejectionReason.ConsensusBlockRejection = try { - ConsensusBlockRejection() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockRejectionReason.ConsensusBlockRejection = + try { + ConsensusBlockRejection() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -58,31 +61,28 @@ public sealed class BlockRejectionReason : ModelEnum { throw wrapException(ex) } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.BlockRejectionReason.ConsensusBlockRejection, - o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals(o1: jp.co.soramitsu.iroha2.generated.BlockRejectionReason.ConsensusBlockRejection, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".BlockRejectionReason.ConsensusBlockRejection".hashCode() } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): BlockRejectionReason = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): BlockRejectionReason = when (val discriminant = reader.readUByte()) { 0 -> ConsensusBlockRejection.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: BlockRejectionReason) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> ConsensusBlockRejection.write(writer, instance as ConsensusBlockRejection) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockSignature.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockSignature.kt index 85ee7d1d2..63c2b40e8 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockSignature.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockSignature.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'BlockSignature' tuple structure */ -public data class BlockSignature( - public val u64: BigInteger, - public val signatureOf: SignatureOf, -) { +public data class BlockSignature(public val u64: BigInteger, public val signatureOf: SignatureOf) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): BlockSignature = try { BlockSignature( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockStatus.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockStatus.kt index df507d132..f98e97453 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockStatus.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockStatus.kt @@ -26,16 +26,51 @@ public sealed class BlockStatus : ModelEnum { public abstract fun discriminant(): Int override fun equals(other: Any?): Boolean = when (this) { + is Created -> Created.equals(this, other) is Approved -> Approved.equals(this, other) is Committed -> Committed.equals(this, other) is Applied -> Applied.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { + is Created -> Created.hashCode() is Approved -> Approved.hashCode() is Committed -> Committed.hashCode() is Applied -> Applied.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } + + /** + * 'Created' variant + */ + public class Created : BlockStatus() { + 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.BlockStatus.Created = try { + Created() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.BlockStatus.Created): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.BlockStatus.Created, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".BlockStatus.Created".hashCode() + } + } /** * 'Approved' variant @@ -46,7 +81,7 @@ public sealed class BlockStatus : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 0 + public const val DISCRIMINANT: Int = 1 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockStatus.Approved = try { Approved() @@ -54,10 +89,7 @@ public sealed class BlockStatus : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.BlockStatus.Approved, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.BlockStatus.Approved): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -74,15 +106,13 @@ public sealed class BlockStatus : ModelEnum { /** * 'Rejected' variant */ - public data class Rejected( - public val blockRejectionReason: BlockRejectionReason, - ) : BlockStatus() { + public data class Rejected(public val blockRejectionReason: BlockRejectionReason) : BlockStatus() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 1 + public const val DISCRIMINANT: Int = 2 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockStatus.Rejected = try { Rejected( @@ -92,10 +122,7 @@ public sealed class BlockStatus : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.BlockStatus.Rejected, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.BlockStatus.Rejected): Unit = try { BlockRejectionReason.write(writer, instance.blockRejectionReason) } catch (ex: Exception) { throw wrapException(ex) @@ -112,7 +139,7 @@ public sealed class BlockStatus : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 2 + public const val DISCRIMINANT: Int = 3 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockStatus.Committed = try { Committed() @@ -120,10 +147,7 @@ public sealed class BlockStatus : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.BlockStatus.Committed, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.BlockStatus.Committed): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -146,7 +170,7 @@ public sealed class BlockStatus : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 3 + public const val DISCRIMINANT: Int = 4 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockStatus.Applied = try { Applied() @@ -154,10 +178,7 @@ public sealed class BlockStatus : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.BlockStatus.Applied, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.BlockStatus.Applied): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -172,24 +193,25 @@ public sealed class BlockStatus : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): BlockStatus = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Approved.read(reader) - 1 -> Rejected.read(reader) - 2 -> Committed.read(reader) - 3 -> Applied.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + override fun read(reader: ScaleCodecReader): BlockStatus = when (val discriminant = reader.readUByte()) { + 0 -> Created.read(reader) + 1 -> Approved.read(reader) + 2 -> Rejected.read(reader) + 3 -> Committed.read(reader) + 4 -> Applied.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: BlockStatus) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Approved.write(writer, instance as Approved) - 1 -> Rejected.write(writer, instance as Rejected) - 2 -> Committed.write(writer, instance as Committed) - 3 -> Applied.write(writer, instance as Applied) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 0 -> Created.write(writer, instance as Created) + 1 -> Approved.write(writer, instance as Approved) + 2 -> Rejected.write(writer, instance as Rejected) + 3 -> Committed.write(writer, instance as Committed) + 4 -> Applied.write(writer, instance as Applied) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockSubscriptionRequest.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockSubscriptionRequest.kt index 34fd0f84a..86b1de4e9 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockSubscriptionRequest.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockSubscriptionRequest.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'BlockSubscriptionRequest' regular structure */ -public data class BlockSubscriptionRequest( - public val nonZeroOfu64: NonZeroOfu64, -) { +public data class BlockSubscriptionRequest(public val nonZeroOfu64: NonZeroOfu64) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BurnBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BurnBox.kt index a7e7b29ec..cc36316f8 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BurnBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BurnBox.kt @@ -26,9 +26,7 @@ public sealed class BurnBox : ModelEnum { /** * 'Asset' variant */ - public data class Asset( - public val burnOfNumericAndAsset: BurnOfNumericAndAsset, - ) : BurnBox() { + public data class Asset(public val burnOfNumericAndAsset: BurnOfNumericAndAsset) : BurnBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -36,19 +34,15 @@ public sealed class BurnBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BurnBox.Asset = - try { - Asset( - BurnOfNumericAndAsset.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BurnBox.Asset = try { + Asset( + BurnOfNumericAndAsset.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.BurnBox.Asset, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.BurnBox.Asset): Unit = try { BurnOfNumericAndAsset.write(writer, instance.burnOfNumericAndAsset) } catch (ex: Exception) { throw wrapException(ex) @@ -59,9 +53,7 @@ public sealed class BurnBox : ModelEnum { /** * 'TriggerRepetitions' variant */ - public data class TriggerRepetitions( - public val burnOfu32AndTrigger: BurnOfu32AndTrigger, - ) : BurnBox() { + public data class TriggerRepetitions(public val burnOfu32AndTrigger: BurnOfu32AndTrigger) : BurnBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -77,32 +69,29 @@ public sealed class BurnBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.BurnBox.TriggerRepetitions, - ): Unit = try { - BurnOfu32AndTrigger.write(writer, instance.burnOfu32AndTrigger) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.BurnBox.TriggerRepetitions): Unit = + try { + BurnOfu32AndTrigger.write(writer, instance.burnOfu32AndTrigger) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): BurnBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): BurnBox = when (val discriminant = reader.readUByte()) { 0 -> Asset.read(reader) 1 -> TriggerRepetitions.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: BurnBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Asset.write(writer, instance as Asset) 1 -> TriggerRepetitions.write(writer, instance as TriggerRepetitions) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BurnOfNumericAndAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BurnOfNumericAndAsset.kt index 5e4b85de6..ea4183e95 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BurnOfNumericAndAsset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BurnOfNumericAndAsset.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,10 +18,9 @@ import kotlin.Unit * * Generated from 'BurnOfNumericAndAsset' regular structure */ -public data class BurnOfNumericAndAsset( - public val `object`: Numeric, - public val destination: AssetId, -) { +public data class BurnOfNumericAndAsset(public val `object`: Numeric, public val destination: AssetId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): BurnOfNumericAndAsset = try { BurnOfNumericAndAsset( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BurnOfu32AndTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BurnOfu32AndTrigger.kt index f8681d7fe..bf7912e1b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BurnOfu32AndTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BurnOfu32AndTrigger.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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.Long import kotlin.Unit @@ -16,10 +19,9 @@ import kotlin.Unit * * Generated from 'BurnOfu32AndTrigger' regular structure */ -public data class BurnOfu32AndTrigger( - public val `object`: Long, - public val destination: TriggerId, -) { +public data class BurnOfu32AndTrigger(public val `object`: Long, public val destination: TriggerId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): BurnOfu32AndTrigger = try { BurnOfu32AndTrigger( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintUserAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnAsset.kt similarity index 63% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintUserAsset.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnAsset.kt index 1f237f34c..78cc761f5 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintUserAsset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnAsset.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,23 +12,21 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanMintUserAsset + * CanBurnAsset * - * Generated from 'CanMintUserAsset' regular structure + * Generated from 'CanBurnAsset' regular structure */ -public data class CanMintUserAsset( - public val asset: AssetId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanMintUserAsset = try { - CanMintUserAsset( +public data class CanBurnAsset(public val asset: AssetId) : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanBurnAsset = try { + CanBurnAsset( AssetId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanMintUserAsset): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanBurnAsset): Unit = try { AssetId.write(writer, instance.asset) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnAssetWithDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnAssetWithDefinition.kt index 265ec6a71..2cbe166ce 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnAssetWithDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnAssetWithDefinition.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -15,9 +16,7 @@ import kotlin.Unit * * Generated from 'CanBurnAssetWithDefinition' regular structure */ -public data class CanBurnAssetWithDefinition( - public val assetDefinition: AssetDefinitionId, -) { +public data class CanBurnAssetWithDefinition(public val assetDefinition: AssetDefinitionId) : ModelPermission { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintUserTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanExecuteTrigger.kt similarity index 61% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintUserTrigger.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanExecuteTrigger.kt index 4f2f09288..0a2ed1fd3 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintUserTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanExecuteTrigger.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,23 +12,21 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanMintUserTrigger + * CanExecuteTrigger * - * Generated from 'CanMintUserTrigger' regular structure + * Generated from 'CanExecuteTrigger' regular structure */ -public data class CanMintUserTrigger( - public val trigger: TriggerId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanMintUserTrigger = try { - CanMintUserTrigger( +public data class CanExecuteTrigger(public val trigger: TriggerId) : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanExecuteTrigger = try { + CanExecuteTrigger( TriggerId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanMintUserTrigger): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanExecuteTrigger): Unit = try { TriggerId.write(writer, instance.trigger) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllDomains.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanManagePeers.kt similarity index 54% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllDomains.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanManagePeers.kt index 0e1b0ade0..533431c09 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllDomains.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanManagePeers.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -14,28 +15,28 @@ import kotlin.Int import kotlin.Unit /** - * FindAllDomains + * CanManagePeers * - * Generated from 'FindAllDomains' regular structure + * Generated from 'CanManagePeers' tuple structure */ -public class FindAllDomains { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllDomains = try { - FindAllDomains() +public class CanManagePeers : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanManagePeers = try { + CanManagePeers() } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: FindAllDomains): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanManagePeers): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: FindAllDomains, o2: Any?): Boolean = when (o2) { + public fun equals(o1: CanManagePeers, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } - override fun hashCode(): Int = ".FindAllDomains".hashCode() + override fun hashCode(): Int = ".CanManagePeers".hashCode() } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllRoleIds.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanManageRoles.kt similarity index 54% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllRoleIds.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanManageRoles.kt index c964d9ab4..3688afc0b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllRoleIds.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanManageRoles.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -14,28 +15,28 @@ import kotlin.Int import kotlin.Unit /** - * FindAllRoleIds + * CanManageRoles * - * Generated from 'FindAllRoleIds' regular structure + * Generated from 'CanManageRoles' tuple structure */ -public class FindAllRoleIds { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllRoleIds = try { - FindAllRoleIds() +public class CanManageRoles : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanManageRoles = try { + CanManageRoles() } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: FindAllRoleIds): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanManageRoles): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: FindAllRoleIds, o2: Any?): Boolean = when (o2) { + public fun equals(o1: CanManageRoles, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } - override fun hashCode(): Int = ".FindAllRoleIds".hashCode() + override fun hashCode(): Int = ".CanManageRoles".hashCode() } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnUserAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintAsset.kt similarity index 63% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnUserAsset.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintAsset.kt index c33542aea..8227d7df4 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnUserAsset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintAsset.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,23 +12,21 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanBurnUserAsset + * CanMintAsset * - * Generated from 'CanBurnUserAsset' regular structure + * Generated from 'CanMintAsset' regular structure */ -public data class CanBurnUserAsset( - public val asset: AssetId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanBurnUserAsset = try { - CanBurnUserAsset( +public data class CanMintAsset(public val asset: AssetId) : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanMintAsset = try { + CanMintAsset( AssetId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanBurnUserAsset): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanMintAsset): Unit = try { AssetId.write(writer, instance.asset) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintAssetWithDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintAssetWithDefinition.kt index 1b4ce4ae3..93d0df8f1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintAssetWithDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintAssetWithDefinition.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -15,9 +16,7 @@ import kotlin.Unit * * Generated from 'CanMintAssetWithDefinition' regular structure */ -public data class CanMintAssetWithDefinition( - public val assetDefinition: AssetDefinitionId, -) { +public data class CanMintAssetWithDefinition(public val assetDefinition: AssetDefinitionId) : ModelPermission { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAccountMetadata.kt similarity index 59% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInAccount.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAccountMetadata.kt index 024ef5a7b..0878923fb 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAccountMetadata.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,25 +12,23 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanSetKeyValueInAccount + * CanModifyAccountMetadata * - * Generated from 'CanSetKeyValueInAccount' regular structure + * Generated from 'CanModifyAccountMetadata' regular structure */ -public data class CanSetKeyValueInAccount( - public val account: AccountId, -) { +public data class CanModifyAccountMetadata(public val account: AccountId) : ModelPermission { public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanSetKeyValueInAccount = try { - CanSetKeyValueInAccount( + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CanModifyAccountMetadata = try { + CanModifyAccountMetadata( AccountId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanSetKeyValueInAccount): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanModifyAccountMetadata): Unit = try { AccountId.write(writer, instance.account) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAssetDefinitionMetadata.kt similarity index 57% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInAssetDefinition.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAssetDefinitionMetadata.kt index da5718ba5..f9848a966 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInAssetDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAssetDefinitionMetadata.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,25 +12,23 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanRemoveKeyValueInAssetDefinition + * CanModifyAssetDefinitionMetadata * - * Generated from 'CanRemoveKeyValueInAssetDefinition' regular structure + * Generated from 'CanModifyAssetDefinitionMetadata' regular structure */ -public data class CanRemoveKeyValueInAssetDefinition( - public val assetDefinition: AssetDefinitionId, -) { +public data class CanModifyAssetDefinitionMetadata(public val assetDefinition: AssetDefinitionId) : ModelPermission { public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRemoveKeyValueInAssetDefinition = try { - CanRemoveKeyValueInAssetDefinition( + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CanModifyAssetDefinitionMetadata = try { + CanModifyAssetDefinitionMetadata( AssetDefinitionId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanRemoveKeyValueInAssetDefinition): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanModifyAssetDefinitionMetadata): Unit = try { AssetDefinitionId.write(writer, instance.assetDefinition) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInUserAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAssetMetadata.kt similarity index 60% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInUserAsset.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAssetMetadata.kt index 2a955e704..8187ac0b9 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInUserAsset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAssetMetadata.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,25 +12,23 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanRemoveKeyValueInUserAsset + * CanModifyAssetMetadata * - * Generated from 'CanRemoveKeyValueInUserAsset' regular structure + * Generated from 'CanModifyAssetMetadata' regular structure */ -public data class CanRemoveKeyValueInUserAsset( - public val asset: AssetId, -) { +public data class CanModifyAssetMetadata(public val asset: AssetId) : ModelPermission { public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRemoveKeyValueInUserAsset = try { - CanRemoveKeyValueInUserAsset( + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CanModifyAssetMetadata = try { + CanModifyAssetMetadata( AssetId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanRemoveKeyValueInUserAsset): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanModifyAssetMetadata): Unit = try { AssetId.write(writer, instance.asset) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyDomainMetadata.kt similarity index 60% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInDomain.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyDomainMetadata.kt index ed241bfea..5f3ad3ba4 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInDomain.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyDomainMetadata.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,25 +12,23 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanRemoveKeyValueInDomain + * CanModifyDomainMetadata * - * Generated from 'CanRemoveKeyValueInDomain' regular structure + * Generated from 'CanModifyDomainMetadata' regular structure */ -public data class CanRemoveKeyValueInDomain( - public val domain: DomainId, -) { +public data class CanModifyDomainMetadata(public val domain: DomainId) : ModelPermission { public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRemoveKeyValueInDomain = try { - CanRemoveKeyValueInDomain( + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CanModifyDomainMetadata = try { + CanModifyDomainMetadata( DomainId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanRemoveKeyValueInDomain): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanModifyDomainMetadata): Unit = try { DomainId.write(writer, instance.domain) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnUserTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyTrigger.kt similarity index 61% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnUserTrigger.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyTrigger.kt index 09d8e0339..87293b1ba 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnUserTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyTrigger.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,23 +12,21 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanBurnUserTrigger + * CanModifyTrigger * - * Generated from 'CanBurnUserTrigger' regular structure + * Generated from 'CanModifyTrigger' regular structure */ -public data class CanBurnUserTrigger( - public val trigger: TriggerId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanBurnUserTrigger = try { - CanBurnUserTrigger( +public data class CanModifyTrigger(public val trigger: TriggerId) : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanModifyTrigger = try { + CanModifyTrigger( TriggerId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanBurnUserTrigger): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanModifyTrigger): Unit = try { TriggerId.write(writer, instance.trigger) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyTriggerMetadata.kt similarity index 59% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInTrigger.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyTriggerMetadata.kt index 844a06c7f..bd3ed88d1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyTriggerMetadata.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,25 +12,23 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanSetKeyValueInTrigger + * CanModifyTriggerMetadata * - * Generated from 'CanSetKeyValueInTrigger' regular structure + * Generated from 'CanModifyTriggerMetadata' regular structure */ -public data class CanSetKeyValueInTrigger( - public val trigger: TriggerId, -) { +public data class CanModifyTriggerMetadata(public val trigger: TriggerId) : ModelPermission { public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanSetKeyValueInTrigger = try { - CanSetKeyValueInTrigger( + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CanModifyTriggerMetadata = try { + CanModifyTriggerMetadata( TriggerId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanSetKeyValueInTrigger): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanModifyTriggerMetadata): Unit = try { TriggerId.write(writer, instance.trigger) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAccountInDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAccount.kt similarity index 64% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAccountInDomain.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAccount.kt index dea60174e..bf0d3a1ad 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAccountInDomain.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAccount.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,25 +12,21 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanRegisterAccountInDomain + * CanRegisterAccount * - * Generated from 'CanRegisterAccountInDomain' regular structure + * Generated from 'CanRegisterAccount' regular structure */ -public data class CanRegisterAccountInDomain( - public val domain: DomainId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRegisterAccountInDomain = try { - CanRegisterAccountInDomain( +public data class CanRegisterAccount(public val domain: DomainId) : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanRegisterAccount = try { + CanRegisterAccount( DomainId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanRegisterAccountInDomain): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanRegisterAccount): Unit = try { DomainId.write(writer, instance.domain) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterUserTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAsset.kt similarity index 62% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterUserTrigger.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAsset.kt index 415c2f987..f70023896 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterUserTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAsset.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,24 +12,22 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanRegisterUserTrigger + * CanRegisterAsset * - * Generated from 'CanRegisterUserTrigger' regular structure + * Generated from 'CanRegisterAsset' regular structure */ -public data class CanRegisterUserTrigger( - public val account: AccountId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRegisterUserTrigger = try { - CanRegisterUserTrigger( +public data class CanRegisterAsset(public val owner: AccountId) : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanRegisterAsset = try { + CanRegisterAsset( AccountId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanRegisterUserTrigger): Unit = try { - AccountId.write(writer, instance.account) + override fun write(writer: ScaleCodecWriter, instance: CanRegisterAsset): Unit = try { + AccountId.write(writer, instance.owner) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetDefinitionInDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetDefinition.kt similarity index 64% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetDefinitionInDomain.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetDefinition.kt index 858dc873a..f6535afc0 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetDefinitionInDomain.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetDefinition.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,25 +12,23 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanRegisterAssetDefinitionInDomain + * CanRegisterAssetDefinition * - * Generated from 'CanRegisterAssetDefinitionInDomain' regular structure + * Generated from 'CanRegisterAssetDefinition' regular structure */ -public data class CanRegisterAssetDefinitionInDomain( - public val domain: DomainId, -) { +public data class CanRegisterAssetDefinition(public val domain: DomainId) : ModelPermission { public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRegisterAssetDefinitionInDomain = try { - CanRegisterAssetDefinitionInDomain( + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CanRegisterAssetDefinition = try { + CanRegisterAssetDefinition( DomainId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanRegisterAssetDefinitionInDomain): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanRegisterAssetDefinition): Unit = try { DomainId.write(writer, instance.domain) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetWithDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetWithDefinition.kt index 0ba87046b..019468e42 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetWithDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetWithDefinition.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -15,9 +16,7 @@ import kotlin.Unit * * Generated from 'CanRegisterAssetWithDefinition' regular structure */ -public data class CanRegisterAssetWithDefinition( - public val assetDefinition: AssetDefinitionId, -) { +public data class CanRegisterAssetWithDefinition(public val assetDefinition: AssetDefinitionId) : ModelPermission { public companion object : ScaleReader, ScaleWriter { @@ -29,11 +28,10 @@ public data class CanRegisterAssetWithDefinition( throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanRegisterAssetWithDefinition): Unit = - try { - AssetDefinitionId.write(writer, instance.assetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: CanRegisterAssetWithDefinition): Unit = try { + AssetDefinitionId.write(writer, instance.assetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllParameters.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterDomain.kt similarity index 53% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllParameters.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterDomain.kt index 3cbf81082..0d0926eba 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllParameters.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterDomain.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -14,28 +15,28 @@ import kotlin.Int import kotlin.Unit /** - * FindAllParameters + * CanRegisterDomain * - * Generated from 'FindAllParameters' regular structure + * Generated from 'CanRegisterDomain' tuple structure */ -public class FindAllParameters { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllParameters = try { - FindAllParameters() +public class CanRegisterDomain : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanRegisterDomain = try { + CanRegisterDomain() } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: FindAllParameters): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanRegisterDomain): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: FindAllParameters, o2: Any?): Boolean = when (o2) { + public fun equals(o1: CanRegisterDomain, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } - override fun hashCode(): Int = ".FindAllParameters".hashCode() + override fun hashCode(): Int = ".CanRegisterDomain".hashCode() } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterUserTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterTrigger.kt similarity index 55% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterUserTrigger.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterTrigger.kt index 80340de0b..fc9b40e56 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterUserTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterTrigger.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,26 +12,22 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanUnregisterUserTrigger + * CanRegisterTrigger * - * Generated from 'CanUnregisterUserTrigger' regular structure + * Generated from 'CanRegisterTrigger' regular structure */ -public data class CanUnregisterUserTrigger( - public val account: AccountId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanUnregisterUserTrigger = try { - CanUnregisterUserTrigger( +public data class CanRegisterTrigger(public val authority: AccountId) : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanRegisterTrigger = try { + CanRegisterTrigger( AccountId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanUnregisterUserTrigger): Unit = try { - AccountId.write(writer, instance.account) + override fun write(writer: ScaleCodecWriter, instance: CanRegisterTrigger): Unit = try { + AccountId.write(writer, instance.authority) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInAccount.kt deleted file mode 100644 index b75459474..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInAccount.kt +++ /dev/null @@ -1,38 +0,0 @@ -// -// 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 - -/** - * CanRemoveKeyValueInAccount - * - * Generated from 'CanRemoveKeyValueInAccount' regular structure - */ -public data class CanRemoveKeyValueInAccount( - public val account: AccountId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRemoveKeyValueInAccount = try { - CanRemoveKeyValueInAccount( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanRemoveKeyValueInAccount): Unit = try { - AccountId.write(writer, instance.account) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInTrigger.kt deleted file mode 100644 index a03af883c..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInTrigger.kt +++ /dev/null @@ -1,38 +0,0 @@ -// -// 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 - -/** - * CanRemoveKeyValueInTrigger - * - * Generated from 'CanRemoveKeyValueInTrigger' regular structure - */ -public data class CanRemoveKeyValueInTrigger( - public val trigger: TriggerId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRemoveKeyValueInTrigger = try { - CanRemoveKeyValueInTrigger( - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanRemoveKeyValueInTrigger): Unit = try { - TriggerId.write(writer, instance.trigger) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInAssetDefinition.kt deleted file mode 100644 index c22ec37e5..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInAssetDefinition.kt +++ /dev/null @@ -1,39 +0,0 @@ -// -// 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 - -/** - * CanSetKeyValueInAssetDefinition - * - * Generated from 'CanSetKeyValueInAssetDefinition' regular structure - */ -public data class CanSetKeyValueInAssetDefinition( - public val assetDefinition: AssetDefinitionId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanSetKeyValueInAssetDefinition = try { - CanSetKeyValueInAssetDefinition( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanSetKeyValueInAssetDefinition): Unit = - try { - AssetDefinitionId.write(writer, instance.assetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInDomain.kt deleted file mode 100644 index f0dd9ed2c..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInDomain.kt +++ /dev/null @@ -1,36 +0,0 @@ -// -// 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 - -/** - * CanSetKeyValueInDomain - * - * Generated from 'CanSetKeyValueInDomain' regular structure - */ -public data class CanSetKeyValueInDomain( - public val domain: DomainId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanSetKeyValueInDomain = try { - CanSetKeyValueInDomain( - DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanSetKeyValueInDomain): Unit = try { - DomainId.write(writer, instance.domain) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInUserAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInUserAsset.kt deleted file mode 100644 index 6070ca368..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInUserAsset.kt +++ /dev/null @@ -1,38 +0,0 @@ -// -// 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 - -/** - * CanSetKeyValueInUserAsset - * - * Generated from 'CanSetKeyValueInUserAsset' regular structure - */ -public data class CanSetKeyValueInUserAsset( - public val asset: AssetId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanSetKeyValueInUserAsset = try { - CanSetKeyValueInUserAsset( - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanSetKeyValueInUserAsset): Unit = try { - AssetId.write(writer, instance.asset) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllBlocks.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetParameters.kt similarity index 52% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllBlocks.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetParameters.kt index 1ce79fa0d..c0fd3c0f6 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllBlocks.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetParameters.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -14,28 +15,28 @@ import kotlin.Int import kotlin.Unit /** - * FindAllBlocks + * CanSetParameters * - * Generated from 'FindAllBlocks' regular structure + * Generated from 'CanSetParameters' tuple structure */ -public class FindAllBlocks { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllBlocks = try { - FindAllBlocks() +public class CanSetParameters : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanSetParameters = try { + CanSetParameters() } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: FindAllBlocks): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanSetParameters): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: FindAllBlocks, o2: Any?): Boolean = when (o2) { + public fun equals(o1: CanSetParameters, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } - override fun hashCode(): Int = ".FindAllBlocks".hashCode() + override fun hashCode(): Int = ".CanSetParameters".hashCode() } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferUserAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferAsset.kt similarity index 67% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferUserAsset.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferAsset.kt index 2c4322986..58110d1b9 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferUserAsset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferAsset.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,23 +12,21 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanTransferUserAsset + * CanTransferAsset * - * Generated from 'CanTransferUserAsset' regular structure + * Generated from 'CanTransferAsset' regular structure */ -public data class CanTransferUserAsset( - public val asset: AssetId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanTransferUserAsset = try { - CanTransferUserAsset( +public data class CanTransferAsset(public val asset: AssetId) : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanTransferAsset = try { + CanTransferAsset( AssetId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanTransferUserAsset): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanTransferAsset): Unit = try { AssetId.write(writer, instance.asset) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferAssetWithDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferAssetWithDefinition.kt index d8df1d595..d2ea6e5ef 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferAssetWithDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferAssetWithDefinition.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -15,9 +16,7 @@ import kotlin.Unit * * Generated from 'CanTransferAssetWithDefinition' regular structure */ -public data class CanTransferAssetWithDefinition( - public val assetDefinition: AssetDefinitionId, -) { +public data class CanTransferAssetWithDefinition(public val assetDefinition: AssetDefinitionId) : ModelPermission { public companion object : ScaleReader, ScaleWriter { @@ -29,11 +28,10 @@ public data class CanTransferAssetWithDefinition( throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanTransferAssetWithDefinition): Unit = - try { - AssetDefinitionId.write(writer, instance.assetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: CanTransferAssetWithDefinition): Unit = try { + AssetDefinitionId.write(writer, instance.assetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAccount.kt index dae14c76d..5f8e9f473 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAccount.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -15,9 +16,7 @@ import kotlin.Unit * * Generated from 'CanUnregisterAccount' regular structure */ -public data class CanUnregisterAccount( - public val account: AccountId, -) { +public data class CanUnregisterAccount(public val account: AccountId) : ModelPermission { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): CanUnregisterAccount = try { CanUnregisterAccount( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterUserAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAsset.kt similarity index 66% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterUserAsset.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAsset.kt index c29a1a1c8..54a81a7e2 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterUserAsset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAsset.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,23 +12,21 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanUnregisterUserAsset + * CanUnregisterAsset * - * Generated from 'CanUnregisterUserAsset' regular structure + * Generated from 'CanUnregisterAsset' regular structure */ -public data class CanUnregisterUserAsset( - public val asset: AssetId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanUnregisterUserAsset = try { - CanUnregisterUserAsset( +public data class CanUnregisterAsset(public val asset: AssetId) : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanUnregisterAsset = try { + CanUnregisterAsset( AssetId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanUnregisterUserAsset): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanUnregisterAsset): Unit = try { AssetId.write(writer, instance.asset) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAssetDefinition.kt index e9bb10982..1c53532fd 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAssetDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAssetDefinition.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -15,9 +16,7 @@ import kotlin.Unit * * Generated from 'CanUnregisterAssetDefinition' regular structure */ -public data class CanUnregisterAssetDefinition( - public val assetDefinition: AssetDefinitionId, -) { +public data class CanUnregisterAssetDefinition(public val assetDefinition: AssetDefinitionId) : ModelPermission { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAssetWithDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAssetWithDefinition.kt index 026066d46..f1a1e5d12 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAssetWithDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAssetWithDefinition.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -15,9 +16,7 @@ import kotlin.Unit * * Generated from 'CanUnregisterAssetWithDefinition' regular structure */ -public data class CanUnregisterAssetWithDefinition( - public val assetDefinition: AssetDefinitionId, -) { +public data class CanUnregisterAssetWithDefinition(public val assetDefinition: AssetDefinitionId) : ModelPermission { public companion object : ScaleReader, ScaleWriter { @@ -29,11 +28,10 @@ public data class CanUnregisterAssetWithDefinition( throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanUnregisterAssetWithDefinition): Unit = - try { - AssetDefinitionId.write(writer, instance.assetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: CanUnregisterAssetWithDefinition): Unit = try { + AssetDefinitionId.write(writer, instance.assetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterDomain.kt index 5100adc0a..87fb6068e 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterDomain.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterDomain.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -15,9 +16,7 @@ import kotlin.Unit * * Generated from 'CanUnregisterDomain' regular structure */ -public data class CanUnregisterDomain( - public val domain: DomainId, -) { +public data class CanUnregisterDomain(public val domain: DomainId) : ModelPermission { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): CanUnregisterDomain = try { CanUnregisterDomain( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanExecuteUserTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterTrigger.kt similarity index 59% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanExecuteUserTrigger.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterTrigger.kt index a5b5900ce..dc73481d5 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanExecuteUserTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterTrigger.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -11,23 +12,21 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * CanExecuteUserTrigger + * CanUnregisterTrigger * - * Generated from 'CanExecuteUserTrigger' regular structure + * Generated from 'CanUnregisterTrigger' regular structure */ -public data class CanExecuteUserTrigger( - public val trigger: TriggerId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanExecuteUserTrigger = try { - CanExecuteUserTrigger( +public data class CanUnregisterTrigger(public val trigger: TriggerId) : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanUnregisterTrigger = try { + CanUnregisterTrigger( TriggerId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: CanExecuteUserTrigger): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanUnregisterTrigger): Unit = try { TriggerId.write(writer, instance.trigger) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllAssets.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUpgradeExecutor.kt similarity index 51% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllAssets.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUpgradeExecutor.kt index 025e17006..016d7fa31 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllAssets.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUpgradeExecutor.kt @@ -3,6 +3,7 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.ModelPermission import jp.co.soramitsu.iroha2.codec.ScaleCodecReader import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter import jp.co.soramitsu.iroha2.codec.ScaleReader @@ -14,28 +15,28 @@ import kotlin.Int import kotlin.Unit /** - * FindAllAssets + * CanUpgradeExecutor * - * Generated from 'FindAllAssets' regular structure + * Generated from 'CanUpgradeExecutor' tuple structure */ -public class FindAllAssets { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllAssets = try { - FindAllAssets() +public class CanUpgradeExecutor : ModelPermission { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): CanUpgradeExecutor = try { + CanUpgradeExecutor() } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: FindAllAssets): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: CanUpgradeExecutor): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: FindAllAssets, o2: Any?): Boolean = when (o2) { + public fun equals(o1: CanUpgradeExecutor, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } - override fun hashCode(): Int = ".FindAllAssets".hashCode() + override fun hashCode(): Int = ".CanUpgradeExecutor".hashCode() } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ChainId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ChainId.kt index 9e3302da7..f04d89a88 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ChainId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ChainId.kt @@ -16,9 +16,7 @@ import kotlin.Unit * * Generated from 'ChainId' regular structure */ -public data class ChainId( - public val string: String, -) { +public data class ChainId(public val string: String) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): ChainId = try { ChainId( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ClientQueryPayload.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ClientQueryPayload.kt deleted file mode 100644 index ece309fff..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ClientQueryPayload.kt +++ /dev/null @@ -1,51 +0,0 @@ -// -// 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 - -/** - * ClientQueryPayload - * - * Generated from 'ClientQueryPayload' regular structure - */ -public data class ClientQueryPayload( - public val authority: AccountId, - public val query: QueryBox, - public val filter: GenericPredicateBox, - public val sorting: Sorting, - public val pagination: Pagination, - public val fetchSize: FetchSize, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): ClientQueryPayload = try { - ClientQueryPayload( - AccountId.read(reader), - QueryBox.read(reader), - GenericPredicateBox.read(reader) as GenericPredicateBox, - Sorting.read(reader), - Pagination.read(reader), - FetchSize.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: ClientQueryPayload): Unit = try { - AccountId.write(writer, instance.authority) - QueryBox.write(writer, instance.query) - GenericPredicateBox.write(writer, instance.filter) - Sorting.write(writer, instance.sorting) - Pagination.write(writer, instance.pagination) - FetchSize.write(writer, instance.fetchSize) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransaction.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransaction.kt index 8359fa420..6f38fcf03 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransaction.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransaction.kt @@ -16,12 +16,14 @@ import kotlin.Unit * Generated from 'CommittedTransaction' regular structure */ public data class CommittedTransaction( + public val blockHash: HashOf, public val `value`: SignedTransaction, public val error: TransactionRejectionReason? = null, ) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): CommittedTransaction = try { CommittedTransaction( + HashOf.read(reader) as HashOf, SignedTransaction.read(reader), reader.readNullable(TransactionRejectionReason) as TransactionRejectionReason?, ) @@ -30,6 +32,7 @@ public data class CommittedTransaction( } override fun write(writer: ScaleCodecWriter, instance: CommittedTransaction): Unit = try { + HashOf.write(writer, instance.blockHash) SignedTransaction.write(writer, instance.`value`) writer.writeNullable(TransactionRejectionReason, instance.error) } catch (ex: Exception) { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionPredicateAtom.kt new file mode 100644 index 000000000..fa305bcb8 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionPredicateAtom.kt @@ -0,0 +1,38 @@ +// +// 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 + +/** + * CommittedTransactionPredicateAtom + * + * Generated from 'CommittedTransactionPredicateAtom' enum + */ +public sealed class CommittedTransactionPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CommittedTransactionPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: CommittedTransactionPredicateAtom) { + 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/CommittedTransactionPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionPredicateBox.kt deleted file mode 100644 index 0f41cf40a..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionPredicateBox.kt +++ /dev/null @@ -1,111 +0,0 @@ -// -// 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 - -/** - * CommittedTransactionPredicateBox - * - * Generated from 'CommittedTransactionPredicateBox' enum - */ -public sealed class CommittedTransactionPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Value' variant - */ - public data class Value( - public val signedTransactionPredicateBox: SignedTransactionPredicateBox, - ) : CommittedTransactionPredicateBox() { - 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.CommittedTransactionPredicateBox.Value = try { - Value( - SignedTransactionPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CommittedTransactionPredicateBox.Value, - ): Unit = - try { - SignedTransactionPredicateBox.write(writer, instance.signedTransactionPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Error' variant - */ - public data class Error( - public val transactionErrorPredicateBox: TransactionErrorPredicateBox, - ) : CommittedTransactionPredicateBox() { - 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.CommittedTransactionPredicateBox.Error = try { - Error( - TransactionErrorPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CommittedTransactionPredicateBox.Error, - ): Unit = - try { - TransactionErrorPredicateBox.write(writer, instance.transactionErrorPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CommittedTransactionPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { - 0 -> Value.read(reader) - 1 -> Error.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: CommittedTransactionPredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Value.write(writer, instance as Value) - 1 -> Error.write(writer, instance as Error) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..9fa317e77 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionProjectionOfPredicateMarker.kt @@ -0,0 +1,181 @@ +// +// 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 + +/** + * CommittedTransactionProjectionOfPredicateMarker + * + * Generated from 'CommittedTransactionProjectionOfPredicateMarker' enum + */ +public sealed class CommittedTransactionProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val committedTransactionPredicateAtom: CommittedTransactionPredicateAtom) : + CommittedTransactionProjectionOfPredicateMarker() { + 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.CommittedTransactionProjectionOfPredicateMarker.Atom = try { + Atom( + CommittedTransactionPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CommittedTransactionProjectionOfPredicateMarker.Atom, + ): Unit = try { + CommittedTransactionPredicateAtom.write(writer, instance.committedTransactionPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'BlockHash' variant + */ + public data class BlockHash(public val blockHeaderHashProjectionOfPredicateMarker: BlockHeaderHashProjectionOfPredicateMarker) : + CommittedTransactionProjectionOfPredicateMarker() { + 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.CommittedTransactionProjectionOfPredicateMarker.BlockHash = try { + BlockHash( + BlockHeaderHashProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CommittedTransactionProjectionOfPredicateMarker.BlockHash, + ): Unit = try { + BlockHeaderHashProjectionOfPredicateMarker.write(writer, instance.blockHeaderHashProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Value' variant + */ + public data class Value(public val signedTransactionProjectionOfPredicateMarker: SignedTransactionProjectionOfPredicateMarker) : + CommittedTransactionProjectionOfPredicateMarker() { + 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.CommittedTransactionProjectionOfPredicateMarker.Value = try { + Value( + SignedTransactionProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CommittedTransactionProjectionOfPredicateMarker.Value, + ): Unit = try { + SignedTransactionProjectionOfPredicateMarker.write(writer, instance.signedTransactionProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Error' variant + */ + public data class Error(public val transactionErrorProjectionOfPredicateMarker: TransactionErrorProjectionOfPredicateMarker) : + CommittedTransactionProjectionOfPredicateMarker() { + 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.CommittedTransactionProjectionOfPredicateMarker.Error = try { + Error( + TransactionErrorProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CommittedTransactionProjectionOfPredicateMarker.Error, + ): Unit = try { + TransactionErrorProjectionOfPredicateMarker.write(writer, instance.transactionErrorProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CommittedTransactionProjectionOfPredicateMarker = + when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> BlockHash.read(reader) + 2 -> Value.read(reader) + 3 -> Error.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: CommittedTransactionProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> BlockHash.write(writer, instance as BlockHash) + 2 -> Value.write(writer, instance as Value) + 3 -> Error.write(writer, instance as Error) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..07d1c5a11 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionProjectionOfSelectorMarker.kt @@ -0,0 +1,197 @@ +// +// 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 + +/** + * CommittedTransactionProjectionOfSelectorMarker + * + * Generated from 'CommittedTransactionProjectionOfSelectorMarker' enum + */ +public sealed class CommittedTransactionProjectionOfSelectorMarker : 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 : CommittedTransactionProjectionOfSelectorMarker() { + 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.CommittedTransactionProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CommittedTransactionProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.CommittedTransactionProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".CommittedTransactionProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'BlockHash' variant + */ + public data class BlockHash(public val blockHeaderHashProjectionOfSelectorMarker: BlockHeaderHashProjectionOfSelectorMarker) : + CommittedTransactionProjectionOfSelectorMarker() { + 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.CommittedTransactionProjectionOfSelectorMarker.BlockHash = try { + BlockHash( + BlockHeaderHashProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CommittedTransactionProjectionOfSelectorMarker.BlockHash, + ): Unit = try { + BlockHeaderHashProjectionOfSelectorMarker.write(writer, instance.blockHeaderHashProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Value' variant + */ + public data class Value(public val signedTransactionProjectionOfSelectorMarker: SignedTransactionProjectionOfSelectorMarker) : + CommittedTransactionProjectionOfSelectorMarker() { + 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.CommittedTransactionProjectionOfSelectorMarker.Value = try { + Value( + SignedTransactionProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CommittedTransactionProjectionOfSelectorMarker.Value, + ): Unit = try { + SignedTransactionProjectionOfSelectorMarker.write(writer, instance.signedTransactionProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Error' variant + */ + public data class Error(public val transactionErrorProjectionOfSelectorMarker: TransactionErrorProjectionOfSelectorMarker) : + CommittedTransactionProjectionOfSelectorMarker() { + 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.CommittedTransactionProjectionOfSelectorMarker.Error = try { + Error( + TransactionErrorProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CommittedTransactionProjectionOfSelectorMarker.Error, + ): Unit = try { + TransactionErrorProjectionOfSelectorMarker.write(writer, instance.transactionErrorProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CommittedTransactionProjectionOfSelectorMarker = + when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> BlockHash.read(reader) + 2 -> Value.read(reader) + 3 -> Error.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: CommittedTransactionProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> BlockHash.write(writer, instance as BlockHash) + 2 -> Value.write(writer, instance as Value) + 3 -> Error.write(writer, instance as Error) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAccount.kt new file mode 100644 index 000000000..188f1ffe0 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAccount.kt @@ -0,0 +1,168 @@ +// +// 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 +import kotlin.collections.List + +/** + * CompoundPredicateOfAccount + * + * Generated from 'CompoundPredicateOfAccount' enum + */ +public sealed class CompoundPredicateOfAccount : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val accountProjectionOfPredicateMarker: AccountProjectionOfPredicateMarker) : + CompoundPredicateOfAccount() { + 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.CompoundPredicateOfAccount.Atom = try { + Atom( + AccountProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccount.Atom): Unit = + try { + AccountProjectionOfPredicateMarker.write(writer, instance.accountProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Not' variant + */ + public data class Not(public val compoundPredicateOfAccount: CompoundPredicateOfAccount) : CompoundPredicateOfAccount() { + 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.CompoundPredicateOfAccount.Not = try { + Not( + CompoundPredicateOfAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccount.Not): Unit = + try { + CompoundPredicateOfAccount.write(writer, instance.compoundPredicateOfAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'And' variant + */ + public data class And(public val vec: List) : CompoundPredicateOfAccount() { + 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.CompoundPredicateOfAccount.And = try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAccount.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccount.And): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfAccount.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Or' variant + */ + public data class Or(public val vec: List) : CompoundPredicateOfAccount() { + 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.CompoundPredicateOfAccount.Or = try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAccount.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccount.Or): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfAccount.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfAccount = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Not.read(reader) + 2 -> And.read(reader) + 3 -> Or.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfAccount) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Not.write(writer, instance as Not) + 2 -> And.write(writer, instance as And) + 3 -> Or.write(writer, instance as Or) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAsset.kt new file mode 100644 index 000000000..a7cbc3260 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAsset.kt @@ -0,0 +1,167 @@ +// +// 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 +import kotlin.collections.List + +/** + * CompoundPredicateOfAsset + * + * Generated from 'CompoundPredicateOfAsset' enum + */ +public sealed class CompoundPredicateOfAsset : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val assetProjectionOfPredicateMarker: AssetProjectionOfPredicateMarker) : CompoundPredicateOfAsset() { + 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.CompoundPredicateOfAsset.Atom = try { + Atom( + AssetProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAsset.Atom): Unit = + try { + AssetProjectionOfPredicateMarker.write(writer, instance.assetProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Not' variant + */ + public data class Not(public val compoundPredicateOfAsset: CompoundPredicateOfAsset) : CompoundPredicateOfAsset() { + 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.CompoundPredicateOfAsset.Not = try { + Not( + CompoundPredicateOfAsset.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAsset.Not): Unit = + try { + CompoundPredicateOfAsset.write(writer, instance.compoundPredicateOfAsset) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'And' variant + */ + public data class And(public val vec: List) : CompoundPredicateOfAsset() { + 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.CompoundPredicateOfAsset.And = try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAsset.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAsset.And): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfAsset.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Or' variant + */ + public data class Or(public val vec: List) : CompoundPredicateOfAsset() { + 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.CompoundPredicateOfAsset.Or = try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAsset.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAsset.Or): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfAsset.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfAsset = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Not.read(reader) + 2 -> And.read(reader) + 3 -> Or.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfAsset) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Not.write(writer, instance as Not) + 2 -> And.write(writer, instance as And) + 3 -> Or.write(writer, instance as Or) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetDefinition.kt similarity index 65% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetDefinition.kt index 41dcffd98..118388462 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetDefinition.kt @@ -14,11 +14,11 @@ import kotlin.Unit import kotlin.collections.List /** - * CompoundPredicateOfAssetPredicateBox + * CompoundPredicateOfAssetDefinition * - * Generated from 'CompoundPredicateOfAssetPredicateBox' enum + * Generated from 'CompoundPredicateOfAssetDefinition' enum */ -public sealed class CompoundPredicateOfAssetPredicateBox : ModelEnum { +public sealed class CompoundPredicateOfAssetDefinition : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -27,19 +27,18 @@ public sealed class CompoundPredicateOfAssetPredicateBox : ModelEnum { /** * 'Atom' variant */ - public data class Atom( - public val assetPredicateBox: AssetPredicateBox, - ) : CompoundPredicateOfAssetPredicateBox() { + public data class Atom(public val assetDefinitionProjectionOfPredicateMarker: AssetDefinitionProjectionOfPredicateMarker) : + CompoundPredicateOfAssetDefinition() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetPredicateBox.Atom = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition.Atom = try { Atom( - AssetPredicateBox.read(reader), + AssetDefinitionProjectionOfPredicateMarker.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -47,9 +46,9 @@ public sealed class CompoundPredicateOfAssetPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetPredicateBox.Atom, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition.Atom, ): Unit = try { - AssetPredicateBox.write(writer, instance.assetPredicateBox) + AssetDefinitionProjectionOfPredicateMarker.write(writer, instance.assetDefinitionProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } @@ -59,19 +58,18 @@ public sealed class CompoundPredicateOfAssetPredicateBox : ModelEnum { /** * 'Not' variant */ - public data class Not( - public val compoundPredicateOfAssetPredicateBox: CompoundPredicateOfAssetPredicateBox, - ) : CompoundPredicateOfAssetPredicateBox() { + public data class Not(public val compoundPredicateOfAssetDefinition: CompoundPredicateOfAssetDefinition) : + CompoundPredicateOfAssetDefinition() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetPredicateBox.Not = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition.Not = try { Not( - CompoundPredicateOfAssetPredicateBox.read(reader), + CompoundPredicateOfAssetDefinition.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -79,12 +77,9 @@ public sealed class CompoundPredicateOfAssetPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetPredicateBox.Not, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition.Not, ): Unit = try { - CompoundPredicateOfAssetPredicateBox.write( - writer, - instance.compoundPredicateOfAssetPredicateBox, - ) + CompoundPredicateOfAssetDefinition.write(writer, instance.compoundPredicateOfAssetDefinition) } catch (ex: Exception) { throw wrapException(ex) } @@ -94,19 +89,17 @@ public sealed class CompoundPredicateOfAssetPredicateBox : ModelEnum { /** * 'And' variant */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfAssetPredicateBox() { + public data class And(public val vec: List) : CompoundPredicateOfAssetDefinition() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetPredicateBox.And = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition.And = try { And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAssetPredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAssetDefinition.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -114,11 +107,11 @@ public sealed class CompoundPredicateOfAssetPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetPredicateBox.And, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition.And, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfAssetPredicateBox.write(writer, value) + CompoundPredicateOfAssetDefinition.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -129,19 +122,17 @@ public sealed class CompoundPredicateOfAssetPredicateBox : ModelEnum { /** * 'Or' variant */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfAssetPredicateBox() { + public data class Or(public val vec: List) : CompoundPredicateOfAssetDefinition() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetPredicateBox.Or = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition.Or = try { Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAssetPredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAssetDefinition.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -149,11 +140,11 @@ public sealed class CompoundPredicateOfAssetPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetPredicateBox.Or, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition.Or, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfAssetPredicateBox.write(writer, value) + CompoundPredicateOfAssetDefinition.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -162,26 +153,25 @@ public sealed class CompoundPredicateOfAssetPredicateBox : ModelEnum { } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfAssetPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfAssetDefinition = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) 1 -> Not.read(reader) 2 -> And.read(reader) 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfAssetPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfAssetDefinition) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) 1 -> Not.write(writer, instance as Not) 2 -> And.write(writer, instance as And) 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetDefinitionPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetDefinitionPredicateBox.kt deleted file mode 100644 index c1e438290..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetDefinitionPredicateBox.kt +++ /dev/null @@ -1,189 +0,0 @@ -// -// 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 -import kotlin.collections.List - -/** - * CompoundPredicateOfAssetDefinitionPredicateBox - * - * Generated from 'CompoundPredicateOfAssetDefinitionPredicateBox' enum - */ -public sealed class CompoundPredicateOfAssetDefinitionPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Atom' variant - */ - public data class Atom( - public val assetDefinitionPredicateBox: AssetDefinitionPredicateBox, - ) : CompoundPredicateOfAssetDefinitionPredicateBox() { - 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.CompoundPredicateOfAssetDefinitionPredicateBox.Atom = try { - Atom( - AssetDefinitionPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinitionPredicateBox.Atom, - ): Unit = try { - AssetDefinitionPredicateBox.write(writer, instance.assetDefinitionPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val compoundPredicateOfAssetDefinitionPredicateBox: - CompoundPredicateOfAssetDefinitionPredicateBox, - ) : CompoundPredicateOfAssetDefinitionPredicateBox() { - 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.CompoundPredicateOfAssetDefinitionPredicateBox.Not = try { - Not( - CompoundPredicateOfAssetDefinitionPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinitionPredicateBox.Not, - ): Unit = try { - CompoundPredicateOfAssetDefinitionPredicateBox.write( - writer, - instance.compoundPredicateOfAssetDefinitionPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'And' variant - */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfAssetDefinitionPredicateBox() { - 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.CompoundPredicateOfAssetDefinitionPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAssetDefinitionPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinitionPredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfAssetDefinitionPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfAssetDefinitionPredicateBox() { - 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.CompoundPredicateOfAssetDefinitionPredicateBox.Or = try { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAssetDefinitionPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinitionPredicateBox.Or, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfAssetDefinitionPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfAssetDefinitionPredicateBox = - when (val discriminant = reader.readUByte()) { - 0 -> Atom.read(reader) - 1 -> Not.read(reader) - 2 -> And.read(reader) - 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write( - writer: ScaleCodecWriter, - instance: CompoundPredicateOfAssetDefinitionPredicateBox, - ) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Atom.write(writer, instance as Atom) - 1 -> Not.write(writer, instance as Not) - 2 -> And.write(writer, instance as And) - 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfDomainPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfBlockHeader.kt similarity index 65% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfDomainPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfBlockHeader.kt index 08a709838..023eec8fc 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfDomainPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfBlockHeader.kt @@ -14,11 +14,11 @@ import kotlin.Unit import kotlin.collections.List /** - * CompoundPredicateOfDomainPredicateBox + * CompoundPredicateOfBlockHeader * - * Generated from 'CompoundPredicateOfDomainPredicateBox' enum + * Generated from 'CompoundPredicateOfBlockHeader' enum */ -public sealed class CompoundPredicateOfDomainPredicateBox : ModelEnum { +public sealed class CompoundPredicateOfBlockHeader : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -27,19 +27,18 @@ public sealed class CompoundPredicateOfDomainPredicateBox : ModelEnum { /** * 'Atom' variant */ - public data class Atom( - public val domainPredicateBox: DomainPredicateBox, - ) : CompoundPredicateOfDomainPredicateBox() { + public data class Atom(public val blockHeaderProjectionOfPredicateMarker: BlockHeaderProjectionOfPredicateMarker) : + CompoundPredicateOfBlockHeader() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomainPredicateBox.Atom = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeader.Atom = try { Atom( - DomainPredicateBox.read(reader), + BlockHeaderProjectionOfPredicateMarker.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -47,9 +46,9 @@ public sealed class CompoundPredicateOfDomainPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomainPredicateBox.Atom, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeader.Atom, ): Unit = try { - DomainPredicateBox.write(writer, instance.domainPredicateBox) + BlockHeaderProjectionOfPredicateMarker.write(writer, instance.blockHeaderProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } @@ -59,19 +58,17 @@ public sealed class CompoundPredicateOfDomainPredicateBox : ModelEnum { /** * 'Not' variant */ - public data class Not( - public val compoundPredicateOfDomainPredicateBox: CompoundPredicateOfDomainPredicateBox, - ) : CompoundPredicateOfDomainPredicateBox() { + public data class Not(public val compoundPredicateOfBlockHeader: CompoundPredicateOfBlockHeader) : CompoundPredicateOfBlockHeader() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomainPredicateBox.Not = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeader.Not = try { Not( - CompoundPredicateOfDomainPredicateBox.read(reader), + CompoundPredicateOfBlockHeader.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -79,12 +76,9 @@ public sealed class CompoundPredicateOfDomainPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomainPredicateBox.Not, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeader.Not, ): Unit = try { - CompoundPredicateOfDomainPredicateBox.write( - writer, - instance.compoundPredicateOfDomainPredicateBox, - ) + CompoundPredicateOfBlockHeader.write(writer, instance.compoundPredicateOfBlockHeader) } catch (ex: Exception) { throw wrapException(ex) } @@ -94,19 +88,17 @@ public sealed class CompoundPredicateOfDomainPredicateBox : ModelEnum { /** * 'And' variant */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfDomainPredicateBox() { + public data class And(public val vec: List) : CompoundPredicateOfBlockHeader() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomainPredicateBox.And = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeader.And = try { And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfDomainPredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfBlockHeader.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -114,11 +106,11 @@ public sealed class CompoundPredicateOfDomainPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomainPredicateBox.And, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeader.And, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfDomainPredicateBox.write(writer, value) + CompoundPredicateOfBlockHeader.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -129,19 +121,17 @@ public sealed class CompoundPredicateOfDomainPredicateBox : ModelEnum { /** * 'Or' variant */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfDomainPredicateBox() { + public data class Or(public val vec: List) : CompoundPredicateOfBlockHeader() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomainPredicateBox.Or = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeader.Or = try { Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfDomainPredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfBlockHeader.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -149,11 +139,11 @@ public sealed class CompoundPredicateOfDomainPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomainPredicateBox.Or, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeader.Or, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfDomainPredicateBox.write(writer, value) + CompoundPredicateOfBlockHeader.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -162,26 +152,25 @@ public sealed class CompoundPredicateOfDomainPredicateBox : ModelEnum { } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfDomainPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfBlockHeader = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) 1 -> Not.read(reader) 2 -> And.read(reader) 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfDomainPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfBlockHeader) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) 1 -> Not.write(writer, instance as Not) 2 -> And.write(writer, instance as And) 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfBlockHeaderPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfBlockHeaderPredicateBox.kt deleted file mode 100644 index 143aa7d55..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfBlockHeaderPredicateBox.kt +++ /dev/null @@ -1,189 +0,0 @@ -// -// 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 -import kotlin.collections.List - -/** - * CompoundPredicateOfBlockHeaderPredicateBox - * - * Generated from 'CompoundPredicateOfBlockHeaderPredicateBox' enum - */ -public sealed class CompoundPredicateOfBlockHeaderPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Atom' variant - */ - public data class Atom( - public val blockHeaderPredicateBox: BlockHeaderPredicateBox, - ) : CompoundPredicateOfBlockHeaderPredicateBox() { - 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.CompoundPredicateOfBlockHeaderPredicateBox.Atom = try { - Atom( - BlockHeaderPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeaderPredicateBox.Atom, - ): Unit = try { - BlockHeaderPredicateBox.write(writer, instance.blockHeaderPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val compoundPredicateOfBlockHeaderPredicateBox: - CompoundPredicateOfBlockHeaderPredicateBox, - ) : CompoundPredicateOfBlockHeaderPredicateBox() { - 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.CompoundPredicateOfBlockHeaderPredicateBox.Not = try { - Not( - CompoundPredicateOfBlockHeaderPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeaderPredicateBox.Not, - ): Unit = try { - CompoundPredicateOfBlockHeaderPredicateBox.write( - writer, - instance.compoundPredicateOfBlockHeaderPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'And' variant - */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfBlockHeaderPredicateBox() { - 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.CompoundPredicateOfBlockHeaderPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfBlockHeaderPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeaderPredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfBlockHeaderPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfBlockHeaderPredicateBox() { - 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.CompoundPredicateOfBlockHeaderPredicateBox.Or = try { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfBlockHeaderPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeaderPredicateBox.Or, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfBlockHeaderPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfBlockHeaderPredicateBox = - when (val discriminant = reader.readUByte()) { - 0 -> Atom.read(reader) - 1 -> Not.read(reader) - 2 -> And.read(reader) - 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write( - writer: ScaleCodecWriter, - instance: CompoundPredicateOfBlockHeaderPredicateBox, - ) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Atom.write(writer, instance as Atom) - 1 -> Not.write(writer, instance as Not) - 2 -> And.write(writer, instance as And) - 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPermissionPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfCommittedTransaction.kt similarity index 57% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPermissionPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfCommittedTransaction.kt index 90ad9bb31..f80ae072a 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPermissionPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfCommittedTransaction.kt @@ -14,11 +14,11 @@ import kotlin.Unit import kotlin.collections.List /** - * CompoundPredicateOfPermissionPredicateBox + * CompoundPredicateOfCommittedTransaction * - * Generated from 'CompoundPredicateOfPermissionPredicateBox' enum + * Generated from 'CompoundPredicateOfCommittedTransaction' enum */ -public sealed class CompoundPredicateOfPermissionPredicateBox : ModelEnum { +public sealed class CompoundPredicateOfCommittedTransaction : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -27,29 +27,29 @@ public sealed class CompoundPredicateOfPermissionPredicateBox : ModelEnum { /** * 'Atom' variant */ - public data class Atom( - public val permissionPredicateBox: PermissionPredicateBox, - ) : CompoundPredicateOfPermissionPredicateBox() { + public data class Atom(public val committedTransactionProjectionOfPredicateMarker: CommittedTransactionProjectionOfPredicateMarker) : + CompoundPredicateOfCommittedTransaction() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermissionPredicateBox.Atom = try { - Atom( - PermissionPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction.Atom = + try { + Atom( + CommittedTransactionProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermissionPredicateBox.Atom, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction.Atom, ): Unit = try { - PermissionPredicateBox.write(writer, instance.permissionPredicateBox) + CommittedTransactionProjectionOfPredicateMarker.write(writer, instance.committedTransactionProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } @@ -59,32 +59,29 @@ public sealed class CompoundPredicateOfPermissionPredicateBox : ModelEnum { /** * 'Not' variant */ - public data class Not( - public val compoundPredicateOfPermissionPredicateBox: CompoundPredicateOfPermissionPredicateBox, - ) : CompoundPredicateOfPermissionPredicateBox() { + public data class Not(public val compoundPredicateOfCommittedTransaction: CompoundPredicateOfCommittedTransaction) : + CompoundPredicateOfCommittedTransaction() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermissionPredicateBox.Not = try { - Not( - CompoundPredicateOfPermissionPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction.Not = + try { + Not( + CompoundPredicateOfCommittedTransaction.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermissionPredicateBox.Not, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction.Not, ): Unit = try { - CompoundPredicateOfPermissionPredicateBox.write( - writer, - instance.compoundPredicateOfPermissionPredicateBox, - ) + CompoundPredicateOfCommittedTransaction.write(writer, instance.compoundPredicateOfCommittedTransaction) } catch (ex: Exception) { throw wrapException(ex) } @@ -94,31 +91,30 @@ public sealed class CompoundPredicateOfPermissionPredicateBox : ModelEnum { /** * 'And' variant */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfPermissionPredicateBox() { + public data class And(public val vec: List) : CompoundPredicateOfCommittedTransaction() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermissionPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPermissionPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction.And = + try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfCommittedTransaction.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermissionPredicateBox.And, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction.And, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfPermissionPredicateBox.write(writer, value) + CompoundPredicateOfCommittedTransaction.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -129,19 +125,17 @@ public sealed class CompoundPredicateOfPermissionPredicateBox : ModelEnum { /** * 'Or' variant */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfPermissionPredicateBox() { + public data class Or(public val vec: List) : CompoundPredicateOfCommittedTransaction() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermissionPredicateBox.Or = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction.Or = try { Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPermissionPredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfCommittedTransaction.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -149,11 +143,11 @@ public sealed class CompoundPredicateOfPermissionPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermissionPredicateBox.Or, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction.Or, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfPermissionPredicateBox.write(writer, value) + CompoundPredicateOfCommittedTransaction.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -162,27 +156,26 @@ public sealed class CompoundPredicateOfPermissionPredicateBox : ModelEnum { } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfPermissionPredicateBox = + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfCommittedTransaction = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) 1 -> Not.read(reader) 2 -> And.read(reader) 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write( - writer: ScaleCodecWriter, - instance: CompoundPredicateOfPermissionPredicateBox, - ) { + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfCommittedTransaction) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) 1 -> Not.write(writer, instance as Not) 2 -> And.write(writer, instance as And) 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRolePredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfDomain.kt similarity index 53% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRolePredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfDomain.kt index 83ddb0d6f..c71414ce6 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRolePredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfDomain.kt @@ -14,11 +14,11 @@ import kotlin.Unit import kotlin.collections.List /** - * CompoundPredicateOfRolePredicateBox + * CompoundPredicateOfDomain * - * Generated from 'CompoundPredicateOfRolePredicateBox' enum + * Generated from 'CompoundPredicateOfDomain' enum */ -public sealed class CompoundPredicateOfRolePredicateBox : ModelEnum { +public sealed class CompoundPredicateOfDomain : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -27,134 +27,114 @@ public sealed class CompoundPredicateOfRolePredicateBox : ModelEnum { /** * 'Atom' variant */ - public data class Atom( - public val rolePredicateBox: RolePredicateBox, - ) : CompoundPredicateOfRolePredicateBox() { + public data class Atom(public val domainProjectionOfPredicateMarker: DomainProjectionOfPredicateMarker) : CompoundPredicateOfDomain() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRolePredicateBox.Atom = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain.Atom = try { Atom( - RolePredicateBox.read(reader), + DomainProjectionOfPredicateMarker.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRolePredicateBox.Atom, - ): Unit = try { - RolePredicateBox.write(writer, instance.rolePredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain.Atom): Unit = + try { + DomainProjectionOfPredicateMarker.write(writer, instance.domainProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Not' variant */ - public data class Not( - public val compoundPredicateOfRolePredicateBox: CompoundPredicateOfRolePredicateBox, - ) : CompoundPredicateOfRolePredicateBox() { + public data class Not(public val compoundPredicateOfDomain: CompoundPredicateOfDomain) : CompoundPredicateOfDomain() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRolePredicateBox.Not = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain.Not = try { Not( - CompoundPredicateOfRolePredicateBox.read(reader), + CompoundPredicateOfDomain.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRolePredicateBox.Not, - ): Unit = try { - CompoundPredicateOfRolePredicateBox.write( - writer, - instance.compoundPredicateOfRolePredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain.Not): Unit = + try { + CompoundPredicateOfDomain.write(writer, instance.compoundPredicateOfDomain) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'And' variant */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfRolePredicateBox() { + public data class And(public val vec: List) : CompoundPredicateOfDomain() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRolePredicateBox.And = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain.And = try { And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfRolePredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfDomain.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRolePredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfRolePredicateBox.write(writer, value) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain.And): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfDomain.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } /** * 'Or' variant */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfRolePredicateBox() { + public data class Or(public val vec: List) : CompoundPredicateOfDomain() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRolePredicateBox.Or = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain.Or = try { Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfRolePredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfDomain.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRolePredicateBox.Or, - ): Unit = + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain.Or): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfRolePredicateBox.write(writer, value) + CompoundPredicateOfDomain.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -163,26 +143,25 @@ public sealed class CompoundPredicateOfRolePredicateBox : ModelEnum { } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfRolePredicateBox = when ( - val - discriminant = reader.readUByte() - ) { + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfDomain = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) 1 -> Not.read(reader) 2 -> And.read(reader) 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfRolePredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfDomain) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) 1 -> Not.write(writer, instance as Not) 2 -> And.write(writer, instance as And) 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPeerId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPeerId.kt new file mode 100644 index 000000000..a488e01f2 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPeerId.kt @@ -0,0 +1,167 @@ +// +// 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 +import kotlin.collections.List + +/** + * CompoundPredicateOfPeerId + * + * Generated from 'CompoundPredicateOfPeerId' enum + */ +public sealed class CompoundPredicateOfPeerId : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val peerIdProjectionOfPredicateMarker: PeerIdProjectionOfPredicateMarker) : CompoundPredicateOfPeerId() { + 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.CompoundPredicateOfPeerId.Atom = try { + Atom( + PeerIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerId.Atom): Unit = + try { + PeerIdProjectionOfPredicateMarker.write(writer, instance.peerIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Not' variant + */ + public data class Not(public val compoundPredicateOfPeerId: CompoundPredicateOfPeerId) : CompoundPredicateOfPeerId() { + 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.CompoundPredicateOfPeerId.Not = try { + Not( + CompoundPredicateOfPeerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerId.Not): Unit = + try { + CompoundPredicateOfPeerId.write(writer, instance.compoundPredicateOfPeerId) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'And' variant + */ + public data class And(public val vec: List) : CompoundPredicateOfPeerId() { + 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.CompoundPredicateOfPeerId.And = try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPeerId.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerId.And): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfPeerId.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Or' variant + */ + public data class Or(public val vec: List) : CompoundPredicateOfPeerId() { + 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.CompoundPredicateOfPeerId.Or = try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPeerId.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerId.Or): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfPeerId.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfPeerId = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Not.read(reader) + 2 -> And.read(reader) + 3 -> Or.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfPeerId) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Not.write(writer, instance as Not) + 2 -> And.write(writer, instance as And) + 3 -> Or.write(writer, instance as Or) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRoleIdPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPermission.kt similarity index 65% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRoleIdPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPermission.kt index 4c871c6cd..8608589b6 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRoleIdPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPermission.kt @@ -14,11 +14,11 @@ import kotlin.Unit import kotlin.collections.List /** - * CompoundPredicateOfRoleIdPredicateBox + * CompoundPredicateOfPermission * - * Generated from 'CompoundPredicateOfRoleIdPredicateBox' enum + * Generated from 'CompoundPredicateOfPermission' enum */ -public sealed class CompoundPredicateOfRoleIdPredicateBox : ModelEnum { +public sealed class CompoundPredicateOfPermission : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -27,19 +27,18 @@ public sealed class CompoundPredicateOfRoleIdPredicateBox : ModelEnum { /** * 'Atom' variant */ - public data class Atom( - public val roleIdPredicateBox: RoleIdPredicateBox, - ) : CompoundPredicateOfRoleIdPredicateBox() { + public data class Atom(public val permissionProjectionOfPredicateMarker: PermissionProjectionOfPredicateMarker) : + CompoundPredicateOfPermission() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleIdPredicateBox.Atom = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission.Atom = try { Atom( - RoleIdPredicateBox.read(reader), + PermissionProjectionOfPredicateMarker.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -47,9 +46,9 @@ public sealed class CompoundPredicateOfRoleIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleIdPredicateBox.Atom, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission.Atom, ): Unit = try { - RoleIdPredicateBox.write(writer, instance.roleIdPredicateBox) + PermissionProjectionOfPredicateMarker.write(writer, instance.permissionProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } @@ -59,19 +58,17 @@ public sealed class CompoundPredicateOfRoleIdPredicateBox : ModelEnum { /** * 'Not' variant */ - public data class Not( - public val compoundPredicateOfRoleIdPredicateBox: CompoundPredicateOfRoleIdPredicateBox, - ) : CompoundPredicateOfRoleIdPredicateBox() { + public data class Not(public val compoundPredicateOfPermission: CompoundPredicateOfPermission) : CompoundPredicateOfPermission() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleIdPredicateBox.Not = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission.Not = try { Not( - CompoundPredicateOfRoleIdPredicateBox.read(reader), + CompoundPredicateOfPermission.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -79,12 +76,9 @@ public sealed class CompoundPredicateOfRoleIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleIdPredicateBox.Not, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission.Not, ): Unit = try { - CompoundPredicateOfRoleIdPredicateBox.write( - writer, - instance.compoundPredicateOfRoleIdPredicateBox, - ) + CompoundPredicateOfPermission.write(writer, instance.compoundPredicateOfPermission) } catch (ex: Exception) { throw wrapException(ex) } @@ -94,19 +88,17 @@ public sealed class CompoundPredicateOfRoleIdPredicateBox : ModelEnum { /** * 'And' variant */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfRoleIdPredicateBox() { + public data class And(public val vec: List) : CompoundPredicateOfPermission() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleIdPredicateBox.And = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission.And = try { And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfRoleIdPredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPermission.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -114,11 +106,11 @@ public sealed class CompoundPredicateOfRoleIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleIdPredicateBox.And, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission.And, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfRoleIdPredicateBox.write(writer, value) + CompoundPredicateOfPermission.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -129,19 +121,17 @@ public sealed class CompoundPredicateOfRoleIdPredicateBox : ModelEnum { /** * 'Or' variant */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfRoleIdPredicateBox() { + public data class Or(public val vec: List) : CompoundPredicateOfPermission() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleIdPredicateBox.Or = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission.Or = try { Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfRoleIdPredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPermission.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -149,11 +139,11 @@ public sealed class CompoundPredicateOfRoleIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleIdPredicateBox.Or, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission.Or, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfRoleIdPredicateBox.write(writer, value) + CompoundPredicateOfPermission.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -162,26 +152,25 @@ public sealed class CompoundPredicateOfRoleIdPredicateBox : ModelEnum { } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfRoleIdPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfPermission = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) 1 -> Not.read(reader) 2 -> And.read(reader) 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfRoleIdPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfPermission) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) 1 -> Not.write(writer, instance as Not) 2 -> And.write(writer, instance as And) 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRole.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRole.kt new file mode 100644 index 000000000..fdd9c67e3 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRole.kt @@ -0,0 +1,167 @@ +// +// 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 +import kotlin.collections.List + +/** + * CompoundPredicateOfRole + * + * Generated from 'CompoundPredicateOfRole' enum + */ +public sealed class CompoundPredicateOfRole : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val roleProjectionOfPredicateMarker: RoleProjectionOfPredicateMarker) : CompoundPredicateOfRole() { + 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.CompoundPredicateOfRole.Atom = try { + Atom( + RoleProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRole.Atom): Unit = + try { + RoleProjectionOfPredicateMarker.write(writer, instance.roleProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Not' variant + */ + public data class Not(public val compoundPredicateOfRole: CompoundPredicateOfRole) : CompoundPredicateOfRole() { + 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.CompoundPredicateOfRole.Not = try { + Not( + CompoundPredicateOfRole.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRole.Not): Unit = + try { + CompoundPredicateOfRole.write(writer, instance.compoundPredicateOfRole) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'And' variant + */ + public data class And(public val vec: List) : CompoundPredicateOfRole() { + 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.CompoundPredicateOfRole.And = try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfRole.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRole.And): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfRole.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Or' variant + */ + public data class Or(public val vec: List) : CompoundPredicateOfRole() { + 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.CompoundPredicateOfRole.Or = try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfRole.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRole.Or): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfRole.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfRole = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Not.read(reader) + 2 -> And.read(reader) + 3 -> Or.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfRole) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Not.write(writer, instance as Not) + 2 -> And.write(writer, instance as And) + 3 -> Or.write(writer, instance as Or) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRoleId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRoleId.kt new file mode 100644 index 000000000..3964b4b45 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRoleId.kt @@ -0,0 +1,167 @@ +// +// 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 +import kotlin.collections.List + +/** + * CompoundPredicateOfRoleId + * + * Generated from 'CompoundPredicateOfRoleId' enum + */ +public sealed class CompoundPredicateOfRoleId : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val roleIdProjectionOfPredicateMarker: RoleIdProjectionOfPredicateMarker) : CompoundPredicateOfRoleId() { + 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.CompoundPredicateOfRoleId.Atom = try { + Atom( + RoleIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleId.Atom): Unit = + try { + RoleIdProjectionOfPredicateMarker.write(writer, instance.roleIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Not' variant + */ + public data class Not(public val compoundPredicateOfRoleId: CompoundPredicateOfRoleId) : CompoundPredicateOfRoleId() { + 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.CompoundPredicateOfRoleId.Not = try { + Not( + CompoundPredicateOfRoleId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleId.Not): Unit = + try { + CompoundPredicateOfRoleId.write(writer, instance.compoundPredicateOfRoleId) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'And' variant + */ + public data class And(public val vec: List) : CompoundPredicateOfRoleId() { + 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.CompoundPredicateOfRoleId.And = try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfRoleId.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleId.And): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfRoleId.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Or' variant + */ + public data class Or(public val vec: List) : CompoundPredicateOfRoleId() { + 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.CompoundPredicateOfRoleId.Or = try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfRoleId.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleId.Or): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfRoleId.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfRoleId = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Not.read(reader) + 2 -> And.read(reader) + 3 -> Or.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfRoleId) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Not.write(writer, instance as Not) + 2 -> And.write(writer, instance as And) + 3 -> Or.write(writer, instance as Or) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAccountPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfSignedBlock.kt similarity index 65% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAccountPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfSignedBlock.kt index 45b664893..d349d9a18 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAccountPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfSignedBlock.kt @@ -14,11 +14,11 @@ import kotlin.Unit import kotlin.collections.List /** - * CompoundPredicateOfAccountPredicateBox + * CompoundPredicateOfSignedBlock * - * Generated from 'CompoundPredicateOfAccountPredicateBox' enum + * Generated from 'CompoundPredicateOfSignedBlock' enum */ -public sealed class CompoundPredicateOfAccountPredicateBox : ModelEnum { +public sealed class CompoundPredicateOfSignedBlock : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -27,19 +27,18 @@ public sealed class CompoundPredicateOfAccountPredicateBox : ModelEnum { /** * 'Atom' variant */ - public data class Atom( - public val accountPredicateBox: AccountPredicateBox, - ) : CompoundPredicateOfAccountPredicateBox() { + public data class Atom(public val signedBlockProjectionOfPredicateMarker: SignedBlockProjectionOfPredicateMarker) : + CompoundPredicateOfSignedBlock() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccountPredicateBox.Atom = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock.Atom = try { Atom( - AccountPredicateBox.read(reader), + SignedBlockProjectionOfPredicateMarker.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -47,9 +46,9 @@ public sealed class CompoundPredicateOfAccountPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccountPredicateBox.Atom, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock.Atom, ): Unit = try { - AccountPredicateBox.write(writer, instance.accountPredicateBox) + SignedBlockProjectionOfPredicateMarker.write(writer, instance.signedBlockProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } @@ -59,19 +58,17 @@ public sealed class CompoundPredicateOfAccountPredicateBox : ModelEnum { /** * 'Not' variant */ - public data class Not( - public val compoundPredicateOfAccountPredicateBox: CompoundPredicateOfAccountPredicateBox, - ) : CompoundPredicateOfAccountPredicateBox() { + public data class Not(public val compoundPredicateOfSignedBlock: CompoundPredicateOfSignedBlock) : CompoundPredicateOfSignedBlock() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccountPredicateBox.Not = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock.Not = try { Not( - CompoundPredicateOfAccountPredicateBox.read(reader), + CompoundPredicateOfSignedBlock.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -79,12 +76,9 @@ public sealed class CompoundPredicateOfAccountPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccountPredicateBox.Not, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock.Not, ): Unit = try { - CompoundPredicateOfAccountPredicateBox.write( - writer, - instance.compoundPredicateOfAccountPredicateBox, - ) + CompoundPredicateOfSignedBlock.write(writer, instance.compoundPredicateOfSignedBlock) } catch (ex: Exception) { throw wrapException(ex) } @@ -94,19 +88,17 @@ public sealed class CompoundPredicateOfAccountPredicateBox : ModelEnum { /** * 'And' variant */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfAccountPredicateBox() { + public data class And(public val vec: List) : CompoundPredicateOfSignedBlock() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccountPredicateBox.And = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock.And = try { And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAccountPredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfSignedBlock.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -114,11 +106,11 @@ public sealed class CompoundPredicateOfAccountPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccountPredicateBox.And, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock.And, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfAccountPredicateBox.write(writer, value) + CompoundPredicateOfSignedBlock.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -129,19 +121,17 @@ public sealed class CompoundPredicateOfAccountPredicateBox : ModelEnum { /** * 'Or' variant */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfAccountPredicateBox() { + public data class Or(public val vec: List) : CompoundPredicateOfSignedBlock() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccountPredicateBox.Or = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock.Or = try { Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAccountPredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfSignedBlock.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -149,11 +139,11 @@ public sealed class CompoundPredicateOfAccountPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccountPredicateBox.Or, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock.Or, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfAccountPredicateBox.write(writer, value) + CompoundPredicateOfSignedBlock.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -162,26 +152,25 @@ public sealed class CompoundPredicateOfAccountPredicateBox : ModelEnum { } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfAccountPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfSignedBlock = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) 1 -> Not.read(reader) 2 -> And.read(reader) 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfAccountPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfSignedBlock) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) 1 -> Not.write(writer, instance as Not) 2 -> And.write(writer, instance as And) 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfSignedBlockPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfSignedBlockPredicateBox.kt deleted file mode 100644 index a598a6962..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfSignedBlockPredicateBox.kt +++ /dev/null @@ -1,189 +0,0 @@ -// -// 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 -import kotlin.collections.List - -/** - * CompoundPredicateOfSignedBlockPredicateBox - * - * Generated from 'CompoundPredicateOfSignedBlockPredicateBox' enum - */ -public sealed class CompoundPredicateOfSignedBlockPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Atom' variant - */ - public data class Atom( - public val signedBlockPredicateBox: SignedBlockPredicateBox, - ) : CompoundPredicateOfSignedBlockPredicateBox() { - 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.CompoundPredicateOfSignedBlockPredicateBox.Atom = try { - Atom( - SignedBlockPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlockPredicateBox.Atom, - ): Unit = try { - SignedBlockPredicateBox.write(writer, instance.signedBlockPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val compoundPredicateOfSignedBlockPredicateBox: - CompoundPredicateOfSignedBlockPredicateBox, - ) : CompoundPredicateOfSignedBlockPredicateBox() { - 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.CompoundPredicateOfSignedBlockPredicateBox.Not = try { - Not( - CompoundPredicateOfSignedBlockPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlockPredicateBox.Not, - ): Unit = try { - CompoundPredicateOfSignedBlockPredicateBox.write( - writer, - instance.compoundPredicateOfSignedBlockPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'And' variant - */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfSignedBlockPredicateBox() { - 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.CompoundPredicateOfSignedBlockPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfSignedBlockPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlockPredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfSignedBlockPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfSignedBlockPredicateBox() { - 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.CompoundPredicateOfSignedBlockPredicateBox.Or = try { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfSignedBlockPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlockPredicateBox.Or, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfSignedBlockPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfSignedBlockPredicateBox = - when (val discriminant = reader.readUByte()) { - 0 -> Atom.read(reader) - 1 -> Not.read(reader) - 2 -> And.read(reader) - 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write( - writer: ScaleCodecWriter, - instance: CompoundPredicateOfSignedBlockPredicateBox, - ) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Atom.write(writer, instance as Atom) - 1 -> Not.write(writer, instance as Not) - 2 -> And.write(writer, instance as And) - 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTransactionQueryOutputPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTransactionQueryOutputPredicateBox.kt deleted file mode 100644 index 63af5b66a..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTransactionQueryOutputPredicateBox.kt +++ /dev/null @@ -1,194 +0,0 @@ -// -// 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 -import kotlin.collections.List - -/** - * CompoundPredicateOfTransactionQueryOutputPredicateBox - * - * Generated from 'CompoundPredicateOfTransactionQueryOutputPredicateBox' enum - */ -public sealed class CompoundPredicateOfTransactionQueryOutputPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Atom' variant - */ - public data class Atom( - public val transactionQueryOutputPredicateBox: TransactionQueryOutputPredicateBox, - ) : CompoundPredicateOfTransactionQueryOutputPredicateBox() { - 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.CompoundPredicateOfTransactionQueryOutputPredicateBox.Atom = try { - Atom( - TransactionQueryOutputPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTransactionQueryOutputPredicateBox.Atom, - ): Unit = try { - TransactionQueryOutputPredicateBox.write( - writer, - instance.transactionQueryOutputPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val compoundPredicateOfTransactionQueryOutputPredicateBox: - CompoundPredicateOfTransactionQueryOutputPredicateBox, - ) : CompoundPredicateOfTransactionQueryOutputPredicateBox() { - 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.CompoundPredicateOfTransactionQueryOutputPredicateBox.Not = try { - Not( - CompoundPredicateOfTransactionQueryOutputPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTransactionQueryOutputPredicateBox.Not, - ): Unit = try { - CompoundPredicateOfTransactionQueryOutputPredicateBox.write( - writer, - instance.compoundPredicateOfTransactionQueryOutputPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'And' variant - */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfTransactionQueryOutputPredicateBox() { - 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.CompoundPredicateOfTransactionQueryOutputPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfTransactionQueryOutputPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTransactionQueryOutputPredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfTransactionQueryOutputPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfTransactionQueryOutputPredicateBox() { - 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.CompoundPredicateOfTransactionQueryOutputPredicateBox.Or = try { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfTransactionQueryOutputPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTransactionQueryOutputPredicateBox.Or, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfTransactionQueryOutputPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfTransactionQueryOutputPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Atom.read(reader) - 1 -> Not.read(reader) - 2 -> And.read(reader) - 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write( - writer: ScaleCodecWriter, - instance: CompoundPredicateOfTransactionQueryOutputPredicateBox, - ) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Atom.write(writer, instance as Atom) - 1 -> Not.write(writer, instance as Not) - 2 -> And.write(writer, instance as And) - 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTrigger.kt new file mode 100644 index 000000000..d57df0706 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTrigger.kt @@ -0,0 +1,168 @@ +// +// 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 +import kotlin.collections.List + +/** + * CompoundPredicateOfTrigger + * + * Generated from 'CompoundPredicateOfTrigger' enum + */ +public sealed class CompoundPredicateOfTrigger : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val triggerProjectionOfPredicateMarker: TriggerProjectionOfPredicateMarker) : + CompoundPredicateOfTrigger() { + 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.CompoundPredicateOfTrigger.Atom = try { + Atom( + TriggerProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTrigger.Atom): Unit = + try { + TriggerProjectionOfPredicateMarker.write(writer, instance.triggerProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Not' variant + */ + public data class Not(public val compoundPredicateOfTrigger: CompoundPredicateOfTrigger) : CompoundPredicateOfTrigger() { + 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.CompoundPredicateOfTrigger.Not = try { + Not( + CompoundPredicateOfTrigger.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTrigger.Not): Unit = + try { + CompoundPredicateOfTrigger.write(writer, instance.compoundPredicateOfTrigger) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'And' variant + */ + public data class And(public val vec: List) : CompoundPredicateOfTrigger() { + 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.CompoundPredicateOfTrigger.And = try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfTrigger.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTrigger.And): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfTrigger.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Or' variant + */ + public data class Or(public val vec: List) : CompoundPredicateOfTrigger() { + 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.CompoundPredicateOfTrigger.Or = try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfTrigger.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTrigger.Or): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfTrigger.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfTrigger = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Not.read(reader) + 2 -> And.read(reader) + 3 -> Or.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfTrigger) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Not.write(writer, instance as Not) + 2 -> And.write(writer, instance as And) + 3 -> Or.write(writer, instance as Or) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPeerPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTriggerId.kt similarity index 64% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPeerPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTriggerId.kt index c173ec28c..fad9e7e25 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPeerPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTriggerId.kt @@ -14,11 +14,11 @@ import kotlin.Unit import kotlin.collections.List /** - * CompoundPredicateOfPeerPredicateBox + * CompoundPredicateOfTriggerId * - * Generated from 'CompoundPredicateOfPeerPredicateBox' enum + * Generated from 'CompoundPredicateOfTriggerId' enum */ -public sealed class CompoundPredicateOfPeerPredicateBox : ModelEnum { +public sealed class CompoundPredicateOfTriggerId : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -27,19 +27,18 @@ public sealed class CompoundPredicateOfPeerPredicateBox : ModelEnum { /** * 'Atom' variant */ - public data class Atom( - public val peerPredicateBox: PeerPredicateBox, - ) : CompoundPredicateOfPeerPredicateBox() { + public data class Atom(public val triggerIdProjectionOfPredicateMarker: TriggerIdProjectionOfPredicateMarker) : + CompoundPredicateOfTriggerId() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerPredicateBox.Atom = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId.Atom = try { Atom( - PeerPredicateBox.read(reader), + TriggerIdProjectionOfPredicateMarker.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -47,9 +46,9 @@ public sealed class CompoundPredicateOfPeerPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerPredicateBox.Atom, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId.Atom, ): Unit = try { - PeerPredicateBox.write(writer, instance.peerPredicateBox) + TriggerIdProjectionOfPredicateMarker.write(writer, instance.triggerIdProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } @@ -59,19 +58,17 @@ public sealed class CompoundPredicateOfPeerPredicateBox : ModelEnum { /** * 'Not' variant */ - public data class Not( - public val compoundPredicateOfPeerPredicateBox: CompoundPredicateOfPeerPredicateBox, - ) : CompoundPredicateOfPeerPredicateBox() { + public data class Not(public val compoundPredicateOfTriggerId: CompoundPredicateOfTriggerId) : CompoundPredicateOfTriggerId() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerPredicateBox.Not = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId.Not = try { Not( - CompoundPredicateOfPeerPredicateBox.read(reader), + CompoundPredicateOfTriggerId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -79,12 +76,9 @@ public sealed class CompoundPredicateOfPeerPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerPredicateBox.Not, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId.Not, ): Unit = try { - CompoundPredicateOfPeerPredicateBox.write( - writer, - instance.compoundPredicateOfPeerPredicateBox, - ) + CompoundPredicateOfTriggerId.write(writer, instance.compoundPredicateOfTriggerId) } catch (ex: Exception) { throw wrapException(ex) } @@ -94,19 +88,17 @@ public sealed class CompoundPredicateOfPeerPredicateBox : ModelEnum { /** * 'And' variant */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfPeerPredicateBox() { + public data class And(public val vec: List) : CompoundPredicateOfTriggerId() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerPredicateBox.And = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId.And = try { And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPeerPredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfTriggerId.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -114,11 +106,11 @@ public sealed class CompoundPredicateOfPeerPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerPredicateBox.And, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId.And, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfPeerPredicateBox.write(writer, value) + CompoundPredicateOfTriggerId.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -129,32 +121,27 @@ public sealed class CompoundPredicateOfPeerPredicateBox : ModelEnum { /** * 'Or' variant */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfPeerPredicateBox() { + public data class Or(public val vec: List) : CompoundPredicateOfTriggerId() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerPredicateBox.Or = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId.Or = try { Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPeerPredicateBox.read(reader) }, + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfTriggerId.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerPredicateBox.Or, - ): Unit = + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId.Or): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfPeerPredicateBox.write(writer, value) + CompoundPredicateOfTriggerId.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -163,26 +150,25 @@ public sealed class CompoundPredicateOfPeerPredicateBox : ModelEnum { } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfPeerPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): CompoundPredicateOfTriggerId = when (val discriminant = reader.readUByte()) { 0 -> Atom.read(reader) 1 -> Not.read(reader) 2 -> And.read(reader) 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfPeerPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfTriggerId) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Atom.write(writer, instance as Atom) 1 -> Not.write(writer, instance as Not) 2 -> And.write(writer, instance as And) 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTriggerIdPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTriggerIdPredicateBox.kt deleted file mode 100644 index c57886dd7..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTriggerIdPredicateBox.kt +++ /dev/null @@ -1,190 +0,0 @@ -// -// 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 -import kotlin.collections.List - -/** - * CompoundPredicateOfTriggerIdPredicateBox - * - * Generated from 'CompoundPredicateOfTriggerIdPredicateBox' enum - */ -public sealed class CompoundPredicateOfTriggerIdPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Atom' variant - */ - public data class Atom( - public val triggerIdPredicateBox: TriggerIdPredicateBox, - ) : CompoundPredicateOfTriggerIdPredicateBox() { - 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.CompoundPredicateOfTriggerIdPredicateBox.Atom = try { - Atom( - TriggerIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerIdPredicateBox.Atom, - ): Unit = try { - TriggerIdPredicateBox.write(writer, instance.triggerIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val compoundPredicateOfTriggerIdPredicateBox: CompoundPredicateOfTriggerIdPredicateBox, - ) : CompoundPredicateOfTriggerIdPredicateBox() { - 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.CompoundPredicateOfTriggerIdPredicateBox.Not = try { - Not( - CompoundPredicateOfTriggerIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerIdPredicateBox.Not, - ): Unit = try { - CompoundPredicateOfTriggerIdPredicateBox.write( - writer, - instance.compoundPredicateOfTriggerIdPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'And' variant - */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfTriggerIdPredicateBox() { - 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.CompoundPredicateOfTriggerIdPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfTriggerIdPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerIdPredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfTriggerIdPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfTriggerIdPredicateBox() { - 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.CompoundPredicateOfTriggerIdPredicateBox.Or = try { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfTriggerIdPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerIdPredicateBox.Or, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfTriggerIdPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfTriggerIdPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { - 0 -> Atom.read(reader) - 1 -> Not.read(reader) - 2 -> And.read(reader) - 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write( - writer: ScaleCodecWriter, - instance: CompoundPredicateOfTriggerIdPredicateBox, - ) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Atom.write(writer, instance as Atom) - 1 -> Not.write(writer, instance as Not) - 2 -> And.write(writer, instance as And) - 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTriggerPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTriggerPredicateBox.kt deleted file mode 100644 index 3daba80e5..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTriggerPredicateBox.kt +++ /dev/null @@ -1,187 +0,0 @@ -// -// 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 -import kotlin.collections.List - -/** - * CompoundPredicateOfTriggerPredicateBox - * - * Generated from 'CompoundPredicateOfTriggerPredicateBox' enum - */ -public sealed class CompoundPredicateOfTriggerPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Atom' variant - */ - public data class Atom( - public val triggerPredicateBox: TriggerPredicateBox, - ) : CompoundPredicateOfTriggerPredicateBox() { - 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.CompoundPredicateOfTriggerPredicateBox.Atom = try { - Atom( - TriggerPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerPredicateBox.Atom, - ): Unit = try { - TriggerPredicateBox.write(writer, instance.triggerPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val compoundPredicateOfTriggerPredicateBox: CompoundPredicateOfTriggerPredicateBox, - ) : CompoundPredicateOfTriggerPredicateBox() { - 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.CompoundPredicateOfTriggerPredicateBox.Not = try { - Not( - CompoundPredicateOfTriggerPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerPredicateBox.Not, - ): Unit = try { - CompoundPredicateOfTriggerPredicateBox.write( - writer, - instance.compoundPredicateOfTriggerPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'And' variant - */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfTriggerPredicateBox() { - 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.CompoundPredicateOfTriggerPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfTriggerPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerPredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfTriggerPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfTriggerPredicateBox() { - 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.CompoundPredicateOfTriggerPredicateBox.Or = try { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfTriggerPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerPredicateBox.Or, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfTriggerPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfTriggerPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { - 0 -> Atom.read(reader) - 1 -> Not.read(reader) - 2 -> And.read(reader) - 3 -> Or.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: CompoundPredicateOfTriggerPredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Atom.write(writer, instance as Atom) - 1 -> Not.write(writer, instance as Not) - 2 -> And.write(writer, instance as And) - 3 -> Or.write(writer, instance as Or) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ConfigurationEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ConfigurationEvent.kt index 1a164848c..5e1a67c29 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ConfigurationEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ConfigurationEvent.kt @@ -26,9 +26,7 @@ public sealed class ConfigurationEvent : ModelEnum { /** * 'Changed' variant */ - public data class Changed( - public val parameterChanged: ParameterChanged, - ) : ConfigurationEvent() { + public data class Changed(public val parameterChanged: ParameterChanged) : ConfigurationEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,30 +42,27 @@ public sealed class ConfigurationEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.ConfigurationEvent.Changed, - ): Unit = try { - ParameterChanged.write(writer, instance.parameterChanged) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.ConfigurationEvent.Changed): Unit = + try { + ParameterChanged.write(writer, instance.parameterChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): ConfigurationEvent = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): ConfigurationEvent = when (val discriminant = reader.readUByte()) { 0 -> Changed.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: ConfigurationEvent) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Changed.write(writer, instance as Changed) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ConfigurationEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ConfigurationEventFilter.kt index fd34ea517..df238ede1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ConfigurationEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ConfigurationEventFilter.kt @@ -16,9 +16,7 @@ import kotlin.Unit * * Generated from 'ConfigurationEventFilter' regular structure */ -public data class ConfigurationEventFilter( - public val eventSet: Long, -) { +public data class ConfigurationEventFilter(public val eventSet: Long) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Container.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Container.kt deleted file mode 100644 index 4be10b719..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Container.kt +++ /dev/null @@ -1,143 +0,0 @@ -// -// 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 - -/** - * Container - * - * Generated from 'Container' enum - */ -public sealed class Container : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Any' variant - */ - public data class Any( - public val queryOutputPredicate: QueryOutputPredicate, - ) : Container() { - 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.Container.Any = - try { - Any( - QueryOutputPredicate.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Container.Any, - ): Unit = try { - QueryOutputPredicate.write(writer, instance.queryOutputPredicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'All' variant - */ - public data class All( - public val queryOutputPredicate: QueryOutputPredicate, - ) : Container() { - 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.Container.All = - try { - All( - QueryOutputPredicate.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Container.All, - ): Unit = try { - QueryOutputPredicate.write(writer, instance.queryOutputPredicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'AtIndex' variant - */ - public data class AtIndex( - public val atIndex: jp.co.soramitsu.iroha2.generated.AtIndex, - ) : Container() { - 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.Container.AtIndex = try { - AtIndex( - jp.co.soramitsu.iroha2.generated.AtIndex.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Container.AtIndex, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.AtIndex.write(writer, instance.atIndex) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Container = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Any.read(reader) - 1 -> All.read(reader) - 2 -> AtIndex.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: Container) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Any.write(writer, instance as Any) - 1 -> All.write(writer, instance as All) - 2 -> AtIndex.write(writer, instance as AtIndex) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CustomInstruction.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CustomInstruction.kt index c7cd7b2ce..ea76d0333 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CustomInstruction.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CustomInstruction.kt @@ -8,7 +8,6 @@ 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.String import kotlin.Unit /** @@ -16,20 +15,18 @@ import kotlin.Unit * * Generated from 'CustomInstruction' regular structure */ -public data class CustomInstruction( - public val payload: String, -) { +public data class CustomInstruction(public val payload: Json) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): CustomInstruction = try { CustomInstruction( - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } override fun write(writer: ScaleCodecWriter, instance: CustomInstruction): Unit = try { - writer.writeAsList(instance.payload.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.payload) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CustomParameter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CustomParameter.kt index 5d1aed51c..f729d6fab 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CustomParameter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CustomParameter.kt @@ -8,7 +8,6 @@ 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.String import kotlin.Unit /** @@ -16,15 +15,12 @@ import kotlin.Unit * * Generated from 'CustomParameter' regular structure */ -public data class CustomParameter( - public val id: CustomParameterId, - public val payload: String, -) { +public data class CustomParameter(public val id: CustomParameterId, public val payload: Json) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): CustomParameter = try { CustomParameter( CustomParameterId.read(reader), - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -32,7 +28,7 @@ public data class CustomParameter( override fun write(writer: ScaleCodecWriter, instance: CustomParameter): Unit = try { CustomParameterId.write(writer, instance.id) - writer.writeAsList(instance.payload.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.payload) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CustomParameterId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CustomParameterId.kt index 04e99cfda..fe127e868 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CustomParameterId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CustomParameterId.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'CustomParameterId' regular structure */ -public data class CustomParameterId( - public val name: Name, -) { +public data class CustomParameterId(public val name: Name) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): CustomParameterId = try { CustomParameterId( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DataEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DataEvent.kt index 426dfe055..d5ceb52c2 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DataEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DataEvent.kt @@ -26,9 +26,7 @@ public sealed class DataEvent : ModelEnum { /** * 'Peer' variant */ - public data class Peer( - public val peerEvent: PeerEvent, - ) : DataEvent() { + public data class Peer(public val peerEvent: PeerEvent) : DataEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -36,19 +34,15 @@ public sealed class DataEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEvent.Peer = - try { - Peer( - PeerEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEvent.Peer, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEvent.Peer = try { + Peer( + PeerEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEvent.Peer): Unit = try { PeerEvent.write(writer, instance.peerEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -59,9 +53,7 @@ public sealed class DataEvent : ModelEnum { /** * 'Domain' variant */ - public data class Domain( - public val domainEvent: DomainEvent, - ) : DataEvent() { + public data class Domain(public val domainEvent: DomainEvent) : DataEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -77,10 +69,7 @@ public sealed class DataEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEvent.Domain, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEvent.Domain): Unit = try { DomainEvent.write(writer, instance.domainEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -91,9 +80,7 @@ public sealed class DataEvent : ModelEnum { /** * 'Trigger' variant */ - public data class Trigger( - public val triggerEvent: TriggerEvent, - ) : DataEvent() { + public data class Trigger(public val triggerEvent: TriggerEvent) : DataEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -109,10 +96,7 @@ public sealed class DataEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEvent.Trigger, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEvent.Trigger): Unit = try { TriggerEvent.write(writer, instance.triggerEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -123,9 +107,7 @@ public sealed class DataEvent : ModelEnum { /** * 'Role' variant */ - public data class Role( - public val roleEvent: RoleEvent, - ) : DataEvent() { + public data class Role(public val roleEvent: RoleEvent) : DataEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -133,19 +115,15 @@ public sealed class DataEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEvent.Role = - try { - Role( - RoleEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEvent.Role, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEvent.Role = try { + Role( + RoleEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEvent.Role): Unit = try { RoleEvent.write(writer, instance.roleEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -156,9 +134,7 @@ public sealed class DataEvent : ModelEnum { /** * 'Configuration' variant */ - public data class Configuration( - public val configurationEvent: ConfigurationEvent, - ) : DataEvent() { + public data class Configuration(public val configurationEvent: ConfigurationEvent) : DataEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -174,10 +150,7 @@ public sealed class DataEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEvent.Configuration, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEvent.Configuration): Unit = try { ConfigurationEvent.write(writer, instance.configurationEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -188,9 +161,7 @@ public sealed class DataEvent : ModelEnum { /** * 'Executor' variant */ - public data class Executor( - public val executorEvent: ExecutorEvent, - ) : DataEvent() { + public data class Executor(public val executorEvent: ExecutorEvent) : DataEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -206,10 +177,7 @@ public sealed class DataEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEvent.Executor, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEvent.Executor): Unit = try { ExecutorEvent.write(writer, instance.executorEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -218,17 +186,15 @@ public sealed class DataEvent : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): DataEvent = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): DataEvent = when (val discriminant = reader.readUByte()) { 0 -> Peer.read(reader) 1 -> Domain.read(reader) 2 -> Trigger.read(reader) 3 -> Role.read(reader) 4 -> Configuration.read(reader) 5 -> Executor.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: DataEvent) { writer.directWrite(instance.discriminant()) @@ -239,7 +205,8 @@ public sealed class DataEvent : ModelEnum { 3 -> Role.write(writer, instance as Role) 4 -> Configuration.write(writer, instance as Configuration) 5 -> Executor.write(writer, instance as Executor) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DataEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DataEventFilter.kt index 1f7f25451..29e631ae1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DataEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DataEventFilter.kt @@ -26,11 +26,13 @@ public sealed class DataEventFilter : ModelEnum { override fun equals(other: kotlin.Any?): Boolean = when (this) { is Any -> Any.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is Any -> Any.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'Any' variant @@ -49,10 +51,7 @@ public sealed class DataEventFilter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Any, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Any): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -69,9 +68,7 @@ public sealed class DataEventFilter : ModelEnum { /** * 'Peer' variant */ - public data class Peer( - public val peerEventFilter: PeerEventFilter, - ) : DataEventFilter() { + public data class Peer(public val peerEventFilter: PeerEventFilter) : DataEventFilter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -87,10 +84,7 @@ public sealed class DataEventFilter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Peer, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Peer): Unit = try { PeerEventFilter.write(writer, instance.peerEventFilter) } catch (ex: Exception) { throw wrapException(ex) @@ -101,9 +95,7 @@ public sealed class DataEventFilter : ModelEnum { /** * 'Domain' variant */ - public data class Domain( - public val domainEventFilter: DomainEventFilter, - ) : DataEventFilter() { + public data class Domain(public val domainEventFilter: DomainEventFilter) : DataEventFilter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -119,10 +111,7 @@ public sealed class DataEventFilter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Domain, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Domain): Unit = try { DomainEventFilter.write(writer, instance.domainEventFilter) } catch (ex: Exception) { throw wrapException(ex) @@ -133,9 +122,7 @@ public sealed class DataEventFilter : ModelEnum { /** * 'Account' variant */ - public data class Account( - public val accountEventFilter: AccountEventFilter, - ) : DataEventFilter() { + public data class Account(public val accountEventFilter: AccountEventFilter) : DataEventFilter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -151,10 +138,7 @@ public sealed class DataEventFilter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Account, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Account): Unit = try { AccountEventFilter.write(writer, instance.accountEventFilter) } catch (ex: Exception) { throw wrapException(ex) @@ -165,9 +149,7 @@ public sealed class DataEventFilter : ModelEnum { /** * 'Asset' variant */ - public data class Asset( - public val assetEventFilter: AssetEventFilter, - ) : DataEventFilter() { + public data class Asset(public val assetEventFilter: AssetEventFilter) : DataEventFilter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -183,10 +165,7 @@ public sealed class DataEventFilter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Asset, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Asset): Unit = try { AssetEventFilter.write(writer, instance.assetEventFilter) } catch (ex: Exception) { throw wrapException(ex) @@ -197,9 +176,7 @@ public sealed class DataEventFilter : ModelEnum { /** * 'AssetDefinition' variant */ - public data class AssetDefinition( - public val assetDefinitionEventFilter: AssetDefinitionEventFilter, - ) : DataEventFilter() { + public data class AssetDefinition(public val assetDefinitionEventFilter: AssetDefinitionEventFilter) : DataEventFilter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -215,23 +192,19 @@ public sealed class DataEventFilter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.AssetDefinition, - ): Unit = try { - AssetDefinitionEventFilter.write(writer, instance.assetDefinitionEventFilter) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.AssetDefinition): Unit = + try { + AssetDefinitionEventFilter.write(writer, instance.assetDefinitionEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Trigger' variant */ - public data class Trigger( - public val triggerEventFilter: TriggerEventFilter, - ) : DataEventFilter() { + public data class Trigger(public val triggerEventFilter: TriggerEventFilter) : DataEventFilter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -247,10 +220,7 @@ public sealed class DataEventFilter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Trigger, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Trigger): Unit = try { TriggerEventFilter.write(writer, instance.triggerEventFilter) } catch (ex: Exception) { throw wrapException(ex) @@ -261,9 +231,7 @@ public sealed class DataEventFilter : ModelEnum { /** * 'Role' variant */ - public data class Role( - public val roleEventFilter: RoleEventFilter, - ) : DataEventFilter() { + public data class Role(public val roleEventFilter: RoleEventFilter) : DataEventFilter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -279,10 +247,7 @@ public sealed class DataEventFilter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Role, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Role): Unit = try { RoleEventFilter.write(writer, instance.roleEventFilter) } catch (ex: Exception) { throw wrapException(ex) @@ -293,9 +258,7 @@ public sealed class DataEventFilter : ModelEnum { /** * 'Configuration' variant */ - public data class Configuration( - public val configurationEventFilter: ConfigurationEventFilter, - ) : DataEventFilter() { + public data class Configuration(public val configurationEventFilter: ConfigurationEventFilter) : DataEventFilter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -311,23 +274,19 @@ public sealed class DataEventFilter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Configuration, - ): Unit = try { - ConfigurationEventFilter.write(writer, instance.configurationEventFilter) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Configuration): Unit = + try { + ConfigurationEventFilter.write(writer, instance.configurationEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Executor' variant */ - public data class Executor( - public val executorEventFilter: ExecutorEventFilter, - ) : DataEventFilter() { + public data class Executor(public val executorEventFilter: ExecutorEventFilter) : DataEventFilter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -343,10 +302,7 @@ public sealed class DataEventFilter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Executor, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Executor): Unit = try { ExecutorEventFilter.write(writer, instance.executorEventFilter) } catch (ex: Exception) { throw wrapException(ex) @@ -355,10 +311,7 @@ public sealed class DataEventFilter : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): DataEventFilter = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): DataEventFilter = when (val discriminant = reader.readUByte()) { 0 -> Any.read(reader) 1 -> Peer.read(reader) 2 -> Domain.read(reader) @@ -369,7 +322,8 @@ public sealed class DataEventFilter : ModelEnum { 7 -> Role.read(reader) 8 -> Configuration.read(reader) 9 -> Executor.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: DataEventFilter) { writer.directWrite(instance.discriminant()) @@ -384,7 +338,8 @@ public sealed class DataEventFilter : ModelEnum { 7 -> Role.write(writer, instance as Role) 8 -> Configuration.write(writer, instance as Configuration) 9 -> Executor.write(writer, instance as Executor) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainEvent.kt index 501d0a135..59075b99f 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainEvent.kt @@ -26,9 +26,7 @@ public sealed class DomainEvent : ModelEnum { /** * 'Created' variant */ - public data class Created( - public val domain: Domain, - ) : DomainEvent() { + public data class Created(public val domain: Domain) : DomainEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class DomainEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainEvent.Created, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DomainEvent.Created): Unit = try { Domain.write(writer, instance.domain) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class DomainEvent : ModelEnum { /** * 'Deleted' variant */ - public data class Deleted( - public val domainId: DomainId, - ) : DomainEvent() { + public data class Deleted(public val domainId: DomainId) : DomainEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class DomainEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainEvent.Deleted, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DomainEvent.Deleted): Unit = try { DomainId.write(writer, instance.domainId) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class DomainEvent : ModelEnum { /** * 'AssetDefinition' variant */ - public data class AssetDefinition( - public val assetDefinitionEvent: AssetDefinitionEvent, - ) : DomainEvent() { + public data class AssetDefinition(public val assetDefinitionEvent: AssetDefinitionEvent) : DomainEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,23 +96,19 @@ public sealed class DomainEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainEvent.AssetDefinition, - ): Unit = try { - AssetDefinitionEvent.write(writer, instance.assetDefinitionEvent) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DomainEvent.AssetDefinition): Unit = + try { + AssetDefinitionEvent.write(writer, instance.assetDefinitionEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Account' variant */ - public data class Account( - public val accountEvent: AccountEvent, - ) : DomainEvent() { + public data class Account(public val accountEvent: AccountEvent) : DomainEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,10 +124,7 @@ public sealed class DomainEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainEvent.Account, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DomainEvent.Account): Unit = try { AccountEvent.write(writer, instance.accountEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -154,9 +135,7 @@ public sealed class DomainEvent : ModelEnum { /** * 'MetadataInserted' variant */ - public data class MetadataInserted( - public val metadataChangedOfDomainId: MetadataChangedOfDomainId, - ) : DomainEvent() { + public data class MetadataInserted(public val metadataChangedOfDomainId: MetadataChangedOfDomainId) : DomainEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -172,23 +151,19 @@ public sealed class DomainEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainEvent.MetadataInserted, - ): Unit = try { - MetadataChangedOfDomainId.write(writer, instance.metadataChangedOfDomainId) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DomainEvent.MetadataInserted): Unit = + try { + MetadataChangedOfDomainId.write(writer, instance.metadataChangedOfDomainId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'MetadataRemoved' variant */ - public data class MetadataRemoved( - public val metadataChangedOfDomainId: MetadataChangedOfDomainId, - ) : DomainEvent() { + public data class MetadataRemoved(public val metadataChangedOfDomainId: MetadataChangedOfDomainId) : DomainEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -204,23 +179,19 @@ public sealed class DomainEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainEvent.MetadataRemoved, - ): Unit = try { - MetadataChangedOfDomainId.write(writer, instance.metadataChangedOfDomainId) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DomainEvent.MetadataRemoved): Unit = + try { + MetadataChangedOfDomainId.write(writer, instance.metadataChangedOfDomainId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'OwnerChanged' variant */ - public data class OwnerChanged( - public val domainOwnerChanged: DomainOwnerChanged, - ) : DomainEvent() { + public data class OwnerChanged(public val domainOwnerChanged: DomainOwnerChanged) : DomainEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -236,10 +207,7 @@ public sealed class DomainEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainEvent.OwnerChanged, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DomainEvent.OwnerChanged): Unit = try { DomainOwnerChanged.write(writer, instance.domainOwnerChanged) } catch (ex: Exception) { throw wrapException(ex) @@ -248,10 +216,7 @@ public sealed class DomainEvent : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): DomainEvent = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): DomainEvent = when (val discriminant = reader.readUByte()) { 0 -> Created.read(reader) 1 -> Deleted.read(reader) 2 -> AssetDefinition.read(reader) @@ -259,7 +224,8 @@ public sealed class DomainEvent : ModelEnum { 4 -> MetadataInserted.read(reader) 5 -> MetadataRemoved.read(reader) 6 -> OwnerChanged.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: DomainEvent) { writer.directWrite(instance.discriminant()) @@ -271,7 +237,8 @@ public sealed class DomainEvent : ModelEnum { 4 -> MetadataInserted.write(writer, instance as MetadataInserted) 5 -> MetadataRemoved.write(writer, instance as MetadataRemoved) 6 -> OwnerChanged.write(writer, instance as OwnerChanged) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainEventFilter.kt index 4e3aac02d..93f98110d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainEventFilter.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'DomainEventFilter' regular structure */ -public data class DomainEventFilter( - public val idMatcher: DomainId? = null, - public val eventSet: Long, -) { +public data class DomainEventFilter(public val idMatcher: DomainId? = null, public val eventSet: Long) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): DomainEventFilter = try { DomainEventFilter( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainId.kt index 7735c2626..6ccd79416 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainId.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'DomainId' regular structure */ -public data class DomainId( - public val name: Name, -) { +public data class DomainId(public val name: Name) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): DomainId = try { DomainId( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdPredicateAtom.kt new file mode 100644 index 000000000..770506039 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdPredicateAtom.kt @@ -0,0 +1,68 @@ +// +// 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 + +/** + * DomainIdPredicateAtom + * + * Generated from 'DomainIdPredicateAtom' enum + */ +public sealed class DomainIdPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Equals' variant + */ + public data class Equals(public val domainId: DomainId) : DomainIdPredicateAtom() { + 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.DomainIdPredicateAtom.Equals = try { + Equals( + DomainId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DomainIdPredicateAtom.Equals): Unit = + try { + DomainId.write(writer, instance.domainId) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): DomainIdPredicateAtom = 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: DomainIdPredicateAtom) { + 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/DomainIdPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdProjectionOfPredicateMarker.kt similarity index 59% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdProjectionOfPredicateMarker.kt index c0ddd21c5..346c80d3b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdProjectionOfPredicateMarker.kt @@ -13,32 +13,30 @@ import kotlin.Int import kotlin.Unit /** - * DomainIdPredicateBox + * DomainIdProjectionOfPredicateMarker * - * Generated from 'DomainIdPredicateBox' enum + * Generated from 'DomainIdProjectionOfPredicateMarker' enum */ -public sealed class DomainIdPredicateBox : ModelEnum { +public sealed class DomainIdProjectionOfPredicateMarker : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int /** - * 'Equals' variant + * 'Atom' variant */ - public data class Equals( - public val domainId: DomainId, - ) : DomainIdPredicateBox() { + public data class Atom(public val domainIdPredicateAtom: DomainIdPredicateAtom) : DomainIdProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainIdPredicateBox.Equals = try { - Equals( - DomainId.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainIdProjectionOfPredicateMarker.Atom = try { + Atom( + DomainIdPredicateAtom.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -46,9 +44,9 @@ public sealed class DomainIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainIdPredicateBox.Equals, + instance: jp.co.soramitsu.iroha2.generated.DomainIdProjectionOfPredicateMarker.Atom, ): Unit = try { - DomainId.write(writer, instance.domainId) + DomainIdPredicateAtom.write(writer, instance.domainIdPredicateAtom) } catch (ex: Exception) { throw wrapException(ex) } @@ -58,19 +56,18 @@ public sealed class DomainIdPredicateBox : ModelEnum { /** * 'Name' variant */ - public data class Name( - public val stringPredicateBox: StringPredicateBox, - ) : DomainIdPredicateBox() { + public data class Name(public val nameProjectionOfPredicateMarker: NameProjectionOfPredicateMarker) : + DomainIdProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainIdPredicateBox.Name = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainIdProjectionOfPredicateMarker.Name = try { Name( - StringPredicateBox.read(reader), + NameProjectionOfPredicateMarker.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -78,30 +75,31 @@ public sealed class DomainIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainIdPredicateBox.Name, + instance: jp.co.soramitsu.iroha2.generated.DomainIdProjectionOfPredicateMarker.Name, ): Unit = try { - StringPredicateBox.write(writer, instance.stringPredicateBox) + NameProjectionOfPredicateMarker.write(writer, instance.nameProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } } } - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): DomainIdPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Equals.read(reader) + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): DomainIdProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) 1 -> Name.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: DomainIdPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: DomainIdProjectionOfPredicateMarker) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Equals.write(writer, instance as Equals) + 0 -> Atom.write(writer, instance as Atom) 1 -> Name.write(writer, instance as Name) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..867dfb2a1 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdProjectionOfSelectorMarker.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 + +/** + * DomainIdProjectionOfSelectorMarker + * + * Generated from 'DomainIdProjectionOfSelectorMarker' enum + */ +public sealed class DomainIdProjectionOfSelectorMarker : 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 : DomainIdProjectionOfSelectorMarker() { + 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.DomainIdProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.DomainIdProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.DomainIdProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".DomainIdProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Name' variant + */ + public data class Name(public val nameProjectionOfSelectorMarker: NameProjectionOfSelectorMarker) : + DomainIdProjectionOfSelectorMarker() { + 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.DomainIdProjectionOfSelectorMarker.Name = try { + Name( + NameProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.DomainIdProjectionOfSelectorMarker.Name, + ): Unit = try { + NameProjectionOfSelectorMarker.write(writer, instance.nameProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): DomainIdProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Name.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: DomainIdProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Name.write(writer, instance as Name) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainOwnerChanged.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainOwnerChanged.kt index c2d2afa71..2f0edf5cf 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainOwnerChanged.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainOwnerChanged.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'DomainOwnerChanged' regular structure */ -public data class DomainOwnerChanged( - public val domain: DomainId, - public val newOwner: AccountId, -) { +public data class DomainOwnerChanged(public val domain: DomainId, public val newOwner: AccountId) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): DomainOwnerChanged = try { DomainOwnerChanged( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainPredicateAtom.kt new file mode 100644 index 000000000..b7d32acaf --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainPredicateAtom.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 + +/** + * DomainPredicateAtom + * + * Generated from 'DomainPredicateAtom' enum + */ +public sealed class DomainPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): DomainPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: DomainPredicateAtom) { + 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/DomainPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainPredicateBox.kt deleted file mode 100644 index 05141a1ba..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainPredicateBox.kt +++ /dev/null @@ -1,107 +0,0 @@ -// -// 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 - -/** - * DomainPredicateBox - * - * Generated from 'DomainPredicateBox' enum - */ -public sealed class DomainPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Id' variant - */ - public data class Id( - public val domainIdPredicateBox: DomainIdPredicateBox, - ) : DomainPredicateBox() { - 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.DomainPredicateBox.Id = try { - Id( - DomainIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainPredicateBox.Id, - ): Unit = try { - DomainIdPredicateBox.write(writer, instance.domainIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Metadata' variant - */ - public data class Metadata( - public val metadataPredicateBox: MetadataPredicateBox, - ) : DomainPredicateBox() { - 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.DomainPredicateBox.Metadata = try { - Metadata( - MetadataPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainPredicateBox.Metadata, - ): Unit = try { - MetadataPredicateBox.write(writer, instance.metadataPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): DomainPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Id.read(reader) - 1 -> Metadata.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: DomainPredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Id.write(writer, instance as Id) - 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/DomainProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..9e4b31f46 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainProjectionOfPredicateMarker.kt @@ -0,0 +1,138 @@ +// +// 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 + +/** + * DomainProjectionOfPredicateMarker + * + * Generated from 'DomainProjectionOfPredicateMarker' enum + */ +public sealed class DomainProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val domainPredicateAtom: DomainPredicateAtom) : DomainProjectionOfPredicateMarker() { + 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.DomainProjectionOfPredicateMarker.Atom = try { + Atom( + DomainPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.DomainProjectionOfPredicateMarker.Atom, + ): Unit = try { + DomainPredicateAtom.write(writer, instance.domainPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Id' variant + */ + public data class Id(public val domainIdProjectionOfPredicateMarker: DomainIdProjectionOfPredicateMarker) : + DomainProjectionOfPredicateMarker() { + 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.DomainProjectionOfPredicateMarker.Id = try { + Id( + DomainIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.DomainProjectionOfPredicateMarker.Id, + ): Unit = try { + DomainIdProjectionOfPredicateMarker.write(writer, instance.domainIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Metadata' variant + */ + public data class Metadata(public val metadataProjectionOfPredicateMarker: MetadataProjectionOfPredicateMarker) : + DomainProjectionOfPredicateMarker() { + 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.DomainProjectionOfPredicateMarker.Metadata = try { + Metadata( + MetadataProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.DomainProjectionOfPredicateMarker.Metadata, + ): Unit = try { + MetadataProjectionOfPredicateMarker.write(writer, instance.metadataProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): DomainProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Id.read(reader) + 2 -> Metadata.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: DomainProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Id.write(writer, instance as Id) + 2 -> 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/DomainProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..9d199681a --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainProjectionOfSelectorMarker.kt @@ -0,0 +1,154 @@ +// +// 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 + +/** + * DomainProjectionOfSelectorMarker + * + * Generated from 'DomainProjectionOfSelectorMarker' enum + */ +public sealed class DomainProjectionOfSelectorMarker : 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 : DomainProjectionOfSelectorMarker() { + 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.DomainProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.DomainProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.DomainProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".DomainProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Id' variant + */ + public data class Id(public val domainIdProjectionOfSelectorMarker: DomainIdProjectionOfSelectorMarker) : + DomainProjectionOfSelectorMarker() { + 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.DomainProjectionOfSelectorMarker.Id = try { + Id( + DomainIdProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.DomainProjectionOfSelectorMarker.Id, + ): Unit = try { + DomainIdProjectionOfSelectorMarker.write(writer, instance.domainIdProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Metadata' variant + */ + public data class Metadata(public val metadataProjectionOfSelectorMarker: MetadataProjectionOfSelectorMarker) : + DomainProjectionOfSelectorMarker() { + 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.DomainProjectionOfSelectorMarker.Metadata = try { + Metadata( + MetadataProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.DomainProjectionOfSelectorMarker.Metadata, + ): Unit = try { + MetadataProjectionOfSelectorMarker.write(writer, instance.metadataProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): DomainProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Id.read(reader) + 2 -> Metadata.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: DomainProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Id.write(writer, instance as Id) + 2 -> 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/EventBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventBox.kt index 4f24e6a5f..2244acf99 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventBox.kt @@ -26,9 +26,7 @@ public sealed class EventBox : ModelEnum { /** * 'Pipeline' variant */ - public data class Pipeline( - public val pipelineEventBox: PipelineEventBox, - ) : EventBox() { + public data class Pipeline(public val pipelineEventBox: PipelineEventBox) : EventBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class EventBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.EventBox.Pipeline, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.EventBox.Pipeline): Unit = try { PipelineEventBox.write(writer, instance.pipelineEventBox) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class EventBox : ModelEnum { /** * 'Data' variant */ - public data class Data( - public val dataEvent: DataEvent, - ) : EventBox() { + public data class Data(public val dataEvent: DataEvent) : EventBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -68,19 +61,15 @@ public sealed class EventBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventBox.Data = - try { - Data( - DataEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.EventBox.Data, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventBox.Data = try { + Data( + DataEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.EventBox.Data): Unit = try { DataEvent.write(writer, instance.dataEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -91,9 +80,7 @@ public sealed class EventBox : ModelEnum { /** * 'Time' variant */ - public data class Time( - public val timeEvent: TimeEvent, - ) : EventBox() { + public data class Time(public val timeEvent: TimeEvent) : EventBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -101,19 +88,15 @@ public sealed class EventBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventBox.Time = - try { - Time( - TimeEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.EventBox.Time, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventBox.Time = try { + Time( + TimeEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.EventBox.Time): Unit = try { TimeEvent.write(writer, instance.timeEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -124,9 +107,7 @@ public sealed class EventBox : ModelEnum { /** * 'ExecuteTrigger' variant */ - public data class ExecuteTrigger( - public val executeTriggerEvent: ExecuteTriggerEvent, - ) : EventBox() { + public data class ExecuteTrigger(public val executeTriggerEvent: ExecuteTriggerEvent) : EventBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -142,10 +123,7 @@ public sealed class EventBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.EventBox.ExecuteTrigger, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.EventBox.ExecuteTrigger): Unit = try { ExecuteTriggerEvent.write(writer, instance.executeTriggerEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -156,9 +134,7 @@ public sealed class EventBox : ModelEnum { /** * 'TriggerCompleted' variant */ - public data class TriggerCompleted( - public val triggerCompletedEvent: TriggerCompletedEvent, - ) : EventBox() { + public data class TriggerCompleted(public val triggerCompletedEvent: TriggerCompletedEvent) : EventBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -174,10 +150,7 @@ public sealed class EventBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.EventBox.TriggerCompleted, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.EventBox.TriggerCompleted): Unit = try { TriggerCompletedEvent.write(writer, instance.triggerCompletedEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -186,16 +159,14 @@ public sealed class EventBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): EventBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): EventBox = when (val discriminant = reader.readUByte()) { 0 -> Pipeline.read(reader) 1 -> Data.read(reader) 2 -> Time.read(reader) 3 -> ExecuteTrigger.read(reader) 4 -> TriggerCompleted.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: EventBox) { writer.directWrite(instance.discriminant()) @@ -205,7 +176,8 @@ public sealed class EventBox : ModelEnum { 2 -> Time.write(writer, instance as Time) 3 -> ExecuteTrigger.write(writer, instance as ExecuteTrigger) 4 -> TriggerCompleted.write(writer, instance as TriggerCompleted) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventFilterBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventFilterBox.kt index 0f0eebbb7..1f5086a03 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventFilterBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventFilterBox.kt @@ -26,9 +26,7 @@ public sealed class EventFilterBox : ModelEnum { /** * 'Pipeline' variant */ - public data class Pipeline( - public val pipelineEventFilterBox: PipelineEventFilterBox, - ) : EventFilterBox() { + public data class Pipeline(public val pipelineEventFilterBox: PipelineEventFilterBox) : EventFilterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class EventFilterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.EventFilterBox.Pipeline, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.EventFilterBox.Pipeline): Unit = try { PipelineEventFilterBox.write(writer, instance.pipelineEventFilterBox) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class EventFilterBox : ModelEnum { /** * 'Data' variant */ - public data class Data( - public val dataEventFilter: DataEventFilter, - ) : EventFilterBox() { + public data class Data(public val dataEventFilter: DataEventFilter) : EventFilterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class EventFilterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.EventFilterBox.Data, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.EventFilterBox.Data): Unit = try { DataEventFilter.write(writer, instance.dataEventFilter) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class EventFilterBox : ModelEnum { /** * 'Time' variant */ - public data class Time( - public val timeEventFilter: TimeEventFilter, - ) : EventFilterBox() { + public data class Time(public val timeEventFilter: TimeEventFilter) : EventFilterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,10 +96,7 @@ public sealed class EventFilterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.EventFilterBox.Time, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.EventFilterBox.Time): Unit = try { TimeEventFilter.write(writer, instance.timeEventFilter) } catch (ex: Exception) { throw wrapException(ex) @@ -122,9 +107,7 @@ public sealed class EventFilterBox : ModelEnum { /** * 'ExecuteTrigger' variant */ - public data class ExecuteTrigger( - public val executeTriggerEventFilter: ExecuteTriggerEventFilter, - ) : EventFilterBox() { + public data class ExecuteTrigger(public val executeTriggerEventFilter: ExecuteTriggerEventFilter) : EventFilterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,23 +123,19 @@ public sealed class EventFilterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.EventFilterBox.ExecuteTrigger, - ): Unit = try { - ExecuteTriggerEventFilter.write(writer, instance.executeTriggerEventFilter) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.EventFilterBox.ExecuteTrigger): Unit = + try { + ExecuteTriggerEventFilter.write(writer, instance.executeTriggerEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'TriggerCompleted' variant */ - public data class TriggerCompleted( - public val triggerCompletedEventFilter: TriggerCompletedEventFilter, - ) : EventFilterBox() { + public data class TriggerCompleted(public val triggerCompletedEventFilter: TriggerCompletedEventFilter) : EventFilterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -172,28 +151,24 @@ public sealed class EventFilterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.EventFilterBox.TriggerCompleted, - ): Unit = try { - TriggerCompletedEventFilter.write(writer, instance.triggerCompletedEventFilter) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.EventFilterBox.TriggerCompleted): Unit = + try { + TriggerCompletedEventFilter.write(writer, instance.triggerCompletedEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): EventFilterBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): EventFilterBox = when (val discriminant = reader.readUByte()) { 0 -> Pipeline.read(reader) 1 -> Data.read(reader) 2 -> Time.read(reader) 3 -> ExecuteTrigger.read(reader) 4 -> TriggerCompleted.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: EventFilterBox) { writer.directWrite(instance.discriminant()) @@ -203,7 +178,8 @@ public sealed class EventFilterBox : ModelEnum { 2 -> Time.write(writer, instance as Time) 3 -> ExecuteTrigger.write(writer, instance as ExecuteTrigger) 4 -> TriggerCompleted.write(writer, instance as TriggerCompleted) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventMessage.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventMessage.kt index 242f01359..b922ad281 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventMessage.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventMessage.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'EventMessage' regular structure */ -public data class EventMessage( - public val eventBox: EventBox, -) { +public data class EventMessage(public val eventBox: EventBox) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): EventMessage = try { EventMessage( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventSubscriptionRequest.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventSubscriptionRequest.kt index 2f1050cbb..466ced19e 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventSubscriptionRequest.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/EventSubscriptionRequest.kt @@ -16,9 +16,7 @@ import kotlin.collections.List * * Generated from 'EventSubscriptionRequest' regular structure */ -public data class EventSubscriptionRequest( - public val vecOfEventFilterBox: List, -) { +public data class EventSubscriptionRequest(public val vecOfEventFilterBox: List) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Executable.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Executable.kt index db40f7a1f..39863f89b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Executable.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Executable.kt @@ -27,9 +27,7 @@ public sealed class Executable : ModelEnum { /** * 'Instructions' variant */ - public data class Instructions( - public val vec: List, - ) : Executable() { + public data class Instructions(public val vec: List) : Executable() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -45,10 +43,7 @@ public sealed class Executable : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Executable.Instructions, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Executable.Instructions): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> InstructionBox.write(writer, value) @@ -62,9 +57,7 @@ public sealed class Executable : ModelEnum { /** * 'Wasm' variant */ - public data class Wasm( - public val wasmSmartContract: WasmSmartContract, - ) : Executable() { + public data class Wasm(public val wasmSmartContract: WasmSmartContract) : Executable() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -80,10 +73,7 @@ public sealed class Executable : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Executable.Wasm, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Executable.Wasm): Unit = try { WasmSmartContract.write(writer, instance.wasmSmartContract) } catch (ex: Exception) { throw wrapException(ex) @@ -92,20 +82,19 @@ public sealed class Executable : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Executable = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): Executable = when (val discriminant = reader.readUByte()) { 0 -> Instructions.read(reader) 1 -> Wasm.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: Executable) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Instructions.write(writer, instance as Instructions) 1 -> Wasm.write(writer, instance as Wasm) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecuteTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecuteTrigger.kt index a82b9d03d..ee6b63650 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecuteTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecuteTrigger.kt @@ -3,12 +3,14 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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.String import kotlin.Unit /** @@ -16,15 +18,14 @@ import kotlin.Unit * * Generated from 'ExecuteTrigger' regular structure */ -public data class ExecuteTrigger( - public val trigger: TriggerId, - public val args: String? = null, -) { +public data class ExecuteTrigger(public val trigger: TriggerId, public val args: Json) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): ExecuteTrigger = try { ExecuteTrigger( TriggerId.read(reader), - reader.readNullable(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -32,7 +33,7 @@ public data class ExecuteTrigger( override fun write(writer: ScaleCodecWriter, instance: ExecuteTrigger): Unit = try { TriggerId.write(writer, instance.trigger) - writer.writeNullable(instance.args) + Json.write(writer, instance.args) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecuteTriggerEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecuteTriggerEvent.kt index bacfbf0ab..28f99814e 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecuteTriggerEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecuteTriggerEvent.kt @@ -8,7 +8,6 @@ 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.String import kotlin.Unit /** @@ -19,14 +18,14 @@ import kotlin.Unit public data class ExecuteTriggerEvent( public val triggerId: TriggerId, public val authority: AccountId, - public val args: String? = null, + public val args: Json, ) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): ExecuteTriggerEvent = try { ExecuteTriggerEvent( TriggerId.read(reader), AccountId.read(reader), - reader.readNullable(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -35,7 +34,7 @@ public data class ExecuteTriggerEvent( override fun write(writer: ScaleCodecWriter, instance: ExecuteTriggerEvent): Unit = try { TriggerId.write(writer, instance.triggerId) AccountId.write(writer, instance.authority) - writer.writeNullable(instance.args) + Json.write(writer, instance.args) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecuteTriggerEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecuteTriggerEventFilter.kt index 0f0e6881d..0fc865fb4 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecuteTriggerEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecuteTriggerEventFilter.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'ExecuteTriggerEventFilter' regular structure */ -public data class ExecuteTriggerEventFilter( - public val triggerId: TriggerId? = null, - public val authority: AccountId? = null, -) { +public data class ExecuteTriggerEventFilter(public val triggerId: TriggerId? = null, public val authority: AccountId? = null) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutionTime.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutionTime.kt index d3b552867..b45c8620a 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutionTime.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutionTime.kt @@ -27,11 +27,13 @@ public sealed class ExecutionTime : ModelEnum { override fun equals(other: Any?): Boolean = when (this) { is PreCommit -> PreCommit.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is PreCommit -> PreCommit.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'PreCommit' variant @@ -50,10 +52,7 @@ public sealed class ExecutionTime : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.ExecutionTime.PreCommit, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.ExecutionTime.PreCommit): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -70,9 +69,7 @@ public sealed class ExecutionTime : ModelEnum { /** * 'Schedule' variant */ - public data class Schedule( - public val schedule: jp.co.soramitsu.iroha2.generated.Schedule, - ) : ExecutionTime() { + public data class Schedule(public val schedule: jp.co.soramitsu.iroha2.generated.Schedule) : ExecutionTime() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -88,10 +85,7 @@ public sealed class ExecutionTime : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.ExecutionTime.Schedule, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.ExecutionTime.Schedule): Unit = try { jp.co.soramitsu.iroha2.generated.Schedule.write(writer, instance.schedule) } catch (ex: Exception) { throw wrapException(ex) @@ -100,20 +94,19 @@ public sealed class ExecutionTime : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): ExecutionTime = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): ExecutionTime = when (val discriminant = reader.readUByte()) { 0 -> PreCommit.read(reader) 1 -> Schedule.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: ExecutionTime) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> PreCommit.write(writer, instance as PreCommit) 1 -> Schedule.write(writer, instance as Schedule) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Executor.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Executor.kt index a436cc11b..c91b4feab 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Executor.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Executor.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'Executor' regular structure */ -public data class Executor( - public val wasm: WasmSmartContract, -) { +public data class Executor(public val wasm: WasmSmartContract) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Executor = try { Executor( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorDataModel.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorDataModel.kt index d0dc37429..10496b928 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorDataModel.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorDataModel.kt @@ -23,19 +23,15 @@ public data class ExecutorDataModel( public val parameters: Map, public val instructions: List, public val permissions: List, - public val schema: String, + public val schema: Json, ) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): ExecutorDataModel = try { ExecutorDataModel( - reader.readMap( - reader.readCompactInt(), - { CustomParameterId.read(reader) }, - { CustomParameter.read(reader) }, - ), + reader.readMap(reader.readCompactInt(), { CustomParameterId.read(reader) }, { CustomParameter.read(reader) }), reader.readVec(reader.readCompactInt()) { reader.readString() }, reader.readVec(reader.readCompactInt()) { reader.readString() }, - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -61,7 +57,7 @@ public data class ExecutorDataModel( ).forEach { value -> writer.writeAsList(value.toByteArray(Charsets.UTF_8)) } - writer.writeAsList(instance.schema.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.schema) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorEvent.kt index e7fb9bd45..3ba2711f7 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorEvent.kt @@ -26,9 +26,7 @@ public sealed class ExecutorEvent : ModelEnum { /** * 'Upgraded' variant */ - public data class Upgraded( - public val executorUpgrade: ExecutorUpgrade, - ) : ExecutorEvent() { + public data class Upgraded(public val executorUpgrade: ExecutorUpgrade) : ExecutorEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class ExecutorEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.ExecutorEvent.Upgraded, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.ExecutorEvent.Upgraded): Unit = try { ExecutorUpgrade.write(writer, instance.executorUpgrade) } catch (ex: Exception) { throw wrapException(ex) @@ -56,18 +51,17 @@ public sealed class ExecutorEvent : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): ExecutorEvent = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): ExecutorEvent = when (val discriminant = reader.readUByte()) { 0 -> Upgraded.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: ExecutorEvent) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Upgraded.write(writer, instance as Upgraded) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorEventFilter.kt index 0f92ede73..2f4408f2b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorEventFilter.kt @@ -16,9 +16,7 @@ import kotlin.Unit * * Generated from 'ExecutorEventFilter' regular structure */ -public data class ExecutorEventFilter( - public val eventSet: Long, -) { +public data class ExecutorEventFilter(public val eventSet: Long) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): ExecutorEventFilter = try { ExecutorEventFilter( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorUpgrade.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorUpgrade.kt index 5e08b9b56..e164d8f9c 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorUpgrade.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ExecutorUpgrade.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'ExecutorUpgrade' regular structure */ -public data class ExecutorUpgrade( - public val newDataModel: ExecutorDataModel, -) { +public data class ExecutorUpgrade(public val newDataModel: ExecutorDataModel) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): ExecutorUpgrade = try { ExecutorUpgrade( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FetchSize.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FetchSize.kt index 7883f4fc5..e1532f2b3 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FetchSize.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FetchSize.kt @@ -15,20 +15,18 @@ import kotlin.Unit * * Generated from 'FetchSize' regular structure */ -public data class FetchSize( - public val fetchSize: NonZeroOfu32? = null, -) { +public data class FetchSize(public val fetchSize: NonZeroOfu64? = null) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): FetchSize = try { FetchSize( - reader.readNullable(NonZeroOfu32) as NonZeroOfu32?, + reader.readNullable(NonZeroOfu64) as NonZeroOfu64?, ) } catch (ex: Exception) { throw wrapException(ex) } override fun write(writer: ScaleCodecWriter, instance: FetchSize): Unit = try { - writer.writeNullable(NonZeroOfu32, instance.fetchSize) + writer.writeNullable(NonZeroOfu64, instance.fetchSize) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountKeyValueByIdAndKey.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountKeyValueByIdAndKey.kt deleted file mode 100644 index 3ec7ba137..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountKeyValueByIdAndKey.kt +++ /dev/null @@ -1,42 +0,0 @@ -// -// 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 - -/** - * FindAccountKeyValueByIdAndKey - * - * Generated from 'FindAccountKeyValueByIdAndKey' regular structure - */ -public data class FindAccountKeyValueByIdAndKey( - public val id: AccountId, - public val key: Name, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAccountKeyValueByIdAndKey = try { - FindAccountKeyValueByIdAndKey( - AccountId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAccountKeyValueByIdAndKey): Unit = - try { - AccountId.write(writer, instance.id) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountMetadata.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountMetadata.kt index 42c47d23c..385819727 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountMetadata.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountMetadata.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'FindAccountMetadata' regular structure */ -public data class FindAccountMetadata( - public val id: AccountId, - public val key: Name, -) { +public data class FindAccountMetadata(public val id: AccountId, public val key: Name) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): FindAccountMetadata = try { FindAccountMetadata( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccounts.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccounts.kt index f497845e5..5d97013e9 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccounts.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccounts.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindAccounts * - * Generated from 'FindAccounts' regular structure + * Generated from 'FindAccounts' tuple structure */ public class FindAccounts { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountsByDomainId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountsByDomainId.kt deleted file mode 100644 index 9a6a49a13..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountsByDomainId.kt +++ /dev/null @@ -1,36 +0,0 @@ -// -// 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 - -/** - * FindAccountsByDomainId - * - * Generated from 'FindAccountsByDomainId' regular structure - */ -public data class FindAccountsByDomainId( - public val domain: DomainId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAccountsByDomainId = try { - FindAccountsByDomainId( - DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAccountsByDomainId): Unit = try { - DomainId.write(writer, instance.domain) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountsWithAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountsWithAsset.kt index e22c8b519..71fea205b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountsWithAsset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountsWithAsset.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'FindAccountsWithAsset' regular structure */ -public data class FindAccountsWithAsset( - public val assetDefinition: AssetDefinitionId, -) { +public data class FindAccountsWithAsset(public val assetDefinition: AssetDefinitionId) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): FindAccountsWithAsset = try { FindAccountsWithAsset( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindActiveTriggerIds.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindActiveTriggerIds.kt index 4c9688a10..3a7e57f9f 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindActiveTriggerIds.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindActiveTriggerIds.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindActiveTriggerIds * - * Generated from 'FindActiveTriggerIds' regular structure + * Generated from 'FindActiveTriggerIds' tuple structure */ public class FindActiveTriggerIds { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllAccounts.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllAccounts.kt deleted file mode 100644 index 481567b5e..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllAccounts.kt +++ /dev/null @@ -1,41 +0,0 @@ -// -// 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.Any -import kotlin.Boolean -import kotlin.Int -import kotlin.Unit - -/** - * FindAllAccounts - * - * Generated from 'FindAllAccounts' regular structure - */ -public class FindAllAccounts { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllAccounts = try { - FindAllAccounts() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAllAccounts): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: FindAllAccounts, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".FindAllAccounts".hashCode() - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllActiveTriggerIds.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllActiveTriggerIds.kt deleted file mode 100644 index 03ba4fa3c..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllActiveTriggerIds.kt +++ /dev/null @@ -1,43 +0,0 @@ -// -// 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.Any -import kotlin.Boolean -import kotlin.Int -import kotlin.Unit - -/** - * FindAllActiveTriggerIds - * - * Generated from 'FindAllActiveTriggerIds' regular structure - */ -public class FindAllActiveTriggerIds { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllActiveTriggerIds = try { - FindAllActiveTriggerIds() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAllActiveTriggerIds): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: FindAllActiveTriggerIds, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".FindAllActiveTriggerIds".hashCode() - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllAssetsDefinitions.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllAssetsDefinitions.kt deleted file mode 100644 index 7327a6e9f..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllAssetsDefinitions.kt +++ /dev/null @@ -1,43 +0,0 @@ -// -// 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.Any -import kotlin.Boolean -import kotlin.Int -import kotlin.Unit - -/** - * FindAllAssetsDefinitions - * - * Generated from 'FindAllAssetsDefinitions' regular structure - */ -public class FindAllAssetsDefinitions { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllAssetsDefinitions = try { - FindAllAssetsDefinitions() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAllAssetsDefinitions): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: FindAllAssetsDefinitions, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".FindAllAssetsDefinitions".hashCode() - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllBlockHeaders.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllBlockHeaders.kt deleted file mode 100644 index 120b7eddb..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllBlockHeaders.kt +++ /dev/null @@ -1,41 +0,0 @@ -// -// 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.Any -import kotlin.Boolean -import kotlin.Int -import kotlin.Unit - -/** - * FindAllBlockHeaders - * - * Generated from 'FindAllBlockHeaders' regular structure - */ -public class FindAllBlockHeaders { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllBlockHeaders = try { - FindAllBlockHeaders() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAllBlockHeaders): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: FindAllBlockHeaders, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".FindAllBlockHeaders".hashCode() - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllPeers.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllPeers.kt deleted file mode 100644 index 71db6836f..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllPeers.kt +++ /dev/null @@ -1,41 +0,0 @@ -// -// 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.Any -import kotlin.Boolean -import kotlin.Int -import kotlin.Unit - -/** - * FindAllPeers - * - * Generated from 'FindAllPeers' regular structure - */ -public class FindAllPeers { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllPeers = try { - FindAllPeers() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAllPeers): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: FindAllPeers, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".FindAllPeers".hashCode() - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllRoles.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllRoles.kt deleted file mode 100644 index d8adbbec7..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllRoles.kt +++ /dev/null @@ -1,41 +0,0 @@ -// -// 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.Any -import kotlin.Boolean -import kotlin.Int -import kotlin.Unit - -/** - * FindAllRoles - * - * Generated from 'FindAllRoles' regular structure - */ -public class FindAllRoles { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllRoles = try { - FindAllRoles() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAllRoles): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: FindAllRoles, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".FindAllRoles".hashCode() - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllTransactions.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllTransactions.kt deleted file mode 100644 index 475f9e132..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllTransactions.kt +++ /dev/null @@ -1,41 +0,0 @@ -// -// 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.Any -import kotlin.Boolean -import kotlin.Int -import kotlin.Unit - -/** - * FindAllTransactions - * - * Generated from 'FindAllTransactions' regular structure - */ -public class FindAllTransactions { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllTransactions = try { - FindAllTransactions() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAllTransactions): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: FindAllTransactions, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".FindAllTransactions".hashCode() - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetDefinitionById.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetDefinitionById.kt deleted file mode 100644 index 116a42897..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetDefinitionById.kt +++ /dev/null @@ -1,38 +0,0 @@ -// -// 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 - -/** - * FindAssetDefinitionById - * - * Generated from 'FindAssetDefinitionById' regular structure - */ -public data class FindAssetDefinitionById( - public val id: AssetDefinitionId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetDefinitionById = try { - FindAssetDefinitionById( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAssetDefinitionById): Unit = try { - AssetDefinitionId.write(writer, instance.id) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetDefinitionKeyValueByIdAndKey.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetDefinitionKeyValueByIdAndKey.kt deleted file mode 100644 index ca002dd8a..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetDefinitionKeyValueByIdAndKey.kt +++ /dev/null @@ -1,41 +0,0 @@ -// -// 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 - -/** - * FindAssetDefinitionKeyValueByIdAndKey - * - * Generated from 'FindAssetDefinitionKeyValueByIdAndKey' regular structure - */ -public data class FindAssetDefinitionKeyValueByIdAndKey( - public val id: AssetDefinitionId, - public val key: Name, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetDefinitionKeyValueByIdAndKey = try { - FindAssetDefinitionKeyValueByIdAndKey( - AssetDefinitionId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAssetDefinitionKeyValueByIdAndKey): Unit = try { - AssetDefinitionId.write(writer, instance.id) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetDefinitionMetadata.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetDefinitionMetadata.kt index 62eb5f346..e0a767bdd 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetDefinitionMetadata.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetDefinitionMetadata.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'FindAssetDefinitionMetadata' regular structure */ -public data class FindAssetDefinitionMetadata( - public val id: AssetDefinitionId, - public val key: Name, -) { +public data class FindAssetDefinitionMetadata(public val id: AssetDefinitionId, public val key: Name) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetKeyValueByIdAndKey.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetKeyValueByIdAndKey.kt deleted file mode 100644 index d81e70e13..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetKeyValueByIdAndKey.kt +++ /dev/null @@ -1,41 +0,0 @@ -// -// 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 - -/** - * FindAssetKeyValueByIdAndKey - * - * Generated from 'FindAssetKeyValueByIdAndKey' regular structure - */ -public data class FindAssetKeyValueByIdAndKey( - public val id: AssetId, - public val key: Name, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetKeyValueByIdAndKey = try { - FindAssetKeyValueByIdAndKey( - AssetId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAssetKeyValueByIdAndKey): Unit = try { - AssetId.write(writer, instance.id) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetMetadata.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetMetadata.kt index 2dbe3cd3f..8cafcae7d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetMetadata.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetMetadata.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'FindAssetMetadata' regular structure */ -public data class FindAssetMetadata( - public val id: AssetId, - public val key: Name, -) { +public data class FindAssetMetadata(public val id: AssetId, public val key: Name) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): FindAssetMetadata = try { FindAssetMetadata( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetQuantityById.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetQuantityById.kt index bc6c76a13..9f9e9d093 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetQuantityById.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetQuantityById.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'FindAssetQuantityById' regular structure */ -public data class FindAssetQuantityById( - public val id: AssetId, -) { +public data class FindAssetQuantityById(public val id: AssetId) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): FindAssetQuantityById = try { FindAssetQuantityById( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssets.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssets.kt index 4de441a0d..fc82ebe91 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssets.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssets.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindAssets * - * Generated from 'FindAssets' regular structure + * Generated from 'FindAssets' tuple structure */ public class FindAssets { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByAccountId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByAccountId.kt deleted file mode 100644 index 4f4f75f40..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByAccountId.kt +++ /dev/null @@ -1,36 +0,0 @@ -// -// 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 - -/** - * FindAssetsByAccountId - * - * Generated from 'FindAssetsByAccountId' regular structure - */ -public data class FindAssetsByAccountId( - public val account: AccountId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetsByAccountId = try { - FindAssetsByAccountId( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAssetsByAccountId): Unit = try { - AccountId.write(writer, instance.account) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByAssetDefinitionId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByAssetDefinitionId.kt deleted file mode 100644 index cdcfc5bbe..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByAssetDefinitionId.kt +++ /dev/null @@ -1,39 +0,0 @@ -// -// 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 - -/** - * FindAssetsByAssetDefinitionId - * - * Generated from 'FindAssetsByAssetDefinitionId' regular structure - */ -public data class FindAssetsByAssetDefinitionId( - public val assetDefinition: AssetDefinitionId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetsByAssetDefinitionId = try { - FindAssetsByAssetDefinitionId( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAssetsByAssetDefinitionId): Unit = - try { - AssetDefinitionId.write(writer, instance.assetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByDomainId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByDomainId.kt deleted file mode 100644 index 19ac46ef9..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByDomainId.kt +++ /dev/null @@ -1,36 +0,0 @@ -// -// 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 - -/** - * FindAssetsByDomainId - * - * Generated from 'FindAssetsByDomainId' regular structure - */ -public data class FindAssetsByDomainId( - public val domain: DomainId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetsByDomainId = try { - FindAssetsByDomainId( - DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAssetsByDomainId): Unit = try { - DomainId.write(writer, instance.domain) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByDomainIdAndAssetDefinitionId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByDomainIdAndAssetDefinitionId.kt deleted file mode 100644 index cfdadd4f2..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByDomainIdAndAssetDefinitionId.kt +++ /dev/null @@ -1,44 +0,0 @@ -// -// 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 - -/** - * FindAssetsByDomainIdAndAssetDefinitionId - * - * Generated from 'FindAssetsByDomainIdAndAssetDefinitionId' regular structure - */ -public data class FindAssetsByDomainIdAndAssetDefinitionId( - public val domain: DomainId, - public val assetDefinition: AssetDefinitionId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetsByDomainIdAndAssetDefinitionId = try { - FindAssetsByDomainIdAndAssetDefinitionId( - DomainId.read(reader), - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: FindAssetsByDomainIdAndAssetDefinitionId, - ): Unit = try { - DomainId.write(writer, instance.domain) - AssetDefinitionId.write(writer, instance.assetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByName.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByName.kt deleted file mode 100644 index 6a2f1ebe0..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsByName.kt +++ /dev/null @@ -1,36 +0,0 @@ -// -// 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 - -/** - * FindAssetsByName - * - * Generated from 'FindAssetsByName' regular structure - */ -public data class FindAssetsByName( - public val name: Name, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetsByName = try { - FindAssetsByName( - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAssetsByName): Unit = try { - Name.write(writer, instance.name) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsDefinitions.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsDefinitions.kt index f714d7fe5..3d72e4725 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsDefinitions.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetsDefinitions.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindAssetsDefinitions * - * Generated from 'FindAssetsDefinitions' regular structure + * Generated from 'FindAssetsDefinitions' tuple structure */ public class FindAssetsDefinitions { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindBlockHeaderByHash.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindBlockHeaderByHash.kt deleted file mode 100644 index 7f2cc1271..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindBlockHeaderByHash.kt +++ /dev/null @@ -1,36 +0,0 @@ -// -// 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 - -/** - * FindBlockHeaderByHash - * - * Generated from 'FindBlockHeaderByHash' regular structure - */ -public data class FindBlockHeaderByHash( - public val hash: HashOf, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindBlockHeaderByHash = try { - FindBlockHeaderByHash( - HashOf.read(reader) as HashOf, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindBlockHeaderByHash): Unit = try { - HashOf.write(writer, instance.hash) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindBlockHeaders.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindBlockHeaders.kt index d76648349..5c321e906 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindBlockHeaders.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindBlockHeaders.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindBlockHeaders * - * Generated from 'FindBlockHeaders' regular structure + * Generated from 'FindBlockHeaders' tuple structure */ public class FindBlockHeaders { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindBlocks.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindBlocks.kt index 950ecc220..6932d167b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindBlocks.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindBlocks.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindBlocks * - * Generated from 'FindBlocks' regular structure + * Generated from 'FindBlocks' tuple structure */ public class FindBlocks { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomainKeyValueByIdAndKey.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomainKeyValueByIdAndKey.kt deleted file mode 100644 index 75f2c65c3..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomainKeyValueByIdAndKey.kt +++ /dev/null @@ -1,41 +0,0 @@ -// -// 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 - -/** - * FindDomainKeyValueByIdAndKey - * - * Generated from 'FindDomainKeyValueByIdAndKey' regular structure - */ -public data class FindDomainKeyValueByIdAndKey( - public val id: DomainId, - public val key: Name, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindDomainKeyValueByIdAndKey = try { - FindDomainKeyValueByIdAndKey( - DomainId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindDomainKeyValueByIdAndKey): Unit = try { - DomainId.write(writer, instance.id) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomainMetadata.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomainMetadata.kt index 8fc317f3a..f4bf1df91 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomainMetadata.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomainMetadata.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'FindDomainMetadata' regular structure */ -public data class FindDomainMetadata( - public val id: DomainId, - public val key: Name, -) { +public data class FindDomainMetadata(public val id: DomainId, public val key: Name) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): FindDomainMetadata = try { FindDomainMetadata( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomains.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomains.kt index f38ee835e..fe10968a1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomains.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomains.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindDomains * - * Generated from 'FindDomains' regular structure + * Generated from 'FindDomains' tuple structure */ public class FindDomains { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindError.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindError.kt index 6bb6ffa0b..b00de43f0 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindError.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindError.kt @@ -26,9 +26,7 @@ public sealed class FindError : ModelEnum { /** * 'Asset' variant */ - public data class Asset( - public val assetId: AssetId, - ) : FindError() { + public data class Asset(public val assetId: AssetId) : FindError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class FindError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.FindError.Asset, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.FindError.Asset): Unit = try { AssetId.write(writer, instance.assetId) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class FindError : ModelEnum { /** * 'AssetDefinition' variant */ - public data class AssetDefinition( - public val assetDefinitionId: AssetDefinitionId, - ) : FindError() { + public data class AssetDefinition(public val assetDefinitionId: AssetDefinitionId) : FindError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class FindError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.FindError.AssetDefinition, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.FindError.AssetDefinition): Unit = try { AssetDefinitionId.write(writer, instance.assetDefinitionId) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class FindError : ModelEnum { /** * 'Account' variant */ - public data class Account( - public val accountId: AccountId, - ) : FindError() { + public data class Account(public val accountId: AccountId) : FindError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,10 +96,7 @@ public sealed class FindError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.FindError.Account, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.FindError.Account): Unit = try { AccountId.write(writer, instance.accountId) } catch (ex: Exception) { throw wrapException(ex) @@ -122,9 +107,7 @@ public sealed class FindError : ModelEnum { /** * 'Domain' variant */ - public data class Domain( - public val domainId: DomainId, - ) : FindError() { + public data class Domain(public val domainId: DomainId) : FindError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,10 +123,7 @@ public sealed class FindError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.FindError.Domain, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.FindError.Domain): Unit = try { DomainId.write(writer, instance.domainId) } catch (ex: Exception) { throw wrapException(ex) @@ -154,9 +134,7 @@ public sealed class FindError : ModelEnum { /** * 'MetadataKey' variant */ - public data class MetadataKey( - public val name: Name, - ) : FindError() { + public data class MetadataKey(public val name: Name) : FindError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -172,10 +150,7 @@ public sealed class FindError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.FindError.MetadataKey, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.FindError.MetadataKey): Unit = try { Name.write(writer, instance.name) } catch (ex: Exception) { throw wrapException(ex) @@ -186,9 +161,7 @@ public sealed class FindError : ModelEnum { /** * 'Block' variant */ - public data class Block( - public val hashOf: HashOf, - ) : FindError() { + public data class Block(public val hashOf: HashOf) : FindError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -204,10 +177,7 @@ public sealed class FindError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.FindError.Block, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.FindError.Block): Unit = try { HashOf.write(writer, instance.hashOf) } catch (ex: Exception) { throw wrapException(ex) @@ -218,9 +188,7 @@ public sealed class FindError : ModelEnum { /** * 'Transaction' variant */ - public data class Transaction( - public val hashOf: HashOf, - ) : FindError() { + public data class Transaction(public val hashOf: HashOf) : FindError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -236,10 +204,7 @@ public sealed class FindError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.FindError.Transaction, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.FindError.Transaction): Unit = try { HashOf.write(writer, instance.hashOf) } catch (ex: Exception) { throw wrapException(ex) @@ -250,9 +215,7 @@ public sealed class FindError : ModelEnum { /** * 'Peer' variant */ - public data class Peer( - public val peerId: PeerId, - ) : FindError() { + public data class Peer(public val peerId: PeerId) : FindError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -260,19 +223,15 @@ public sealed class FindError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 7 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Peer = - try { - Peer( - PeerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.FindError.Peer, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Peer = try { + Peer( + PeerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.FindError.Peer): Unit = try { PeerId.write(writer, instance.peerId) } catch (ex: Exception) { throw wrapException(ex) @@ -283,9 +242,7 @@ public sealed class FindError : ModelEnum { /** * 'Trigger' variant */ - public data class Trigger( - public val triggerId: TriggerId, - ) : FindError() { + public data class Trigger(public val triggerId: TriggerId) : FindError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -301,10 +258,7 @@ public sealed class FindError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.FindError.Trigger, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.FindError.Trigger): Unit = try { TriggerId.write(writer, instance.triggerId) } catch (ex: Exception) { throw wrapException(ex) @@ -315,9 +269,7 @@ public sealed class FindError : ModelEnum { /** * 'Role' variant */ - public data class Role( - public val roleId: RoleId, - ) : FindError() { + public data class Role(public val roleId: RoleId) : FindError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -325,19 +277,15 @@ public sealed class FindError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 9 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Role = - try { - Role( - RoleId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.FindError.Role, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Role = try { + Role( + RoleId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.FindError.Role): Unit = try { RoleId.write(writer, instance.roleId) } catch (ex: Exception) { throw wrapException(ex) @@ -348,9 +296,7 @@ public sealed class FindError : ModelEnum { /** * 'Permission' variant */ - public data class Permission( - public val permission: jp.co.soramitsu.iroha2.generated.Permission, - ) : FindError() { + public data class Permission(public val permission: jp.co.soramitsu.iroha2.generated.Permission) : FindError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -366,10 +312,7 @@ public sealed class FindError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.FindError.Permission, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.FindError.Permission): Unit = try { jp.co.soramitsu.iroha2.generated.Permission.write(writer, instance.permission) } catch (ex: Exception) { throw wrapException(ex) @@ -380,9 +323,7 @@ public sealed class FindError : ModelEnum { /** * 'PublicKey' variant */ - public data class PublicKey( - public val publicKey: jp.co.soramitsu.iroha2.generated.PublicKey, - ) : FindError() { + public data class PublicKey(public val publicKey: jp.co.soramitsu.iroha2.generated.PublicKey) : FindError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -398,10 +339,7 @@ public sealed class FindError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.FindError.PublicKey, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.FindError.PublicKey): Unit = try { jp.co.soramitsu.iroha2.generated.PublicKey.write(writer, instance.publicKey) } catch (ex: Exception) { throw wrapException(ex) @@ -410,10 +348,7 @@ public sealed class FindError : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindError = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): FindError = when (val discriminant = reader.readUByte()) { 0 -> Asset.read(reader) 1 -> AssetDefinition.read(reader) 2 -> Account.read(reader) @@ -426,7 +361,8 @@ public sealed class FindError : ModelEnum { 9 -> Role.read(reader) 10 -> Permission.read(reader) 11 -> PublicKey.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: FindError) { writer.directWrite(instance.discriminant()) @@ -443,7 +379,8 @@ public sealed class FindError : ModelEnum { 9 -> Role.write(writer, instance as Role) 10 -> Permission.write(writer, instance as Permission) 11 -> PublicKey.write(writer, instance as PublicKey) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindExecutorDataModel.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindExecutorDataModel.kt index 8e0a97916..38cf7e827 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindExecutorDataModel.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindExecutorDataModel.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindExecutorDataModel * - * Generated from 'FindExecutorDataModel' regular structure + * Generated from 'FindExecutorDataModel' tuple structure */ public class FindExecutorDataModel { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindParameters.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindParameters.kt index 38cba1bc0..840d6c783 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindParameters.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindParameters.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindParameters * - * Generated from 'FindParameters' regular structure + * Generated from 'FindParameters' tuple structure */ public class FindParameters { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindPeers.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindPeers.kt index 37e309d9e..34726211e 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindPeers.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindPeers.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindPeers * - * Generated from 'FindPeers' regular structure + * Generated from 'FindPeers' tuple structure */ public class FindPeers { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindPermissionsByAccountId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindPermissionsByAccountId.kt index f9df0335c..815db2462 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindPermissionsByAccountId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindPermissionsByAccountId.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'FindPermissionsByAccountId' regular structure */ -public data class FindPermissionsByAccountId( - public val id: AccountId, -) { +public data class FindPermissionsByAccountId(public val id: AccountId) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRoleByRoleId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRoleByRoleId.kt deleted file mode 100644 index 1241ec0be..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRoleByRoleId.kt +++ /dev/null @@ -1,36 +0,0 @@ -// -// 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 - -/** - * FindRoleByRoleId - * - * Generated from 'FindRoleByRoleId' regular structure - */ -public data class FindRoleByRoleId( - public val id: RoleId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindRoleByRoleId = try { - FindRoleByRoleId( - RoleId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindRoleByRoleId): Unit = try { - RoleId.write(writer, instance.id) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRoleIds.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRoleIds.kt index eda4a74ae..2a85ef017 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRoleIds.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRoleIds.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindRoleIds * - * Generated from 'FindRoleIds' regular structure + * Generated from 'FindRoleIds' tuple structure */ public class FindRoleIds { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRoles.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRoles.kt index 1544198f0..6243a4629 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRoles.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRoles.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindRoles * - * Generated from 'FindRoles' regular structure + * Generated from 'FindRoles' tuple structure */ public class FindRoles { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRolesByAccountId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRolesByAccountId.kt index 2a2779902..563744493 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRolesByAccountId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindRolesByAccountId.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'FindRolesByAccountId' regular structure */ -public data class FindRolesByAccountId( - public val id: AccountId, -) { +public data class FindRolesByAccountId(public val id: AccountId) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): FindRolesByAccountId = try { FindRolesByAccountId( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTotalAssetQuantityByAssetDefinitionId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTotalAssetQuantityByAssetDefinitionId.kt deleted file mode 100644 index a47b6e0e3..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTotalAssetQuantityByAssetDefinitionId.kt +++ /dev/null @@ -1,41 +0,0 @@ -// -// 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 - -/** - * FindTotalAssetQuantityByAssetDefinitionId - * - * Generated from 'FindTotalAssetQuantityByAssetDefinitionId' regular structure - */ -public data class FindTotalAssetQuantityByAssetDefinitionId( - public val id: AssetDefinitionId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindTotalAssetQuantityByAssetDefinitionId = try { - FindTotalAssetQuantityByAssetDefinitionId( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: FindTotalAssetQuantityByAssetDefinitionId, - ): Unit = try { - AssetDefinitionId.write(writer, instance.id) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTransactionByHash.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTransactionByHash.kt deleted file mode 100644 index 2e33e449d..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTransactionByHash.kt +++ /dev/null @@ -1,36 +0,0 @@ -// -// 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 - -/** - * FindTransactionByHash - * - * Generated from 'FindTransactionByHash' regular structure - */ -public data class FindTransactionByHash( - public val hash: HashOf, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindTransactionByHash = try { - FindTransactionByHash( - HashOf.read(reader) as HashOf, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindTransactionByHash): Unit = try { - HashOf.write(writer, instance.hash) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTransactions.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTransactions.kt index 5655b26bc..bbd38c656 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTransactions.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTransactions.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindTransactions * - * Generated from 'FindTransactions' regular structure + * Generated from 'FindTransactions' tuple structure */ public class FindTransactions { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTransactionsByAccountId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTransactionsByAccountId.kt deleted file mode 100644 index 8d1e744a0..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTransactionsByAccountId.kt +++ /dev/null @@ -1,38 +0,0 @@ -// -// 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 - -/** - * FindTransactionsByAccountId - * - * Generated from 'FindTransactionsByAccountId' regular structure - */ -public data class FindTransactionsByAccountId( - public val account: AccountId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindTransactionsByAccountId = try { - FindTransactionsByAccountId( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindTransactionsByAccountId): Unit = try { - AccountId.write(writer, instance.account) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggerKeyValueByIdAndKey.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggerKeyValueByIdAndKey.kt deleted file mode 100644 index 6991ade0f..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggerKeyValueByIdAndKey.kt +++ /dev/null @@ -1,42 +0,0 @@ -// -// 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 - -/** - * FindTriggerKeyValueByIdAndKey - * - * Generated from 'FindTriggerKeyValueByIdAndKey' regular structure - */ -public data class FindTriggerKeyValueByIdAndKey( - public val id: TriggerId, - public val key: Name, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindTriggerKeyValueByIdAndKey = try { - FindTriggerKeyValueByIdAndKey( - TriggerId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindTriggerKeyValueByIdAndKey): Unit = - try { - TriggerId.write(writer, instance.id) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggerMetadata.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggerMetadata.kt index f9c573e76..474ce2c1a 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggerMetadata.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggerMetadata.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'FindTriggerMetadata' regular structure */ -public data class FindTriggerMetadata( - public val id: TriggerId, - public val key: Name, -) { +public data class FindTriggerMetadata(public val id: TriggerId, public val key: Name) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): FindTriggerMetadata = try { FindTriggerMetadata( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggers.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggers.kt index 1c6f355f8..8482e2f83 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggers.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggers.kt @@ -16,7 +16,7 @@ import kotlin.Unit /** * FindTriggers * - * Generated from 'FindTriggers' regular structure + * Generated from 'FindTriggers' tuple structure */ public class FindTriggers { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggersByAuthorityDomainId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggersByAuthorityDomainId.kt deleted file mode 100644 index 22bafc566..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggersByAuthorityDomainId.kt +++ /dev/null @@ -1,39 +0,0 @@ -// -// 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 - -/** - * FindTriggersByAuthorityDomainId - * - * Generated from 'FindTriggersByAuthorityDomainId' regular structure - */ -public data class FindTriggersByAuthorityDomainId( - public val domain: DomainId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindTriggersByAuthorityDomainId = try { - FindTriggersByAuthorityDomainId( - DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindTriggersByAuthorityDomainId): Unit = - try { - DomainId.write(writer, instance.domain) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggersByAuthorityId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggersByAuthorityId.kt deleted file mode 100644 index 465aa36b9..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggersByAuthorityId.kt +++ /dev/null @@ -1,38 +0,0 @@ -// -// 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 - -/** - * FindTriggersByAuthorityId - * - * Generated from 'FindTriggersByAuthorityId' regular structure - */ -public data class FindTriggersByAuthorityId( - public val account: AccountId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): FindTriggersByAuthorityId = try { - FindTriggersByAuthorityId( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindTriggersByAuthorityId): Unit = try { - AccountId.write(writer, instance.account) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ForwardCursor.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ForwardCursor.kt index 2e34383b1..3c873e787 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ForwardCursor.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ForwardCursor.kt @@ -16,23 +16,20 @@ import kotlin.Unit * * Generated from 'ForwardCursor' regular structure */ -public data class ForwardCursor( - public val query: String? = null, - public val cursor: NonZeroOfu64? = null, -) { +public data class ForwardCursor(public val query: String, public val cursor: NonZeroOfu64) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): ForwardCursor = try { ForwardCursor( - reader.readNullable(), - reader.readNullable(NonZeroOfu64) as NonZeroOfu64?, + reader.readString(), + NonZeroOfu64.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } override fun write(writer: ScaleCodecWriter, instance: ForwardCursor): Unit = try { - writer.writeNullable(instance.query) - writer.writeNullable(NonZeroOfu64, instance.cursor) + writer.writeAsList(instance.query.toByteArray(Charsets.UTF_8)) + NonZeroOfu64.write(writer, instance.cursor) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GenericPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GenericPredicateBox.kt deleted file mode 100644 index 2e8de023b..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GenericPredicateBox.kt +++ /dev/null @@ -1,178 +0,0 @@ -// -// 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.Int -import kotlin.Unit - -/** - * GenericPredicateBox - * - * Generated from 'GenericPredicateBox' enum - */ -public sealed class GenericPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'And' variant - */ - public data class And( - public val nonTrivial: NonTrivial>, - ) : GenericPredicateBox() { - 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.GenericPredicateBox.And = try { - And( - NonTrivial.read(reader) as NonTrivial>, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.GenericPredicateBox.And, - ): Unit = try { - NonTrivial.write(writer, instance.nonTrivial) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val nonTrivial: NonTrivial>, - ) : GenericPredicateBox() { - 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.GenericPredicateBox.Or = try { - Or( - NonTrivial.read(reader) as NonTrivial>, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.GenericPredicateBox.Or, - ): Unit = try { - NonTrivial.write(writer, instance.nonTrivial) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val genericPredicateBox: GenericPredicateBox, - ) : GenericPredicateBox() { - 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.GenericPredicateBox.Not = try { - Not( - GenericPredicateBox.read(reader) as GenericPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.GenericPredicateBox.Not, - ): Unit = try { - GenericPredicateBox.write(writer, instance.genericPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Raw' variant - */ - public data class Raw( - public val queryOutputPredicate: QueryOutputPredicate, - ) : GenericPredicateBox() { - 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.GenericPredicateBox.Raw = try { - Raw( - QueryOutputPredicate.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.GenericPredicateBox.Raw, - ): Unit = try { - QueryOutputPredicate.write(writer, instance.queryOutputPredicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader>, - ScaleWriter> { - override fun read(reader: ScaleCodecReader): GenericPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { - 0 -> And.read(reader) - 1 -> Or.read(reader) - 2 -> Not.read(reader) - 3 -> Raw.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: GenericPredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> And.write(writer, instance as And) - 1 -> Or.write(writer, instance as Or) - 2 -> Not.write(writer, instance as Not) - 3 -> Raw.write(writer, instance as Raw) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GenesisWasmAction.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GenesisWasmAction.kt new file mode 100644 index 000000000..319cae8ae --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GenesisWasmAction.kt @@ -0,0 +1,46 @@ +// +// 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.String +import kotlin.Unit + +/** + * GenesisWasmAction + * + * Generated from 'GenesisWasmAction' regular structure + */ +public data class GenesisWasmAction( + public val executable: String, + public val repeats: Repeats, + public val authority: AccountId, + public val filter: EventFilterBox, +) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): GenesisWasmAction = try { + GenesisWasmAction( + reader.readString(), + Repeats.read(reader), + AccountId.read(reader), + EventFilterBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: GenesisWasmAction): Unit = try { + writer.writeAsList(instance.executable.toByteArray(Charsets.UTF_8)) + Repeats.write(writer, instance.repeats) + AccountId.write(writer, instance.authority) + EventFilterBox.write(writer, instance.filter) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggerById.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GenesisWasmTrigger.kt similarity index 51% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggerById.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GenesisWasmTrigger.kt index 62bcc12a0..c677832e2 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggerById.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GenesisWasmTrigger.kt @@ -11,24 +11,24 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * FindTriggerById + * GenesisWasmTrigger * - * Generated from 'FindTriggerById' regular structure + * Generated from 'GenesisWasmTrigger' regular structure */ -public data class FindTriggerById( - public val id: TriggerId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindTriggerById = try { - FindTriggerById( +public data class GenesisWasmTrigger(public val id: TriggerId, public val action: GenesisWasmAction) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): GenesisWasmTrigger = try { + GenesisWasmTrigger( TriggerId.read(reader), + GenesisWasmAction.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: FindTriggerById): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: GenesisWasmTrigger): Unit = try { TriggerId.write(writer, instance.id) + GenesisWasmAction.write(writer, instance.action) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantBox.kt index e59d56c41..e9825967b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantBox.kt @@ -26,9 +26,7 @@ public sealed class GrantBox : ModelEnum { /** * 'Permission' variant */ - public data class Permission( - public val grantOfPermissionAndAccount: GrantOfPermissionAndAccount, - ) : GrantBox() { + public data class Permission(public val grantOfPermissionAndAccount: GrantOfPermissionAndAccount) : GrantBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class GrantBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.GrantBox.Permission, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.GrantBox.Permission): Unit = try { GrantOfPermissionAndAccount.write(writer, instance.grantOfPermissionAndAccount) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class GrantBox : ModelEnum { /** * 'Role' variant */ - public data class Role( - public val grantOfRoleIdAndAccount: GrantOfRoleIdAndAccount, - ) : GrantBox() { + public data class Role(public val grantOfRoleIdAndAccount: GrantOfRoleIdAndAccount) : GrantBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -68,19 +61,15 @@ public sealed class GrantBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.GrantBox.Role = - try { - Role( - GrantOfRoleIdAndAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.GrantBox.Role, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.GrantBox.Role = try { + Role( + GrantOfRoleIdAndAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.GrantBox.Role): Unit = try { GrantOfRoleIdAndAccount.write(writer, instance.grantOfRoleIdAndAccount) } catch (ex: Exception) { throw wrapException(ex) @@ -91,9 +80,7 @@ public sealed class GrantBox : ModelEnum { /** * 'RolePermission' variant */ - public data class RolePermission( - public val grantOfPermissionAndRole: GrantOfPermissionAndRole, - ) : GrantBox() { + public data class RolePermission(public val grantOfPermissionAndRole: GrantOfPermissionAndRole) : GrantBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -109,10 +96,7 @@ public sealed class GrantBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.GrantBox.RolePermission, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.GrantBox.RolePermission): Unit = try { GrantOfPermissionAndRole.write(writer, instance.grantOfPermissionAndRole) } catch (ex: Exception) { throw wrapException(ex) @@ -121,14 +105,12 @@ public sealed class GrantBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): GrantBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): GrantBox = when (val discriminant = reader.readUByte()) { 0 -> Permission.read(reader) 1 -> Role.read(reader) 2 -> RolePermission.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: GrantBox) { writer.directWrite(instance.discriminant()) @@ -136,7 +118,8 @@ public sealed class GrantBox : ModelEnum { 0 -> Permission.write(writer, instance as Permission) 1 -> Role.write(writer, instance as Role) 2 -> RolePermission.write(writer, instance as RolePermission) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantOfPermissionAndAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantOfPermissionAndAccount.kt index 89c3a0087..3004a241e 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantOfPermissionAndAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantOfPermissionAndAccount.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,10 +18,9 @@ import kotlin.Unit * * Generated from 'GrantOfPermissionAndAccount' regular structure */ -public data class GrantOfPermissionAndAccount( - public val `object`: Permission, - public val destination: AccountId, -) { +public data class GrantOfPermissionAndAccount(public val `object`: Permission, public val destination: AccountId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantOfPermissionAndRole.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantOfPermissionAndRole.kt index 75269183a..d4dd0bd14 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantOfPermissionAndRole.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantOfPermissionAndRole.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,10 +18,9 @@ import kotlin.Unit * * Generated from 'GrantOfPermissionAndRole' regular structure */ -public data class GrantOfPermissionAndRole( - public val `object`: Permission, - public val destination: RoleId, -) { +public data class GrantOfPermissionAndRole(public val `object`: Permission, public val destination: RoleId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantOfRoleIdAndAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantOfRoleIdAndAccount.kt index 549bb4de9..785f1af24 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantOfRoleIdAndAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GrantOfRoleIdAndAccount.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,10 +18,9 @@ import kotlin.Unit * * Generated from 'GrantOfRoleIdAndAccount' regular structure */ -public data class GrantOfRoleIdAndAccount( - public val `object`: RoleId, - public val destination: AccountId, -) { +public data class GrantOfRoleIdAndAccount(public val `object`: RoleId, public val destination: AccountId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Hash.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Hash.kt index 6b987937e..663087f2d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Hash.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Hash.kt @@ -19,9 +19,7 @@ import kotlin.Unit * * Generated from 'Hash' regular structure */ -public data class Hash( - public val arrayOfU8: ByteArray, -) { +public data class Hash(public val arrayOfU8: ByteArray) { override fun equals(other: Any?): Boolean { if (this === other) return true if (other !is Hash) return false diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/HashOf.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/HashOf.kt index 124af9934..4d7806050 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/HashOf.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/HashOf.kt @@ -14,11 +14,9 @@ import kotlin.Unit /** * HashOf * - * Generated from 'HashOf' regular structure + * Generated from 'HashOf>' regular structure */ -public data class HashOf( - public val hash: Hash, -) { +public data class HashOf(public val hash: Hash) { public companion object : ScaleReader>, ScaleWriter> { override fun read(reader: ScaleCodecReader): HashOf = try { HashOf( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/IdBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/IdBox.kt index 5271a7e82..139c9b29b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/IdBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/IdBox.kt @@ -26,9 +26,7 @@ public sealed class IdBox : ModelEnum { /** * 'DomainId' variant */ - public data class DomainId( - public val domainId: jp.co.soramitsu.iroha2.generated.DomainId, - ) : IdBox() { + public data class DomainId(public val domainId: jp.co.soramitsu.iroha2.generated.DomainId) : IdBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -36,19 +34,15 @@ public sealed class IdBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.DomainId = - try { - DomainId( - jp.co.soramitsu.iroha2.generated.DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdBox.DomainId, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.DomainId = try { + DomainId( + jp.co.soramitsu.iroha2.generated.DomainId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.IdBox.DomainId): Unit = try { jp.co.soramitsu.iroha2.generated.DomainId.write(writer, instance.domainId) } catch (ex: Exception) { throw wrapException(ex) @@ -59,9 +53,7 @@ public sealed class IdBox : ModelEnum { /** * 'AccountId' variant */ - public data class AccountId( - public val accountId: jp.co.soramitsu.iroha2.generated.AccountId, - ) : IdBox() { + public data class AccountId(public val accountId: jp.co.soramitsu.iroha2.generated.AccountId) : IdBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -77,10 +69,7 @@ public sealed class IdBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdBox.AccountId, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.IdBox.AccountId): Unit = try { jp.co.soramitsu.iroha2.generated.AccountId.write(writer, instance.accountId) } catch (ex: Exception) { throw wrapException(ex) @@ -91,9 +80,7 @@ public sealed class IdBox : ModelEnum { /** * 'AssetDefinitionId' variant */ - public data class AssetDefinitionId( - public val assetDefinitionId: jp.co.soramitsu.iroha2.generated.AssetDefinitionId, - ) : IdBox() { + public data class AssetDefinitionId(public val assetDefinitionId: jp.co.soramitsu.iroha2.generated.AssetDefinitionId) : IdBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -109,10 +96,7 @@ public sealed class IdBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdBox.AssetDefinitionId, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.IdBox.AssetDefinitionId): Unit = try { jp.co.soramitsu.iroha2.generated.AssetDefinitionId.write(writer, instance.assetDefinitionId) } catch (ex: Exception) { throw wrapException(ex) @@ -123,9 +107,7 @@ public sealed class IdBox : ModelEnum { /** * 'AssetId' variant */ - public data class AssetId( - public val assetId: jp.co.soramitsu.iroha2.generated.AssetId, - ) : IdBox() { + public data class AssetId(public val assetId: jp.co.soramitsu.iroha2.generated.AssetId) : IdBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -133,19 +115,15 @@ public sealed class IdBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.AssetId = - try { - AssetId( - jp.co.soramitsu.iroha2.generated.AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdBox.AssetId, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.AssetId = try { + AssetId( + jp.co.soramitsu.iroha2.generated.AssetId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.IdBox.AssetId): Unit = try { jp.co.soramitsu.iroha2.generated.AssetId.write(writer, instance.assetId) } catch (ex: Exception) { throw wrapException(ex) @@ -156,9 +134,7 @@ public sealed class IdBox : ModelEnum { /** * 'PeerId' variant */ - public data class PeerId( - public val peerId: jp.co.soramitsu.iroha2.generated.PeerId, - ) : IdBox() { + public data class PeerId(public val peerId: jp.co.soramitsu.iroha2.generated.PeerId) : IdBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -166,19 +142,15 @@ public sealed class IdBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.PeerId = - try { - PeerId( - jp.co.soramitsu.iroha2.generated.PeerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdBox.PeerId, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.PeerId = try { + PeerId( + jp.co.soramitsu.iroha2.generated.PeerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.IdBox.PeerId): Unit = try { jp.co.soramitsu.iroha2.generated.PeerId.write(writer, instance.peerId) } catch (ex: Exception) { throw wrapException(ex) @@ -189,9 +161,7 @@ public sealed class IdBox : ModelEnum { /** * 'TriggerId' variant */ - public data class TriggerId( - public val triggerId: jp.co.soramitsu.iroha2.generated.TriggerId, - ) : IdBox() { + public data class TriggerId(public val triggerId: jp.co.soramitsu.iroha2.generated.TriggerId) : IdBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -207,10 +177,7 @@ public sealed class IdBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdBox.TriggerId, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.IdBox.TriggerId): Unit = try { jp.co.soramitsu.iroha2.generated.TriggerId.write(writer, instance.triggerId) } catch (ex: Exception) { throw wrapException(ex) @@ -221,9 +188,7 @@ public sealed class IdBox : ModelEnum { /** * 'RoleId' variant */ - public data class RoleId( - public val roleId: jp.co.soramitsu.iroha2.generated.RoleId, - ) : IdBox() { + public data class RoleId(public val roleId: jp.co.soramitsu.iroha2.generated.RoleId) : IdBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -231,19 +196,15 @@ public sealed class IdBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 6 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.RoleId = - try { - RoleId( - jp.co.soramitsu.iroha2.generated.RoleId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdBox.RoleId, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.RoleId = try { + RoleId( + jp.co.soramitsu.iroha2.generated.RoleId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.IdBox.RoleId): Unit = try { jp.co.soramitsu.iroha2.generated.RoleId.write(writer, instance.roleId) } catch (ex: Exception) { throw wrapException(ex) @@ -254,9 +215,7 @@ public sealed class IdBox : ModelEnum { /** * 'Permission' variant */ - public data class Permission( - public val permission: jp.co.soramitsu.iroha2.generated.Permission, - ) : IdBox() { + public data class Permission(public val permission: jp.co.soramitsu.iroha2.generated.Permission) : IdBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -272,10 +231,7 @@ public sealed class IdBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdBox.Permission, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.IdBox.Permission): Unit = try { jp.co.soramitsu.iroha2.generated.Permission.write(writer, instance.permission) } catch (ex: Exception) { throw wrapException(ex) @@ -286,9 +242,7 @@ public sealed class IdBox : ModelEnum { /** * 'CustomParameterId' variant */ - public data class CustomParameterId( - public val customParameterId: jp.co.soramitsu.iroha2.generated.CustomParameterId, - ) : IdBox() { + public data class CustomParameterId(public val customParameterId: jp.co.soramitsu.iroha2.generated.CustomParameterId) : IdBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -304,10 +258,7 @@ public sealed class IdBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdBox.CustomParameterId, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.IdBox.CustomParameterId): Unit = try { jp.co.soramitsu.iroha2.generated.CustomParameterId.write(writer, instance.customParameterId) } catch (ex: Exception) { throw wrapException(ex) @@ -326,7 +277,8 @@ public sealed class IdBox : ModelEnum { 6 -> RoleId.read(reader) 7 -> Permission.read(reader) 8 -> CustomParameterId.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: IdBox) { writer.directWrite(instance.discriminant()) @@ -340,7 +292,8 @@ public sealed class IdBox : ModelEnum { 6 -> RoleId.write(writer, instance as RoleId) 7 -> Permission.write(writer, instance as Permission) 8 -> CustomParameterId.write(writer, instance as CustomParameterId) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/IdentifiableBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/IdentifiableBox.kt deleted file mode 100644 index 02a5a5a20..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/IdentifiableBox.kt +++ /dev/null @@ -1,450 +0,0 @@ -// -// 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 - -/** - * IdentifiableBox - * - * Generated from 'IdentifiableBox' enum - */ -public sealed class IdentifiableBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'NewDomain' variant - */ - public data class NewDomain( - public val newDomain: jp.co.soramitsu.iroha2.generated.NewDomain, - ) : IdentifiableBox() { - 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.IdentifiableBox.NewDomain = try { - NewDomain( - jp.co.soramitsu.iroha2.generated.NewDomain.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdentifiableBox.NewDomain, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.NewDomain.write(writer, instance.newDomain) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'NewAccount' variant - */ - public data class NewAccount( - public val newAccount: jp.co.soramitsu.iroha2.generated.NewAccount, - ) : IdentifiableBox() { - 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.IdentifiableBox.NewAccount = try { - NewAccount( - jp.co.soramitsu.iroha2.generated.NewAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdentifiableBox.NewAccount, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.NewAccount.write(writer, instance.newAccount) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'NewAssetDefinition' variant - */ - public data class NewAssetDefinition( - public val newAssetDefinition: jp.co.soramitsu.iroha2.generated.NewAssetDefinition, - ) : IdentifiableBox() { - 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.IdentifiableBox.NewAssetDefinition = try { - NewAssetDefinition( - jp.co.soramitsu.iroha2.generated.NewAssetDefinition.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdentifiableBox.NewAssetDefinition, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.NewAssetDefinition.write( - writer, - instance.newAssetDefinition, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'NewRole' variant - */ - public data class NewRole( - public val role: jp.co.soramitsu.iroha2.generated.Role, - ) : IdentifiableBox() { - 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.IdentifiableBox.NewRole = try { - NewRole( - jp.co.soramitsu.iroha2.generated.Role.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdentifiableBox.NewRole, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Role.write(writer, instance.role) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Peer' variant - */ - public data class Peer( - public val peer: jp.co.soramitsu.iroha2.generated.Peer, - ) : IdentifiableBox() { - 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.IdentifiableBox.Peer = try { - Peer( - jp.co.soramitsu.iroha2.generated.Peer.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdentifiableBox.Peer, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Peer.write(writer, instance.peer) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Domain' variant - */ - public data class Domain( - public val domain: jp.co.soramitsu.iroha2.generated.Domain, - ) : IdentifiableBox() { - 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.IdentifiableBox.Domain = try { - Domain( - jp.co.soramitsu.iroha2.generated.Domain.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdentifiableBox.Domain, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Domain.write(writer, instance.domain) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Account' variant - */ - public data class Account( - public val account: jp.co.soramitsu.iroha2.generated.Account, - ) : IdentifiableBox() { - 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.IdentifiableBox.Account = try { - Account( - jp.co.soramitsu.iroha2.generated.Account.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdentifiableBox.Account, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Account.write(writer, instance.account) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'AssetDefinition' variant - */ - public data class AssetDefinition( - public val assetDefinition: jp.co.soramitsu.iroha2.generated.AssetDefinition, - ) : IdentifiableBox() { - 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.IdentifiableBox.AssetDefinition = try { - AssetDefinition( - jp.co.soramitsu.iroha2.generated.AssetDefinition.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdentifiableBox.AssetDefinition, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.AssetDefinition.write(writer, instance.assetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Asset' variant - */ - public data class Asset( - public val asset: jp.co.soramitsu.iroha2.generated.Asset, - ) : IdentifiableBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 8 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdentifiableBox.Asset = try { - Asset( - jp.co.soramitsu.iroha2.generated.Asset.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdentifiableBox.Asset, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Asset.write(writer, instance.asset) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Trigger' variant - */ - public data class Trigger( - public val trigger: jp.co.soramitsu.iroha2.generated.Trigger, - ) : IdentifiableBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 9 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdentifiableBox.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.IdentifiableBox.Trigger, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Trigger.write(writer, instance.trigger) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Role' variant - */ - public data class Role( - public val role: jp.co.soramitsu.iroha2.generated.Role, - ) : IdentifiableBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 10 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdentifiableBox.Role = try { - Role( - jp.co.soramitsu.iroha2.generated.Role.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdentifiableBox.Role, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Role.write(writer, instance.role) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'CustomParameter' variant - */ - public data class CustomParameter( - public val customParameter: jp.co.soramitsu.iroha2.generated.CustomParameter, - ) : IdentifiableBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 11 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdentifiableBox.CustomParameter = try { - CustomParameter( - jp.co.soramitsu.iroha2.generated.CustomParameter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.IdentifiableBox.CustomParameter, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.CustomParameter.write(writer, instance.customParameter) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): IdentifiableBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> NewDomain.read(reader) - 1 -> NewAccount.read(reader) - 2 -> NewAssetDefinition.read(reader) - 3 -> NewRole.read(reader) - 4 -> Peer.read(reader) - 5 -> Domain.read(reader) - 6 -> Account.read(reader) - 7 -> AssetDefinition.read(reader) - 8 -> Asset.read(reader) - 9 -> Trigger.read(reader) - 10 -> Role.read(reader) - 11 -> CustomParameter.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: IdentifiableBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> NewDomain.write(writer, instance as NewDomain) - 1 -> NewAccount.write(writer, instance as NewAccount) - 2 -> NewAssetDefinition.write(writer, instance as NewAssetDefinition) - 3 -> NewRole.write(writer, instance as NewRole) - 4 -> Peer.write(writer, instance as Peer) - 5 -> Domain.write(writer, instance as Domain) - 6 -> Account.write(writer, instance as Account) - 7 -> AssetDefinition.write(writer, instance as AssetDefinition) - 8 -> Asset.write(writer, instance as Asset) - 9 -> Trigger.write(writer, instance as Trigger) - 10 -> Role.write(writer, instance as Role) - 11 -> CustomParameter.write(writer, instance as CustomParameter) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionBox.kt index da498696b..92da3cbae 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionBox.kt @@ -26,9 +26,7 @@ public sealed class InstructionBox : ModelEnum { /** * 'Register' variant */ - public data class Register( - public val registerBox: RegisterBox, - ) : InstructionBox() { + public data class Register(public val registerBox: RegisterBox) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Register, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Register): Unit = try { RegisterBox.write(writer, instance.registerBox) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class InstructionBox : ModelEnum { /** * 'Unregister' variant */ - public data class Unregister( - public val unregisterBox: UnregisterBox, - ) : InstructionBox() { + public data class Unregister(public val unregisterBox: UnregisterBox) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Unregister, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Unregister): Unit = try { UnregisterBox.write(writer, instance.unregisterBox) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class InstructionBox : ModelEnum { /** * 'Mint' variant */ - public data class Mint( - public val mintBox: MintBox, - ) : InstructionBox() { + public data class Mint(public val mintBox: MintBox) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,10 +96,7 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Mint, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Mint): Unit = try { MintBox.write(writer, instance.mintBox) } catch (ex: Exception) { throw wrapException(ex) @@ -122,9 +107,7 @@ public sealed class InstructionBox : ModelEnum { /** * 'Burn' variant */ - public data class Burn( - public val burnBox: BurnBox, - ) : InstructionBox() { + public data class Burn(public val burnBox: BurnBox) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,10 +123,7 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Burn, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Burn): Unit = try { BurnBox.write(writer, instance.burnBox) } catch (ex: Exception) { throw wrapException(ex) @@ -154,9 +134,7 @@ public sealed class InstructionBox : ModelEnum { /** * 'Transfer' variant */ - public data class Transfer( - public val transferBox: TransferBox, - ) : InstructionBox() { + public data class Transfer(public val transferBox: TransferBox) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -172,10 +150,7 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Transfer, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Transfer): Unit = try { TransferBox.write(writer, instance.transferBox) } catch (ex: Exception) { throw wrapException(ex) @@ -186,9 +161,7 @@ public sealed class InstructionBox : ModelEnum { /** * 'SetKeyValue' variant */ - public data class SetKeyValue( - public val setKeyValueBox: SetKeyValueBox, - ) : InstructionBox() { + public data class SetKeyValue(public val setKeyValueBox: SetKeyValueBox) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -204,23 +177,19 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.SetKeyValue, - ): Unit = try { - SetKeyValueBox.write(writer, instance.setKeyValueBox) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.SetKeyValue): Unit = + try { + SetKeyValueBox.write(writer, instance.setKeyValueBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'RemoveKeyValue' variant */ - public data class RemoveKeyValue( - public val removeKeyValueBox: RemoveKeyValueBox, - ) : InstructionBox() { + public data class RemoveKeyValue(public val removeKeyValueBox: RemoveKeyValueBox) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -236,23 +205,19 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.RemoveKeyValue, - ): Unit = try { - RemoveKeyValueBox.write(writer, instance.removeKeyValueBox) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.RemoveKeyValue): Unit = + try { + RemoveKeyValueBox.write(writer, instance.removeKeyValueBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Grant' variant */ - public data class Grant( - public val grantBox: GrantBox, - ) : InstructionBox() { + public data class Grant(public val grantBox: GrantBox) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -268,10 +233,7 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Grant, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Grant): Unit = try { GrantBox.write(writer, instance.grantBox) } catch (ex: Exception) { throw wrapException(ex) @@ -282,9 +244,7 @@ public sealed class InstructionBox : ModelEnum { /** * 'Revoke' variant */ - public data class Revoke( - public val revokeBox: RevokeBox, - ) : InstructionBox() { + public data class Revoke(public val revokeBox: RevokeBox) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -300,10 +260,7 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Revoke, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Revoke): Unit = try { RevokeBox.write(writer, instance.revokeBox) } catch (ex: Exception) { throw wrapException(ex) @@ -314,9 +271,7 @@ public sealed class InstructionBox : ModelEnum { /** * 'ExecuteTrigger' variant */ - public data class ExecuteTrigger( - public val executeTrigger: jp.co.soramitsu.iroha2.generated.ExecuteTrigger, - ) : InstructionBox() { + public data class ExecuteTrigger(public val executeTrigger: jp.co.soramitsu.iroha2.generated.ExecuteTrigger) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -332,23 +287,19 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.ExecuteTrigger, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.ExecuteTrigger.write(writer, instance.executeTrigger) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.ExecuteTrigger): Unit = + try { + jp.co.soramitsu.iroha2.generated.ExecuteTrigger.write(writer, instance.executeTrigger) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'SetParameter' variant */ - public data class SetParameter( - public val setParameter: jp.co.soramitsu.iroha2.generated.SetParameter, - ) : InstructionBox() { + public data class SetParameter(public val setParameter: jp.co.soramitsu.iroha2.generated.SetParameter) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -364,23 +315,19 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.SetParameter, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.SetParameter.write(writer, instance.setParameter) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.SetParameter): Unit = + try { + jp.co.soramitsu.iroha2.generated.SetParameter.write(writer, instance.setParameter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Upgrade' variant */ - public data class Upgrade( - public val upgrade: jp.co.soramitsu.iroha2.generated.Upgrade, - ) : InstructionBox() { + public data class Upgrade(public val upgrade: jp.co.soramitsu.iroha2.generated.Upgrade) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -396,10 +343,7 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Upgrade, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Upgrade): Unit = try { jp.co.soramitsu.iroha2.generated.Upgrade.write(writer, instance.upgrade) } catch (ex: Exception) { throw wrapException(ex) @@ -410,9 +354,7 @@ public sealed class InstructionBox : ModelEnum { /** * 'Log' variant */ - public data class Log( - public val log: jp.co.soramitsu.iroha2.generated.Log, - ) : InstructionBox() { + public data class Log(public val log: jp.co.soramitsu.iroha2.generated.Log) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -428,10 +370,7 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Log, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Log): Unit = try { jp.co.soramitsu.iroha2.generated.Log.write(writer, instance.log) } catch (ex: Exception) { throw wrapException(ex) @@ -442,9 +381,7 @@ public sealed class InstructionBox : ModelEnum { /** * 'Custom' variant */ - public data class Custom( - public val customInstruction: CustomInstruction, - ) : InstructionBox() { + public data class Custom(public val customInstruction: CustomInstruction) : InstructionBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -460,10 +397,7 @@ public sealed class InstructionBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Custom, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionBox.Custom): Unit = try { CustomInstruction.write(writer, instance.customInstruction) } catch (ex: Exception) { throw wrapException(ex) @@ -472,10 +406,7 @@ public sealed class InstructionBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): InstructionBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): InstructionBox = when (val discriminant = reader.readUByte()) { 0 -> Register.read(reader) 1 -> Unregister.read(reader) 2 -> Mint.read(reader) @@ -490,7 +421,8 @@ public sealed class InstructionBox : ModelEnum { 11 -> Upgrade.read(reader) 12 -> Log.read(reader) 13 -> Custom.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: InstructionBox) { writer.directWrite(instance.discriminant()) @@ -509,7 +441,8 @@ public sealed class InstructionBox : ModelEnum { 11 -> Upgrade.write(writer, instance as Upgrade) 12 -> Log.write(writer, instance as Log) 13 -> Custom.write(writer, instance as Custom) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionEvaluationError.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionEvaluationError.kt index 1d78f7592..27b48c28e 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionEvaluationError.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionEvaluationError.kt @@ -27,9 +27,7 @@ public sealed class InstructionEvaluationError : ModelEnum { /** * 'Unsupported' variant */ - public data class Unsupported( - public val instructionType: InstructionType, - ) : InstructionEvaluationError() { + public data class Unsupported(public val instructionType: InstructionType) : InstructionEvaluationError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -48,21 +46,18 @@ public sealed class InstructionEvaluationError : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionEvaluationError.Unsupported, - ): Unit = - try { - InstructionType.write(writer, instance.instructionType) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = try { + InstructionType.write(writer, instance.instructionType) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'PermissionParameter' variant */ - public data class PermissionParameter( - public val string: String, - ) : InstructionEvaluationError() { + public data class PermissionParameter(public val string: String) : InstructionEvaluationError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -70,13 +65,14 @@ public sealed class InstructionEvaluationError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionEvaluationError.PermissionParameter = try { - PermissionParameter( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionEvaluationError.PermissionParameter = + try { + PermissionParameter( + reader.readString(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -92,9 +88,7 @@ public sealed class InstructionEvaluationError : ModelEnum { /** * 'Type' variant */ - public data class Type( - public val typeError: TypeError, - ) : InstructionEvaluationError() { + public data class Type(public val typeError: TypeError) : InstructionEvaluationError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -110,28 +104,24 @@ public sealed class InstructionEvaluationError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionEvaluationError.Type, - ): Unit = try { - TypeError.write(writer, instance.typeError) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionEvaluationError.Type): Unit = + try { + TypeError.write(writer, instance.typeError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): InstructionEvaluationError = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): InstructionEvaluationError = when (val discriminant = reader.readUByte()) { 0 -> Unsupported.read(reader) 1 -> PermissionParameter.read(reader) 2 -> Type.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: InstructionEvaluationError) { writer.directWrite(instance.discriminant()) @@ -139,7 +129,8 @@ public sealed class InstructionEvaluationError : ModelEnum { 0 -> Unsupported.write(writer, instance as Unsupported) 1 -> PermissionParameter.write(writer, instance as PermissionParameter) 2 -> Type.write(writer, instance as Type) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionExecutionError.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionExecutionError.kt index 760bb061c..c30efb4a7 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionExecutionError.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionExecutionError.kt @@ -27,9 +27,7 @@ public sealed class InstructionExecutionError : ModelEnum { /** * 'Evaluate' variant */ - public data class Evaluate( - public val instructionEvaluationError: InstructionEvaluationError, - ) : InstructionExecutionError() { + public data class Evaluate(public val instructionEvaluationError: InstructionEvaluationError) : InstructionExecutionError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -59,9 +57,7 @@ public sealed class InstructionExecutionError : ModelEnum { /** * 'Query' variant */ - public data class Query( - public val queryExecutionFail: QueryExecutionFail, - ) : InstructionExecutionError() { + public data class Query(public val queryExecutionFail: QueryExecutionFail) : InstructionExecutionError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -77,23 +73,19 @@ public sealed class InstructionExecutionError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Query, - ): Unit = try { - QueryExecutionFail.write(writer, instance.queryExecutionFail) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Query): Unit = + try { + QueryExecutionFail.write(writer, instance.queryExecutionFail) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Conversion' variant */ - public data class Conversion( - public val string: String, - ) : InstructionExecutionError() { + public data class Conversion(public val string: String) : InstructionExecutionError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -112,21 +104,18 @@ public sealed class InstructionExecutionError : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Conversion, - ): Unit = - try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Find' variant */ - public data class Find( - public val findError: FindError, - ) : InstructionExecutionError() { + public data class Find(public val findError: FindError) : InstructionExecutionError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -142,23 +131,19 @@ public sealed class InstructionExecutionError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Find, - ): Unit = try { - FindError.write(writer, instance.findError) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Find): Unit = + try { + FindError.write(writer, instance.findError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Repetition' variant */ - public data class Repetition( - public val repetitionError: RepetitionError, - ) : InstructionExecutionError() { + public data class Repetition(public val repetitionError: RepetitionError) : InstructionExecutionError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -177,21 +162,18 @@ public sealed class InstructionExecutionError : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Repetition, - ): Unit = - try { - RepetitionError.write(writer, instance.repetitionError) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = try { + RepetitionError.write(writer, instance.repetitionError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Mintability' variant */ - public data class Mintability( - public val mintabilityError: MintabilityError, - ) : InstructionExecutionError() { + public data class Mintability(public val mintabilityError: MintabilityError) : InstructionExecutionError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -210,21 +192,18 @@ public sealed class InstructionExecutionError : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Mintability, - ): Unit = - try { - MintabilityError.write(writer, instance.mintabilityError) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = try { + MintabilityError.write(writer, instance.mintabilityError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Math' variant */ - public data class Math( - public val mathError: MathError, - ) : InstructionExecutionError() { + public data class Math(public val mathError: MathError) : InstructionExecutionError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -240,23 +219,19 @@ public sealed class InstructionExecutionError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Math, - ): Unit = try { - MathError.write(writer, instance.mathError) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Math): Unit = + try { + MathError.write(writer, instance.mathError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'InvalidParameter' variant */ - public data class InvalidParameter( - public val invalidParameterError: InvalidParameterError, - ) : InstructionExecutionError() { + public data class InvalidParameter(public val invalidParameterError: InvalidParameterError) : InstructionExecutionError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -286,9 +261,7 @@ public sealed class InstructionExecutionError : ModelEnum { /** * 'InvariantViolation' variant */ - public data class InvariantViolation( - public val string: String, - ) : InstructionExecutionError() { + public data class InvariantViolation(public val string: String) : InstructionExecutionError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -296,13 +269,14 @@ public sealed class InstructionExecutionError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 8 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.InvariantViolation = try { - InvariantViolation( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.InvariantViolation = + try { + InvariantViolation( + reader.readString(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -318,10 +292,7 @@ public sealed class InstructionExecutionError : ModelEnum { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): InstructionExecutionError = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): InstructionExecutionError = when (val discriminant = reader.readUByte()) { 0 -> Evaluate.read(reader) 1 -> Query.read(reader) 2 -> Conversion.read(reader) @@ -331,7 +302,8 @@ public sealed class InstructionExecutionError : ModelEnum { 6 -> Math.read(reader) 7 -> InvalidParameter.read(reader) 8 -> InvariantViolation.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: InstructionExecutionError) { writer.directWrite(instance.discriminant()) @@ -345,7 +317,8 @@ public sealed class InstructionExecutionError : ModelEnum { 6 -> Math.write(writer, instance as Math) 7 -> InvalidParameter.write(writer, instance as InvalidParameter) 8 -> InvariantViolation.write(writer, instance as InvariantViolation) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionExecutionFail.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionExecutionFail.kt index 96f0c4d1b..338bd7eec 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionExecutionFail.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionExecutionFail.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'InstructionExecutionFail' regular structure */ -public data class InstructionExecutionFail( - public val instruction: InstructionBox, - public val reason: String, -) { +public data class InstructionExecutionFail(public val instruction: InstructionBox, public val reason: String) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionType.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionType.kt index cd9cc929b..633f850ef 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionType.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InstructionType.kt @@ -40,7 +40,8 @@ public sealed class InstructionType : ModelEnum { is Upgrade -> Upgrade.equals(this, other) is Log -> Log.equals(this, other) is Custom -> Custom.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is Register -> Register.hashCode() @@ -57,7 +58,8 @@ public sealed class InstructionType : ModelEnum { is Upgrade -> Upgrade.hashCode() is Log -> Log.hashCode() is Custom -> Custom.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'Register' variant @@ -76,10 +78,7 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.Register, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Register): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -110,13 +109,11 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.Unregister, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Unregister): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } public fun equals(o1: jp.co.soramitsu.iroha2.generated.InstructionType.Unregister, o2: Any?): Boolean = when (o2) { null -> false @@ -144,10 +141,7 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.Mint, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Mint): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -178,10 +172,7 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.Burn, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Burn): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -212,10 +203,7 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.Transfer, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Transfer): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -246,13 +234,11 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.SetKeyValue, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.SetKeyValue): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } public fun equals(o1: jp.co.soramitsu.iroha2.generated.InstructionType.SetKeyValue, o2: Any?): Boolean = when (o2) { null -> false @@ -280,18 +266,13 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.RemoveKeyValue, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.RemoveKeyValue): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.InstructionType.RemoveKeyValue, - o2: Any?, - ): Boolean = when (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.InstructionType.RemoveKeyValue, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -317,10 +298,7 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.Grant, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Grant): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -351,10 +329,7 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.Revoke, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Revoke): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -385,18 +360,13 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.ExecuteTrigger, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.ExecuteTrigger): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.InstructionType.ExecuteTrigger, - o2: Any?, - ): Boolean = when (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.InstructionType.ExecuteTrigger, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -422,18 +392,13 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.SetParameter, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.SetParameter): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.InstructionType.SetParameter, - o2: Any?, - ): Boolean = when (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.InstructionType.SetParameter, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -459,10 +424,7 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.Upgrade, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Upgrade): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -493,10 +455,7 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.Log, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Log): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -527,10 +486,7 @@ public sealed class InstructionType : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InstructionType.Custom, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Custom): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -545,10 +501,7 @@ public sealed class InstructionType : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): InstructionType = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): InstructionType = when (val discriminant = reader.readUByte()) { 0 -> Register.read(reader) 1 -> Unregister.read(reader) 2 -> Mint.read(reader) @@ -563,7 +516,8 @@ public sealed class InstructionType : ModelEnum { 11 -> Upgrade.read(reader) 12 -> Log.read(reader) 13 -> Custom.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: InstructionType) { writer.directWrite(instance.discriminant()) @@ -582,7 +536,8 @@ public sealed class InstructionType : ModelEnum { 11 -> Upgrade.write(writer, instance as Upgrade) 12 -> Log.write(writer, instance as Log) 13 -> Custom.write(writer, instance as Custom) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InvalidParameterError.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InvalidParameterError.kt index 55914c99b..73de42b1b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InvalidParameterError.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/InvalidParameterError.kt @@ -28,18 +28,18 @@ public sealed class InvalidParameterError : ModelEnum { override fun equals(other: Any?): Boolean = when (this) { is TimeTriggerInThePast -> TimeTriggerInThePast.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is TimeTriggerInThePast -> TimeTriggerInThePast.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'Wasm' variant */ - public data class Wasm( - public val string: String, - ) : InvalidParameterError() { + public data class Wasm(public val string: String) : InvalidParameterError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -55,14 +55,12 @@ public sealed class InvalidParameterError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.InvalidParameterError.Wasm, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InvalidParameterError.Wasm): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -91,33 +89,30 @@ public sealed class InvalidParameterError : ModelEnum { throw wrapException(ex) } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.InvalidParameterError.TimeTriggerInThePast, - o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals(o1: jp.co.soramitsu.iroha2.generated.InvalidParameterError.TimeTriggerInThePast, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InvalidParameterError.TimeTriggerInThePast".hashCode() } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): InvalidParameterError = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): InvalidParameterError = when (val discriminant = reader.readUByte()) { 0 -> Wasm.read(reader) 1 -> TimeTriggerInThePast.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: InvalidParameterError) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Wasm.write(writer, instance as Wasm) 1 -> TimeTriggerInThePast.write(writer, instance as TimeTriggerInThePast) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/IpfsPath.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/IpfsPath.kt index dc195a395..0ab9a97f6 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/IpfsPath.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/IpfsPath.kt @@ -16,9 +16,7 @@ import kotlin.Unit * * Generated from 'IpfsPath' regular structure */ -public data class IpfsPath( - public val string: String, -) { +public data class IpfsPath(public val string: String) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): IpfsPath = try { IpfsPath( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Ipv4Addr.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Ipv4Addr.kt index ff92ed36c..3db3ab72e 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Ipv4Addr.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Ipv4Addr.kt @@ -19,9 +19,7 @@ import kotlin.Unit * * Generated from 'Ipv4Addr' regular structure */ -public data class Ipv4Addr( - public val arrayOfU8: ByteArray, -) { +public data class Ipv4Addr(public val arrayOfU8: ByteArray) { override fun equals(other: Any?): Boolean { if (this === other) return true if (other !is Ipv4Addr) return false diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Ipv6Addr.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Ipv6Addr.kt index 349d53706..b9c9d5c8f 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Ipv6Addr.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Ipv6Addr.kt @@ -17,9 +17,7 @@ import kotlin.Unit * * Generated from 'Ipv6Addr' regular structure */ -public data class Ipv6Addr( - public val arrayOfU16: Array, -) { +public data class Ipv6Addr(public val arrayOfU16: Array) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Ipv6Addr = try { Ipv6Addr( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetById.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Json.kt similarity index 52% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetById.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Json.kt index e9757c51a..72d91f743 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetById.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Json.kt @@ -8,27 +8,26 @@ 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.String import kotlin.Unit /** - * FindAssetById + * Json * - * Generated from 'FindAssetById' regular structure + * Generated from 'Json' regular structure */ -public data class FindAssetById( - public val id: AssetId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetById = try { - FindAssetById( - AssetId.read(reader), +public data class Json(public val string: String) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): Json = try { + Json( + reader.readString(), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: FindAssetById): Unit = try { - AssetId.write(writer, instance.id) + override fun write(writer: ScaleCodecWriter, instance: Json): Unit = try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) } catch (ex: Exception) { throw wrapException(ex) } 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/SignedBlockPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfPredicateMarker.kt similarity index 50% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfPredicateMarker.kt index 57b480932..da8287701 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfPredicateMarker.kt @@ -13,32 +13,30 @@ import kotlin.Int import kotlin.Unit /** - * SignedBlockPredicateBox + * JsonProjectionOfPredicateMarker * - * Generated from 'SignedBlockPredicateBox' enum + * Generated from 'JsonProjectionOfPredicateMarker' enum */ -public sealed class SignedBlockPredicateBox : ModelEnum { +public sealed class JsonProjectionOfPredicateMarker : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int /** - * 'Header' variant + * 'Atom' variant */ - public data class Header( - public val blockHeaderPredicateBox: BlockHeaderPredicateBox, - ) : SignedBlockPredicateBox() { + public data class Atom(public val jsonPredicateAtom: JsonPredicateAtom) : JsonProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SignedBlockPredicateBox.Header = try { - Header( - BlockHeaderPredicateBox.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.JsonProjectionOfPredicateMarker.Atom = try { + Atom( + JsonPredicateAtom.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -46,9 +44,9 @@ public sealed class SignedBlockPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SignedBlockPredicateBox.Header, + instance: jp.co.soramitsu.iroha2.generated.JsonProjectionOfPredicateMarker.Atom, ): Unit = try { - BlockHeaderPredicateBox.write(writer, instance.blockHeaderPredicateBox) + JsonPredicateAtom.write(writer, instance.jsonPredicateAtom) } catch (ex: Exception) { throw wrapException(ex) } @@ -56,20 +54,19 @@ public sealed class SignedBlockPredicateBox : ModelEnum { } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): SignedBlockPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Header.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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: SignedBlockPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: JsonProjectionOfPredicateMarker) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Header.write(writer, instance as Header) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $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/Level.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Level.kt index c8922439c..315932072 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Level.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Level.kt @@ -31,7 +31,8 @@ public sealed class Level : ModelEnum { is INFO -> INFO.equals(this, other) is WARN -> WARN.equals(this, other) is ERROR -> ERROR.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is TRACE -> TRACE.hashCode() @@ -39,7 +40,8 @@ public sealed class Level : ModelEnum { is INFO -> INFO.hashCode() is WARN -> WARN.hashCode() is ERROR -> ERROR.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'TRACE' variant @@ -52,23 +54,18 @@ public sealed class Level : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Level.TRACE = - try { - TRACE() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Level.TRACE, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Level.TRACE = try { + TRACE() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Level.TRACE): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: jp.co.soramitsu.iroha2.generated.Level.TRACE, o2: Any?): Boolean = when - (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.Level.TRACE, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -88,23 +85,18 @@ public sealed class Level : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Level.DEBUG = - try { - DEBUG() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Level.DEBUG, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Level.DEBUG = try { + DEBUG() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Level.DEBUG): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: jp.co.soramitsu.iroha2.generated.Level.DEBUG, o2: Any?): Boolean = when - (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.Level.DEBUG, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -130,16 +122,12 @@ public sealed class Level : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Level.INFO, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Level.INFO): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: jp.co.soramitsu.iroha2.generated.Level.INFO, o2: Any?): Boolean = when - (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.Level.INFO, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -165,16 +153,12 @@ public sealed class Level : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Level.WARN, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Level.WARN): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: jp.co.soramitsu.iroha2.generated.Level.WARN, o2: Any?): Boolean = when - (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.Level.WARN, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -194,23 +178,18 @@ public sealed class Level : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Level.ERROR = - try { - ERROR() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Level.ERROR, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Level.ERROR = try { + ERROR() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Level.ERROR): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: jp.co.soramitsu.iroha2.generated.Level.ERROR, o2: Any?): Boolean = when - (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.Level.ERROR, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -226,7 +205,8 @@ public sealed class Level : ModelEnum { 2 -> INFO.read(reader) 3 -> WARN.read(reader) 4 -> ERROR.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: Level) { writer.directWrite(instance.discriminant()) @@ -236,7 +216,8 @@ public sealed class Level : ModelEnum { 2 -> INFO.write(writer, instance as INFO) 3 -> WARN.write(writer, instance as WARN) 4 -> ERROR.write(writer, instance as ERROR) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Log.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Log.kt index 5f02f1f83..86ac33c5c 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Log.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Log.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'Log' regular structure */ -public data class Log( - public val level: Level, - public val msg: String, -) { +public data class Log(public val level: Level, public val msg: String) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Log = try { Log( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MathError.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MathError.kt index e3ec6fe97..b56d9eac9 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MathError.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MathError.kt @@ -33,7 +33,8 @@ public sealed class MathError : ModelEnum { is NegativeValue -> NegativeValue.equals(this, other) is DomainViolation -> DomainViolation.equals(this, other) is Unknown -> Unknown.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is Overflow -> Overflow.hashCode() @@ -42,7 +43,8 @@ public sealed class MathError : ModelEnum { is NegativeValue -> NegativeValue.hashCode() is DomainViolation -> DomainViolation.hashCode() is Unknown -> Unknown.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'Overflow' variant @@ -61,10 +63,7 @@ public sealed class MathError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.MathError.Overflow, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MathError.Overflow): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -95,13 +94,11 @@ public sealed class MathError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.MathError.NotEnoughQuantity, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MathError.NotEnoughQuantity): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } public fun equals(o1: jp.co.soramitsu.iroha2.generated.MathError.NotEnoughQuantity, o2: Any?): Boolean = when (o2) { null -> false @@ -129,10 +126,7 @@ public sealed class MathError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.MathError.DivideByZero, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MathError.DivideByZero): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -163,10 +157,7 @@ public sealed class MathError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.MathError.NegativeValue, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MathError.NegativeValue): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -197,10 +188,7 @@ public sealed class MathError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.MathError.DomainViolation, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MathError.DomainViolation): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -231,19 +219,15 @@ public sealed class MathError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.MathError.Unknown, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MathError.Unknown): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: jp.co.soramitsu.iroha2.generated.MathError.Unknown, o2: Any?): Boolean = - when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals(o1: jp.co.soramitsu.iroha2.generated.MathError.Unknown, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".MathError.Unknown".hashCode() } @@ -252,9 +236,7 @@ public sealed class MathError : ModelEnum { /** * 'FixedPointConversion' variant */ - public data class FixedPointConversion( - public val string: String, - ) : MathError() { + public data class FixedPointConversion(public val string: String) : MathError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -270,22 +252,17 @@ public sealed class MathError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.MathError.FixedPointConversion, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MathError.FixedPointConversion): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): MathError = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): MathError = when (val discriminant = reader.readUByte()) { 0 -> Overflow.read(reader) 1 -> NotEnoughQuantity.read(reader) 2 -> DivideByZero.read(reader) @@ -293,7 +270,8 @@ public sealed class MathError : ModelEnum { 4 -> DomainViolation.read(reader) 5 -> Unknown.read(reader) 6 -> FixedPointConversion.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: MathError) { writer.directWrite(instance.discriminant()) @@ -305,7 +283,8 @@ public sealed class MathError : ModelEnum { 4 -> DomainViolation.write(writer, instance as DomainViolation) 5 -> Unknown.write(writer, instance as Unknown) 6 -> FixedPointConversion.write(writer, instance as FixedPointConversion) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Metadata.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Metadata.kt index 528ddc575..2e758a137 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Metadata.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Metadata.kt @@ -9,7 +9,6 @@ import jp.co.soramitsu.iroha2.codec.ScaleReader import jp.co.soramitsu.iroha2.codec.ScaleWriter import jp.co.soramitsu.iroha2.comparator import jp.co.soramitsu.iroha2.wrapException -import kotlin.String import kotlin.Unit import kotlin.collections.Map @@ -18,13 +17,11 @@ import kotlin.collections.Map * * Generated from 'Metadata' regular structure */ -public data class Metadata( - public val sortedMapOfName: Map, -) { +public data class Metadata(public val sortedMapOfName: Map) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Metadata = try { Metadata( - reader.readMap(reader.readCompactInt(), { Name.read(reader) }, { reader.readString() }), + reader.readMap(reader.readCompactInt(), { Name.read(reader) }, { Json.read(reader) }), ) } catch (ex: Exception) { throw wrapException(ex) @@ -36,7 +33,7 @@ public data class Metadata( Name.comparator(), ).forEach { (key, value) -> Name.write(writer, key) - writer.writeAsList(value.toByteArray(Charsets.UTF_8)) + Json.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfAccountId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfAccountId.kt index 6e8a77ace..d24468486 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfAccountId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfAccountId.kt @@ -8,7 +8,6 @@ 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.String import kotlin.Unit /** @@ -19,7 +18,7 @@ import kotlin.Unit public data class MetadataChangedOfAccountId( public val target: AccountId, public val key: Name, - public val `value`: String, + public val `value`: Json, ) { public companion object : ScaleReader, @@ -28,7 +27,7 @@ public data class MetadataChangedOfAccountId( MetadataChangedOfAccountId( AccountId.read(reader), Name.read(reader), - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -37,7 +36,7 @@ public data class MetadataChangedOfAccountId( override fun write(writer: ScaleCodecWriter, instance: MetadataChangedOfAccountId): Unit = try { AccountId.write(writer, instance.target) Name.write(writer, instance.key) - writer.writeAsList(instance.`value`.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.`value`) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfAssetDefinitionId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfAssetDefinitionId.kt index dca636649..8a81aad5e 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfAssetDefinitionId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfAssetDefinitionId.kt @@ -8,7 +8,6 @@ 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.String import kotlin.Unit /** @@ -19,7 +18,7 @@ import kotlin.Unit public data class MetadataChangedOfAssetDefinitionId( public val target: AssetDefinitionId, public val key: Name, - public val `value`: String, + public val `value`: Json, ) { public companion object : ScaleReader, @@ -28,7 +27,7 @@ public data class MetadataChangedOfAssetDefinitionId( MetadataChangedOfAssetDefinitionId( AssetDefinitionId.read(reader), Name.read(reader), - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -37,7 +36,7 @@ public data class MetadataChangedOfAssetDefinitionId( override fun write(writer: ScaleCodecWriter, instance: MetadataChangedOfAssetDefinitionId): Unit = try { AssetDefinitionId.write(writer, instance.target) Name.write(writer, instance.key) - writer.writeAsList(instance.`value`.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.`value`) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfAssetId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfAssetId.kt index dd84cede1..45de78697 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfAssetId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfAssetId.kt @@ -8,7 +8,6 @@ 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.String import kotlin.Unit /** @@ -19,7 +18,7 @@ import kotlin.Unit public data class MetadataChangedOfAssetId( public val target: AssetId, public val key: Name, - public val `value`: String, + public val `value`: Json, ) { public companion object : ScaleReader, @@ -28,7 +27,7 @@ public data class MetadataChangedOfAssetId( MetadataChangedOfAssetId( AssetId.read(reader), Name.read(reader), - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -37,7 +36,7 @@ public data class MetadataChangedOfAssetId( override fun write(writer: ScaleCodecWriter, instance: MetadataChangedOfAssetId): Unit = try { AssetId.write(writer, instance.target) Name.write(writer, instance.key) - writer.writeAsList(instance.`value`.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.`value`) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfDomainId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfDomainId.kt index f3be34eeb..aad330bfd 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfDomainId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfDomainId.kt @@ -8,7 +8,6 @@ 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.String import kotlin.Unit /** @@ -19,7 +18,7 @@ import kotlin.Unit public data class MetadataChangedOfDomainId( public val target: DomainId, public val key: Name, - public val `value`: String, + public val `value`: Json, ) { public companion object : ScaleReader, @@ -28,7 +27,7 @@ public data class MetadataChangedOfDomainId( MetadataChangedOfDomainId( DomainId.read(reader), Name.read(reader), - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -37,7 +36,7 @@ public data class MetadataChangedOfDomainId( override fun write(writer: ScaleCodecWriter, instance: MetadataChangedOfDomainId): Unit = try { DomainId.write(writer, instance.target) Name.write(writer, instance.key) - writer.writeAsList(instance.`value`.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.`value`) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfTriggerId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfTriggerId.kt index 7145c306b..b1d474731 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfTriggerId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataChangedOfTriggerId.kt @@ -8,7 +8,6 @@ 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.String import kotlin.Unit /** @@ -19,7 +18,7 @@ import kotlin.Unit public data class MetadataChangedOfTriggerId( public val target: TriggerId, public val key: Name, - public val `value`: String, + public val `value`: Json, ) { public companion object : ScaleReader, @@ -28,7 +27,7 @@ public data class MetadataChangedOfTriggerId( MetadataChangedOfTriggerId( TriggerId.read(reader), Name.read(reader), - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -37,7 +36,7 @@ public data class MetadataChangedOfTriggerId( override fun write(writer: ScaleCodecWriter, instance: MetadataChangedOfTriggerId): Unit = try { TriggerId.write(writer, instance.target) Name.write(writer, instance.key) - writer.writeAsList(instance.`value`.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.`value`) } catch (ex: Exception) { throw wrapException(ex) } 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/MetadataPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataPredicateAtom.kt similarity index 66% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataPredicateAtom.kt index 1c99d97cd..f5bdc63f9 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataPredicateAtom.kt @@ -11,27 +11,26 @@ import jp.co.soramitsu.iroha2.codec.ScaleWriter import kotlin.Int /** - * MetadataPredicateBox + * MetadataPredicateAtom * - * Generated from 'MetadataPredicateBox' enum + * Generated from 'MetadataPredicateAtom' enum */ -public sealed class MetadataPredicateBox : ModelEnum { +public sealed class MetadataPredicateAtom : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): MetadataPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): MetadataPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: MetadataPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: MetadataPredicateAtom) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } 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 new file mode 100644 index 000000000..f0bb49659 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataProjectionOfPredicateMarker.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 + +/** + * MetadataProjectionOfPredicateMarker + * + * Generated from 'MetadataProjectionOfPredicateMarker' enum + */ +public sealed class MetadataProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val metadataPredicateAtom: MetadataPredicateAtom) : MetadataProjectionOfPredicateMarker() { + 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.MetadataProjectionOfPredicateMarker.Atom = try { + Atom( + MetadataPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.MetadataProjectionOfPredicateMarker.Atom, + ): Unit = try { + MetadataPredicateAtom.write(writer, instance.metadataPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * '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") + } + + override fun write(writer: ScaleCodecWriter, instance: MetadataProjectionOfPredicateMarker) { + 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 new file mode 100644 index 000000000..81fc8ae24 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataProjectionOfSelectorMarker.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 + +/** + * MetadataProjectionOfSelectorMarker + * + * Generated from 'MetadataProjectionOfSelectorMarker' enum + */ +public sealed class MetadataProjectionOfSelectorMarker : 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 : MetadataProjectionOfSelectorMarker() { + 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.MetadataProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.MetadataProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.MetadataProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".MetadataProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * '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") + } + + override fun write(writer: ScaleCodecWriter, instance: MetadataProjectionOfSelectorMarker) { + 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/MintBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintBox.kt index dad362578..c8411014a 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintBox.kt @@ -26,9 +26,7 @@ public sealed class MintBox : ModelEnum { /** * 'Asset' variant */ - public data class Asset( - public val mintOfNumericAndAsset: MintOfNumericAndAsset, - ) : MintBox() { + public data class Asset(public val mintOfNumericAndAsset: MintOfNumericAndAsset) : MintBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -36,19 +34,15 @@ public sealed class MintBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MintBox.Asset = - try { - Asset( - MintOfNumericAndAsset.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MintBox.Asset = try { + Asset( + MintOfNumericAndAsset.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.MintBox.Asset, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MintBox.Asset): Unit = try { MintOfNumericAndAsset.write(writer, instance.mintOfNumericAndAsset) } catch (ex: Exception) { throw wrapException(ex) @@ -59,9 +53,7 @@ public sealed class MintBox : ModelEnum { /** * 'TriggerRepetitions' variant */ - public data class TriggerRepetitions( - public val mintOfu32AndTrigger: MintOfu32AndTrigger, - ) : MintBox() { + public data class TriggerRepetitions(public val mintOfu32AndTrigger: MintOfu32AndTrigger) : MintBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -77,32 +69,29 @@ public sealed class MintBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.MintBox.TriggerRepetitions, - ): Unit = try { - MintOfu32AndTrigger.write(writer, instance.mintOfu32AndTrigger) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MintBox.TriggerRepetitions): Unit = + try { + MintOfu32AndTrigger.write(writer, instance.mintOfu32AndTrigger) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): MintBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): MintBox = when (val discriminant = reader.readUByte()) { 0 -> Asset.read(reader) 1 -> TriggerRepetitions.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: MintBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Asset.write(writer, instance as Asset) 1 -> TriggerRepetitions.write(writer, instance as TriggerRepetitions) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintOfNumericAndAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintOfNumericAndAsset.kt index bfb7c849b..41b1b11a2 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintOfNumericAndAsset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintOfNumericAndAsset.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,10 +18,9 @@ import kotlin.Unit * * Generated from 'MintOfNumericAndAsset' regular structure */ -public data class MintOfNumericAndAsset( - public val `object`: Numeric, - public val destination: AssetId, -) { +public data class MintOfNumericAndAsset(public val `object`: Numeric, public val destination: AssetId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): MintOfNumericAndAsset = try { MintOfNumericAndAsset( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintOfu32AndTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintOfu32AndTrigger.kt index 35f188325..278cb2d51 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintOfu32AndTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintOfu32AndTrigger.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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.Long import kotlin.Unit @@ -16,10 +19,9 @@ import kotlin.Unit * * Generated from 'MintOfu32AndTrigger' regular structure */ -public data class MintOfu32AndTrigger( - public val `object`: Long, - public val destination: TriggerId, -) { +public data class MintOfu32AndTrigger(public val `object`: Long, public val destination: TriggerId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): MintOfu32AndTrigger = try { MintOfu32AndTrigger( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintabilityError.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintabilityError.kt index 8cd0c7be6..fff744276 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintabilityError.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MintabilityError.kt @@ -28,12 +28,14 @@ public sealed class MintabilityError : ModelEnum { override fun equals(other: Any?): Boolean = when (this) { is MintUnmintable -> MintUnmintable.equals(this, other) is ForbidMintOnMintable -> ForbidMintOnMintable.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is MintUnmintable -> MintUnmintable.hashCode() is ForbidMintOnMintable -> ForbidMintOnMintable.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'MintUnmintable' variant @@ -52,18 +54,13 @@ public sealed class MintabilityError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.MintabilityError.MintUnmintable, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MintabilityError.MintUnmintable): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.MintabilityError.MintUnmintable, - o2: Any?, - ): Boolean = when (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.MintabilityError.MintUnmintable, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -92,16 +89,12 @@ public sealed class MintabilityError : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MintabilityError.ForbidMintOnMintable, - ): Unit = - try { - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.MintabilityError.ForbidMintOnMintable, - o2: Any?, - ): Boolean = when (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.MintabilityError.ForbidMintOnMintable, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -111,20 +104,19 @@ public sealed class MintabilityError : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): MintabilityError = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): MintabilityError = when (val discriminant = reader.readUByte()) { 0 -> MintUnmintable.read(reader) 1 -> ForbidMintOnMintable.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: MintabilityError) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> MintUnmintable.write(writer, instance as MintUnmintable) 1 -> ForbidMintOnMintable.write(writer, instance as ForbidMintOnMintable) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Mintable.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Mintable.kt index acce75b1b..51a19ed5e 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Mintable.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Mintable.kt @@ -29,13 +29,15 @@ public sealed class Mintable : ModelEnum { is Infinitely -> Infinitely.equals(this, other) is Once -> Once.equals(this, other) is Not -> Not.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is Infinitely -> Infinitely.hashCode() is Once -> Once.hashCode() is Not -> Not.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'Infinitely' variant @@ -54,10 +56,7 @@ public sealed class Mintable : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Mintable.Infinitely, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Mintable.Infinitely): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -82,26 +81,21 @@ public sealed class Mintable : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Mintable.Once = - try { - Once() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Mintable.Once, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Mintable.Once = try { + Once() } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: jp.co.soramitsu.iroha2.generated.Mintable.Once, o2: Any?): Boolean = - when (o2) { - null -> false - else -> o2::class == o1::class - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Mintable.Once): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.Mintable.Once, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Mintable.Once".hashCode() } @@ -118,23 +112,18 @@ public sealed class Mintable : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Mintable.Not = - try { - Not() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Mintable.Not, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Mintable.Not = try { + Not() } catch (ex: Exception) { throw wrapException(ex) } - public fun equals(o1: jp.co.soramitsu.iroha2.generated.Mintable.Not, o2: Any?): Boolean = when - (o2) { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Mintable.Not): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.Mintable.Not, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -144,14 +133,12 @@ public sealed class Mintable : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Mintable = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): Mintable = when (val discriminant = reader.readUByte()) { 0 -> Infinitely.read(reader) 1 -> Once.read(reader) 2 -> Not.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: Mintable) { writer.directWrite(instance.discriminant()) @@ -159,7 +146,8 @@ public sealed class Mintable : ModelEnum { 0 -> Infinitely.write(writer, instance as Infinitely) 1 -> Once.write(writer, instance as Once) 2 -> Not.write(writer, instance as Not) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Mismatch.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Mismatch.kt index 081ad703b..8a25fc83e 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Mismatch.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Mismatch.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'Mismatch' regular structure */ -public data class Mismatch( - public val expected: AssetType, - public val `actual`: AssetType, -) { +public data class Mismatch(public val expected: AssetType, public val `actual`: AssetType) { public companion object : ScaleReader>, ScaleWriter> { override fun read(reader: ScaleCodecReader): Mismatch = try { Mismatch( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigAccountArgs.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigAccountArgs.kt new file mode 100644 index 000000000..912c6eef3 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigAccountArgs.kt @@ -0,0 +1,60 @@ +// +// 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.comparator +import jp.co.soramitsu.iroha2.wrapException +import java.math.BigInteger +import kotlin.Int +import kotlin.Short +import kotlin.Unit +import kotlin.collections.Map + +/** + * MultisigAccountArgs + * + * Generated from 'MultisigAccountArgs' regular structure + */ +public data class MultisigAccountArgs( + public val account: PublicKey, + public val signatories: Map, + public val quorum: Int, + public val transactionTtlMs: BigInteger, +) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): MultisigAccountArgs = try { + MultisigAccountArgs( + PublicKey.read(reader), + reader.readMap( + reader.readCompactInt(), + { AccountId.read(reader) }, + { reader.readUByte().toShort() }, + ), + reader.readUint16(), + reader.readUint64(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: MultisigAccountArgs): Unit = try { + PublicKey.write(writer, instance.account) + writer.writeCompact(instance.signatories.size) + instance.signatories.toSortedMap( + AccountId.comparator(), + ).forEach { (key, value) -> + AccountId.write(writer, key) + writer.writeUByte(value) + } + writer.writeUint16(instance.quorum) + writer.writeUint64(instance.transactionTtlMs) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigApprove.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigApprove.kt new file mode 100644 index 000000000..bc0c139ba --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigApprove.kt @@ -0,0 +1,39 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelCustomInstruction +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 +import kotlin.collections.List + +/** + * MultisigApprove + * + * Generated from 'MultisigApprove' regular structure + */ +public data class MultisigApprove(public val account: AccountId, public val instructionsHash: HashOf>) : + ModelCustomInstruction { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): MultisigApprove = try { + MultisigApprove( + AccountId.read(reader), + HashOf.read(reader) as HashOf>, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: MultisigApprove): Unit = try { + AccountId.write(writer, instance.account) + HashOf.write(writer, instance.instructionsHash) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigInstructionBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigInstructionBox.kt new file mode 100644 index 000000000..6b369d540 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigInstructionBox.kt @@ -0,0 +1,130 @@ +// +// 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 + +/** + * MultisigInstructionBox + * + * Generated from 'MultisigInstructionBox' enum + */ +public sealed class MultisigInstructionBox : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Register' variant + */ + public data class Register(public val multisigRegister: MultisigRegister) : MultisigInstructionBox() { + 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.MultisigInstructionBox.Register = try { + Register( + MultisigRegister.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MultisigInstructionBox.Register): Unit = + try { + MultisigRegister.write(writer, instance.multisigRegister) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Propose' variant + */ + public data class Propose(public val multisigPropose: MultisigPropose) : MultisigInstructionBox() { + 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.MultisigInstructionBox.Propose = try { + Propose( + MultisigPropose.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MultisigInstructionBox.Propose): Unit = + try { + MultisigPropose.write(writer, instance.multisigPropose) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Approve' variant + */ + public data class Approve(public val multisigApprove: MultisigApprove) : MultisigInstructionBox() { + 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.MultisigInstructionBox.Approve = try { + Approve( + MultisigApprove.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MultisigInstructionBox.Approve): Unit = + try { + MultisigApprove.write(writer, instance.multisigApprove) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): MultisigInstructionBox = when (val discriminant = reader.readUByte()) { + 0 -> Register.read(reader) + 1 -> Propose.read(reader) + 2 -> Approve.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: MultisigInstructionBox) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Register.write(writer, instance as Register) + 1 -> Propose.write(writer, instance as Propose) + 2 -> Approve.write(writer, instance as Approve) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigProposalValue.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigProposalValue.kt new file mode 100644 index 000000000..33211008a --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigProposalValue.kt @@ -0,0 +1,61 @@ +// +// 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.codec.reader.BoolReader +import jp.co.soramitsu.iroha2.codec.writer.BoolWriter +import jp.co.soramitsu.iroha2.comparator +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Boolean +import kotlin.Unit +import kotlin.collections.List + +/** + * MultisigProposalValue + * + * Generated from 'MultisigProposalValue' regular structure + */ +public data class MultisigProposalValue( + public val instructions: List, + public val proposedAtMs: NonZeroOfu64, + public val expiresAtMs: NonZeroOfu64, + public val approvals: List, + public val isRelayed: Boolean? = null, +) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): MultisigProposalValue = try { + MultisigProposalValue( + reader.readVec(reader.readCompactInt()) { InstructionBox.read(reader) }, + NonZeroOfu64.read(reader), + NonZeroOfu64.read(reader), + reader.readVec(reader.readCompactInt()) { AccountId.read(reader) }, + reader.readNullable(BoolReader()), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: MultisigProposalValue): Unit = try { + writer.writeCompact(instance.instructions.size) + instance.instructions.forEach { value -> + InstructionBox.write(writer, value) + } + NonZeroOfu64.write(writer, instance.proposedAtMs) + NonZeroOfu64.write(writer, instance.expiresAtMs) + writer.writeCompact(instance.approvals.size) + instance.approvals.sortedWith( + AccountId.comparator(), + ).forEach { value -> + AccountId.write(writer, value) + } + writer.writeNullable(BoolWriter(), instance.isRelayed) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigPropose.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigPropose.kt new file mode 100644 index 000000000..cdc423233 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigPropose.kt @@ -0,0 +1,47 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelCustomInstruction +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 +import kotlin.collections.List + +/** + * MultisigPropose + * + * Generated from 'MultisigPropose' regular structure + */ +public data class MultisigPropose( + public val account: AccountId, + public val instructions: List, + public val transactionTtlMs: NonZeroOfu64? = null, +) : ModelCustomInstruction { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): MultisigPropose = try { + MultisigPropose( + AccountId.read(reader), + reader.readVec(reader.readCompactInt()) { InstructionBox.read(reader) }, + reader.readNullable(NonZeroOfu64) as NonZeroOfu64?, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: MultisigPropose): Unit = try { + AccountId.write(writer, instance.account) + writer.writeCompact(instance.instructions.size) + instance.instructions.forEach { value -> + InstructionBox.write(writer, value) + } + writer.writeNullable(NonZeroOfu64, instance.transactionTtlMs) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigRegister.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigRegister.kt new file mode 100644 index 000000000..d82a833b1 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigRegister.kt @@ -0,0 +1,37 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelCustomInstruction +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 + +/** + * MultisigRegister + * + * Generated from 'MultisigRegister' regular structure + */ +public data class MultisigRegister(public val account: AccountId, public val spec: MultisigSpec) : ModelCustomInstruction { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): MultisigRegister = try { + MultisigRegister( + AccountId.read(reader), + MultisigSpec.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: MultisigRegister): Unit = try { + AccountId.write(writer, instance.account) + MultisigSpec.write(writer, instance.spec) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigSpec.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigSpec.kt new file mode 100644 index 000000000..6f551f421 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigSpec.kt @@ -0,0 +1,51 @@ +// +// 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.comparator +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Short +import kotlin.Unit +import kotlin.collections.Map + +/** + * MultisigSpec + * + * Generated from 'MultisigSpec' regular structure + */ +public data class MultisigSpec( + public val signatories: Map, + public val quorum: NonZeroOfu16, + public val transactionTtlMs: NonZeroOfu64, +) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): MultisigSpec = try { + MultisigSpec( + reader.readMap(reader.readCompactInt(), { AccountId.read(reader) }, { reader.readUByte().toShort() }), + NonZeroOfu16.read(reader), + NonZeroOfu64.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: MultisigSpec): Unit = try { + writer.writeCompact(instance.signatories.size) + instance.signatories.toSortedMap( + AccountId.comparator(), + ).forEach { (key, value) -> + AccountId.write(writer, key) + writer.writeUByte(value) + } + NonZeroOfu16.write(writer, instance.quorum) + NonZeroOfu64.write(writer, instance.transactionTtlMs) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigTransactionArgs.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigTransactionArgs.kt new file mode 100644 index 000000000..74abd063b --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigTransactionArgs.kt @@ -0,0 +1,111 @@ +// +// 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 +import kotlin.collections.List + +/** + * MultisigTransactionArgs + * + * Generated from 'MultisigTransactionArgs' enum + */ +public sealed class MultisigTransactionArgs : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Propose' variant + */ + public data class Propose(public val vec: List) : MultisigTransactionArgs() { + 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.MultisigTransactionArgs.Propose = try { + Propose( + reader.readVec(reader.readCompactInt()) { InstructionBox.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.MultisigTransactionArgs.Propose, + ): Unit = try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + InstructionBox.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Approve' variant + */ + public data class Approve(public val hashOf: HashOf>) : MultisigTransactionArgs() { + 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.MultisigTransactionArgs.Approve = try { + Approve( + HashOf.read(reader) as HashOf>, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.MultisigTransactionArgs.Approve, + ): Unit = try { + HashOf.write(writer, instance.hashOf) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): MultisigTransactionArgs = when ( + val discriminant = + reader.readUByte() + ) { + 0 -> Propose.read(reader) + 1 -> Approve.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: MultisigTransactionArgs) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Propose.write(writer, instance as Propose) + 1 -> Approve.write(writer, instance as Approve) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Name.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Name.kt index 2798439ce..d6096b969 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Name.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Name.kt @@ -16,9 +16,7 @@ import kotlin.Unit * * Generated from 'Name' regular structure */ -public data class Name( - public val string: String, -) { +public data class Name(public val string: String) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Name = try { Name( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NameProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NameProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..420f0c2dd --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NameProjectionOfPredicateMarker.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 + +/** + * NameProjectionOfPredicateMarker + * + * Generated from 'NameProjectionOfPredicateMarker' enum + */ +public sealed class NameProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val stringPredicateAtom: StringPredicateAtom) : NameProjectionOfPredicateMarker() { + 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.NameProjectionOfPredicateMarker.Atom = try { + Atom( + StringPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.NameProjectionOfPredicateMarker.Atom, + ): Unit = try { + StringPredicateAtom.write(writer, instance.stringPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): NameProjectionOfPredicateMarker = 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: NameProjectionOfPredicateMarker) { + 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/NameProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NameProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..1f2194ed1 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NameProjectionOfSelectorMarker.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 + +/** + * NameProjectionOfSelectorMarker + * + * Generated from 'NameProjectionOfSelectorMarker' enum + */ +public sealed class NameProjectionOfSelectorMarker : 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 : NameProjectionOfSelectorMarker() { + 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.NameProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.NameProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.NameProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".NameProjectionOfSelectorMarker.Atom".hashCode() + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): NameProjectionOfSelectorMarker = 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: NameProjectionOfSelectorMarker) { + 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/NewAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewAccount.kt index 048a59580..d618e8cd2 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewAccount.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'NewAccount' regular structure */ -public data class NewAccount( - public val id: AccountId, - public val metadata: Metadata, -) { +public data class NewAccount(public val id: AccountId, public val metadata: Metadata) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): NewAccount = try { NewAccount( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountById.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewRole.kt similarity index 52% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountById.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewRole.kt index 684034e0a..f4da53e97 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountById.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewRole.kt @@ -11,24 +11,24 @@ import jp.co.soramitsu.iroha2.wrapException import kotlin.Unit /** - * FindAccountById + * NewRole * - * Generated from 'FindAccountById' regular structure + * Generated from 'NewRole' regular structure */ -public data class FindAccountById( - public val id: AccountId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAccountById = try { - FindAccountById( +public data class NewRole(public val `inner`: Role, public val grantTo: AccountId) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): NewRole = try { + NewRole( + Role.read(reader), AccountId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: FindAccountById): Unit = try { - AccountId.write(writer, instance.id) + override fun write(writer: ScaleCodecWriter, instance: NewRole): Unit = try { + Role.write(writer, instance.`inner`) + AccountId.write(writer, instance.grantTo) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonTrivial.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonTrivial.kt deleted file mode 100644 index 29e2e976d..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonTrivial.kt +++ /dev/null @@ -1,44 +0,0 @@ -// -// 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.Any -import kotlin.Unit -import kotlin.collections.List - -/** - * NonTrivial - * - * Generated from 'NonTrivial>' regular structure - */ -public data class NonTrivial( - public val vecOfQueryOutputPredicate: List>, -) { - public companion object : ScaleReader>, ScaleWriter> { - override fun read(reader: ScaleCodecReader): NonTrivial = try { - NonTrivial( - reader.readVec(reader.readCompactInt()) { - GenericPredicateBox.read(reader) as - GenericPredicateBox - }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: NonTrivial): Unit = try { - writer.writeCompact(instance.vecOfQueryOutputPredicate.size) - instance.vecOfQueryOutputPredicate.forEach { value -> - GenericPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomainById.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu16.kt similarity index 51% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomainById.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu16.kt index f2043fecb..11ce7a96f 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomainById.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu16.kt @@ -8,27 +8,26 @@ 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 /** - * FindDomainById + * NonZeroOfu16 * - * Generated from 'FindDomainById' regular structure + * Generated from 'NonZeroOfu16' regular structure */ -public data class FindDomainById( - public val id: DomainId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindDomainById = try { - FindDomainById( - DomainId.read(reader), +public data class NonZeroOfu16(public val u16: Int) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): NonZeroOfu16 = try { + NonZeroOfu16( + reader.readUint16(), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: FindDomainById): Unit = try { - DomainId.write(writer, instance.id) + override fun write(writer: ScaleCodecWriter, instance: NonZeroOfu16): Unit = try { + writer.writeUint16(instance.u16) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu32.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu32.kt index 986c92f85..56f7ebefd 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu32.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu32.kt @@ -16,9 +16,7 @@ import kotlin.Unit * * Generated from 'NonZeroOfu32' regular structure */ -public data class NonZeroOfu32( - public val u32: Long, -) { +public data class NonZeroOfu32(public val u32: Long) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): NonZeroOfu32 = try { NonZeroOfu32( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu64.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu64.kt index b397f7460..bb00a3ef2 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu64.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu64.kt @@ -16,9 +16,7 @@ import kotlin.Unit * * Generated from 'NonZeroOfu64' regular structure */ -public data class NonZeroOfu64( - public val u64: BigInteger, -) { +public data class NonZeroOfu64(public val u64: BigInteger) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): NonZeroOfu64 = try { NonZeroOfu64( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Numeric.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Numeric.kt index 20b5baa41..9149a5c03 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Numeric.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Numeric.kt @@ -19,10 +19,7 @@ import kotlin.Unit * * Generated from 'Numeric' regular structure */ -public data class Numeric( - public val mantissa: BigInteger, - public val scale: Long, -) { +public data class Numeric(public val mantissa: BigInteger, public val scale: Long) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Numeric = try { Numeric( 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/NumericSpec.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericSpec.kt index 257bb0c76..0c4ac33a3 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericSpec.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericSpec.kt @@ -16,9 +16,7 @@ import kotlin.Unit * * Generated from 'NumericSpec' regular structure */ -public data class NumericSpec( - public val scale: Long? = null, -) { +public data class NumericSpec(public val scale: Long? = null) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): NumericSpec = try { NumericSpec( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Pagination.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Pagination.kt index cf62e6c1f..e9b2163dc 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Pagination.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Pagination.kt @@ -8,6 +8,7 @@ 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 java.math.BigInteger import kotlin.Unit /** @@ -15,23 +16,20 @@ import kotlin.Unit * * Generated from 'Pagination' regular structure */ -public data class Pagination( - public val limit: NonZeroOfu32? = null, - public val start: NonZeroOfu64? = null, -) { +public data class Pagination(public val limit: NonZeroOfu64? = null, public val offset: BigInteger) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Pagination = try { Pagination( - reader.readNullable(NonZeroOfu32) as NonZeroOfu32?, reader.readNullable(NonZeroOfu64) as NonZeroOfu64?, + reader.readUint64(), ) } catch (ex: Exception) { throw wrapException(ex) } override fun write(writer: ScaleCodecWriter, instance: Pagination): Unit = try { - writer.writeNullable(NonZeroOfu32, instance.limit) - writer.writeNullable(NonZeroOfu64, instance.start) + writer.writeNullable(NonZeroOfu64, instance.limit) + writer.writeUint64(instance.offset) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Parameter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Parameter.kt index 5147fa1bf..f726dc74c 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Parameter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Parameter.kt @@ -26,9 +26,7 @@ public sealed class Parameter : ModelEnum { /** * 'Sumeragi' variant */ - public data class Sumeragi( - public val sumeragiParameter: SumeragiParameter, - ) : Parameter() { + public data class Sumeragi(public val sumeragiParameter: SumeragiParameter) : Parameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class Parameter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Parameter.Sumeragi, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Parameter.Sumeragi): Unit = try { SumeragiParameter.write(writer, instance.sumeragiParameter) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class Parameter : ModelEnum { /** * 'Block' variant */ - public data class Block( - public val blockParameter: BlockParameter, - ) : Parameter() { + public data class Block(public val blockParameter: BlockParameter) : Parameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class Parameter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Parameter.Block, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Parameter.Block): Unit = try { BlockParameter.write(writer, instance.blockParameter) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class Parameter : ModelEnum { /** * 'Transaction' variant */ - public data class Transaction( - public val transactionParameter: TransactionParameter, - ) : Parameter() { + public data class Transaction(public val transactionParameter: TransactionParameter) : Parameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,10 +96,7 @@ public sealed class Parameter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Parameter.Transaction, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Parameter.Transaction): Unit = try { TransactionParameter.write(writer, instance.transactionParameter) } catch (ex: Exception) { throw wrapException(ex) @@ -122,9 +107,7 @@ public sealed class Parameter : ModelEnum { /** * 'SmartContract' variant */ - public data class SmartContract( - public val smartContractParameter: SmartContractParameter, - ) : Parameter() { + public data class SmartContract(public val smartContractParameter: SmartContractParameter) : Parameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,10 +123,7 @@ public sealed class Parameter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Parameter.SmartContract, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Parameter.SmartContract): Unit = try { SmartContractParameter.write(writer, instance.smartContractParameter) } catch (ex: Exception) { throw wrapException(ex) @@ -154,9 +134,7 @@ public sealed class Parameter : ModelEnum { /** * 'Executor' variant */ - public data class Executor( - public val smartContractParameter: SmartContractParameter, - ) : Parameter() { + public data class Executor(public val smartContractParameter: SmartContractParameter) : Parameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -172,10 +150,7 @@ public sealed class Parameter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Parameter.Executor, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Parameter.Executor): Unit = try { SmartContractParameter.write(writer, instance.smartContractParameter) } catch (ex: Exception) { throw wrapException(ex) @@ -186,9 +161,7 @@ public sealed class Parameter : ModelEnum { /** * 'Custom' variant */ - public data class Custom( - public val customParameter: CustomParameter, - ) : Parameter() { + public data class Custom(public val customParameter: CustomParameter) : Parameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -204,10 +177,7 @@ public sealed class Parameter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Parameter.Custom, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Parameter.Custom): Unit = try { CustomParameter.write(writer, instance.customParameter) } catch (ex: Exception) { throw wrapException(ex) @@ -216,17 +186,15 @@ public sealed class Parameter : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Parameter = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): Parameter = when (val discriminant = reader.readUByte()) { 0 -> Sumeragi.read(reader) 1 -> Block.read(reader) 2 -> Transaction.read(reader) 3 -> SmartContract.read(reader) 4 -> Executor.read(reader) 5 -> Custom.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: Parameter) { writer.directWrite(instance.discriminant()) @@ -237,7 +205,8 @@ public sealed class Parameter : ModelEnum { 3 -> SmartContract.write(writer, instance as SmartContract) 4 -> Executor.write(writer, instance as Executor) 5 -> Custom.write(writer, instance as Custom) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ParameterChanged.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ParameterChanged.kt index ae97fda88..d92594838 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ParameterChanged.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ParameterChanged.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'ParameterChanged' regular structure */ -public data class ParameterChanged( - public val oldValue: Parameter, - public val newValue: Parameter, -) { +public data class ParameterChanged(public val oldValue: Parameter, public val newValue: Parameter) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): ParameterChanged = try { ParameterChanged( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Parameters.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Parameters.kt index 30c7f5a03..b6feb4cf3 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Parameters.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Parameters.kt @@ -33,11 +33,7 @@ public data class Parameters( TransactionParameters.read(reader), SmartContractParameters.read(reader), SmartContractParameters.read(reader), - reader.readMap( - reader.readCompactInt(), - { CustomParameterId.read(reader) }, - { CustomParameter.read(reader) }, - ), + reader.readMap(reader.readCompactInt(), { CustomParameterId.read(reader) }, { CustomParameter.read(reader) }), ) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Peer.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Peer.kt index 9416e6de0..2d58c275c 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Peer.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Peer.kt @@ -15,12 +15,11 @@ import kotlin.Unit * * Generated from 'Peer' regular structure */ -public data class Peer( - public val id: PeerId, -) { +public data class Peer(public val address: SocketAddr, public val id: PeerId) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Peer = try { Peer( + SocketAddr.read(reader), PeerId.read(reader), ) } catch (ex: Exception) { @@ -28,6 +27,7 @@ public data class Peer( } override fun write(writer: ScaleCodecWriter, instance: Peer): Unit = try { + SocketAddr.write(writer, instance.address) PeerId.write(writer, instance.id) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerEvent.kt index f9e262fc7..54759f0f6 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerEvent.kt @@ -26,9 +26,7 @@ public sealed class PeerEvent : ModelEnum { /** * 'Added' variant */ - public data class Added( - public val peerId: PeerId, - ) : PeerEvent() { + public data class Added(public val peerId: PeerId) : PeerEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class PeerEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.PeerEvent.Added, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.PeerEvent.Added): Unit = try { PeerId.write(writer, instance.peerId) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class PeerEvent : ModelEnum { /** * 'Removed' variant */ - public data class Removed( - public val peerId: PeerId, - ) : PeerEvent() { + public data class Removed(public val peerId: PeerId) : PeerEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class PeerEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.PeerEvent.Removed, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.PeerEvent.Removed): Unit = try { PeerId.write(writer, instance.peerId) } catch (ex: Exception) { throw wrapException(ex) @@ -88,20 +78,19 @@ public sealed class PeerEvent : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): PeerEvent = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): PeerEvent = when (val discriminant = reader.readUByte()) { 0 -> Added.read(reader) 1 -> Removed.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: PeerEvent) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Added.write(writer, instance as Added) 1 -> Removed.write(writer, instance as Removed) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerEventFilter.kt index 6d56f9e64..d0a80a443 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerEventFilter.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'PeerEventFilter' regular structure */ -public data class PeerEventFilter( - public val idMatcher: PeerId? = null, - public val eventSet: Long, -) { +public data class PeerEventFilter(public val idMatcher: PeerId? = null, public val eventSet: Long) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): PeerEventFilter = try { PeerEventFilter( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerId.kt index 05f994f5d..a37e9a4e3 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerId.kt @@ -15,14 +15,10 @@ import kotlin.Unit * * Generated from 'PeerId' regular structure */ -public data class PeerId( - public val address: SocketAddr, - public val publicKey: PublicKey, -) { +public data class PeerId(public val publicKey: PublicKey) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): PeerId = try { PeerId( - SocketAddr.read(reader), PublicKey.read(reader), ) } catch (ex: Exception) { @@ -30,7 +26,6 @@ public data class PeerId( } override fun write(writer: ScaleCodecWriter, instance: PeerId): Unit = try { - SocketAddr.write(writer, instance.address) PublicKey.write(writer, instance.publicKey) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdPredicateAtom.kt similarity index 62% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdPredicateAtom.kt index e3e35d08d..e1e0ed44e 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdPredicateAtom.kt @@ -11,27 +11,26 @@ import jp.co.soramitsu.iroha2.codec.ScaleWriter import kotlin.Int /** - * PeerPredicateBox + * PeerIdPredicateAtom * - * Generated from 'PeerPredicateBox' enum + * Generated from 'PeerIdPredicateAtom' enum */ -public sealed class PeerPredicateBox : ModelEnum { +public sealed class PeerIdPredicateAtom : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): PeerPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): PeerIdPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: PeerPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: PeerIdPredicateAtom) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..7d2501eb7 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdProjectionOfPredicateMarker.kt @@ -0,0 +1,106 @@ +// +// 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 + +/** + * PeerIdProjectionOfPredicateMarker + * + * Generated from 'PeerIdProjectionOfPredicateMarker' enum + */ +public sealed class PeerIdProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val peerIdPredicateAtom: PeerIdPredicateAtom) : PeerIdProjectionOfPredicateMarker() { + 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.PeerIdProjectionOfPredicateMarker.Atom = try { + Atom( + PeerIdPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.PeerIdProjectionOfPredicateMarker.Atom, + ): Unit = try { + PeerIdPredicateAtom.write(writer, instance.peerIdPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'PublicKey' variant + */ + public data class PublicKey(public val publicKeyProjectionOfPredicateMarker: PublicKeyProjectionOfPredicateMarker) : + PeerIdProjectionOfPredicateMarker() { + 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.PeerIdProjectionOfPredicateMarker.PublicKey = + try { + PublicKey( + PublicKeyProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.PeerIdProjectionOfPredicateMarker.PublicKey, + ): Unit = try { + PublicKeyProjectionOfPredicateMarker.write(writer, instance.publicKeyProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): PeerIdProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> PublicKey.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: PeerIdProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> PublicKey.write(writer, instance as PublicKey) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..793dd0eb6 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdProjectionOfSelectorMarker.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 + +/** + * PeerIdProjectionOfSelectorMarker + * + * Generated from 'PeerIdProjectionOfSelectorMarker' enum + */ +public sealed class PeerIdProjectionOfSelectorMarker : 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 : PeerIdProjectionOfSelectorMarker() { + 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.PeerIdProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.PeerIdProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.PeerIdProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".PeerIdProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'PublicKey' variant + */ + public data class PublicKey(public val publicKeyProjectionOfSelectorMarker: PublicKeyProjectionOfSelectorMarker) : + PeerIdProjectionOfSelectorMarker() { + 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.PeerIdProjectionOfSelectorMarker.PublicKey = try { + PublicKey( + PublicKeyProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.PeerIdProjectionOfSelectorMarker.PublicKey, + ): Unit = try { + PublicKeyProjectionOfSelectorMarker.write(writer, instance.publicKeyProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): PeerIdProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> PublicKey.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: PeerIdProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> PublicKey.write(writer, instance as PublicKey) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Permission.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Permission.kt index 4fd9a4e3c..f00bd6aef 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Permission.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Permission.kt @@ -16,15 +16,12 @@ import kotlin.Unit * * Generated from 'Permission' regular structure */ -public data class Permission( - public val name: String, - public val payload: String, -) { +public data class Permission(public val name: String, public val payload: Json) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Permission = try { Permission( reader.readString(), - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -32,7 +29,7 @@ public data class Permission( override fun write(writer: ScaleCodecWriter, instance: Permission): Unit = try { writer.writeAsList(instance.name.toByteArray(Charsets.UTF_8)) - writer.writeAsList(instance.payload.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.payload) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionPredicateAtom.kt similarity index 65% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionPredicateAtom.kt index 993954fde..af1bd9911 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionPredicateAtom.kt @@ -11,27 +11,28 @@ import jp.co.soramitsu.iroha2.codec.ScaleWriter import kotlin.Int /** - * PermissionPredicateBox + * PermissionPredicateAtom * - * Generated from 'PermissionPredicateBox' enum + * Generated from 'PermissionPredicateAtom' enum */ -public sealed class PermissionPredicateBox : ModelEnum { +public sealed class PermissionPredicateAtom : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): PermissionPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): PermissionPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: PermissionPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: PermissionPredicateAtom) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..e8524f2c4 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionProjectionOfPredicateMarker.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 + +/** + * PermissionProjectionOfPredicateMarker + * + * Generated from 'PermissionProjectionOfPredicateMarker' enum + */ +public sealed class PermissionProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val permissionPredicateAtom: PermissionPredicateAtom) : PermissionProjectionOfPredicateMarker() { + 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.PermissionProjectionOfPredicateMarker.Atom = try { + Atom( + PermissionPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.PermissionProjectionOfPredicateMarker.Atom, + ): Unit = try { + PermissionPredicateAtom.write(writer, instance.permissionPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): PermissionProjectionOfPredicateMarker = 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: PermissionProjectionOfPredicateMarker) { + 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/PermissionProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..65ead550c --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionProjectionOfSelectorMarker.kt @@ -0,0 +1,89 @@ +// +// 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 + +/** + * PermissionProjectionOfSelectorMarker + * + * Generated from 'PermissionProjectionOfSelectorMarker' enum + */ +public sealed class PermissionProjectionOfSelectorMarker : 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 : PermissionProjectionOfSelectorMarker() { + 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.PermissionProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.PermissionProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.PermissionProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".PermissionProjectionOfSelectorMarker.Atom".hashCode() + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): PermissionProjectionOfSelectorMarker = 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: PermissionProjectionOfSelectorMarker) { + 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/PipelineEventBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PipelineEventBox.kt index 2b02650d1..f4cf9c3ee 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PipelineEventBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PipelineEventBox.kt @@ -26,9 +26,7 @@ public sealed class PipelineEventBox : ModelEnum { /** * 'Transaction' variant */ - public data class Transaction( - public val transactionEvent: TransactionEvent, - ) : PipelineEventBox() { + public data class Transaction(public val transactionEvent: TransactionEvent) : PipelineEventBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,23 +42,19 @@ public sealed class PipelineEventBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.PipelineEventBox.Transaction, - ): Unit = try { - TransactionEvent.write(writer, instance.transactionEvent) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.PipelineEventBox.Transaction): Unit = + try { + TransactionEvent.write(writer, instance.transactionEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Block' variant */ - public data class Block( - public val blockEvent: BlockEvent, - ) : PipelineEventBox() { + public data class Block(public val blockEvent: BlockEvent) : PipelineEventBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +70,7 @@ public sealed class PipelineEventBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.PipelineEventBox.Block, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.PipelineEventBox.Block): Unit = try { BlockEvent.write(writer, instance.blockEvent) } catch (ex: Exception) { throw wrapException(ex) @@ -88,20 +79,19 @@ public sealed class PipelineEventBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): PipelineEventBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): PipelineEventBox = when (val discriminant = reader.readUByte()) { 0 -> Transaction.read(reader) 1 -> Block.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: PipelineEventBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Transaction.write(writer, instance as Transaction) 1 -> Block.write(writer, instance as Block) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PipelineEventFilterBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PipelineEventFilterBox.kt index 6d6b170ec..5664a7e6d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PipelineEventFilterBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PipelineEventFilterBox.kt @@ -26,9 +26,7 @@ public sealed class PipelineEventFilterBox : ModelEnum { /** * 'Transaction' variant */ - public data class Transaction( - public val transactionEventFilter: TransactionEventFilter, - ) : PipelineEventFilterBox() { + public data class Transaction(public val transactionEventFilter: TransactionEventFilter) : PipelineEventFilterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -58,9 +56,7 @@ public sealed class PipelineEventFilterBox : ModelEnum { /** * 'Block' variant */ - public data class Block( - public val blockEventFilter: BlockEventFilter, - ) : PipelineEventFilterBox() { + public data class Block(public val blockEventFilter: BlockEventFilter) : PipelineEventFilterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,32 +72,31 @@ public sealed class PipelineEventFilterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.PipelineEventFilterBox.Block, - ): Unit = try { - BlockEventFilter.write(writer, instance.blockEventFilter) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.PipelineEventFilterBox.Block): Unit = + try { + BlockEventFilter.write(writer, instance.blockEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): PipelineEventFilterBox = when ( - val discriminant = - reader.readUByte() - ) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): PipelineEventFilterBox = when (val discriminant = reader.readUByte()) { 0 -> Transaction.read(reader) 1 -> Block.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: PipelineEventFilterBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Transaction.write(writer, instance as Transaction) 1 -> Block.write(writer, instance as Block) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKey.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKey.kt index 56b6b44b2..b58230514 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKey.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKey.kt @@ -19,10 +19,7 @@ import kotlin.Unit * * Generated from 'PublicKey' regular structure */ -public data class PublicKey( - public val algorithm: Algorithm, - public val payload: ByteArray, -) { +public data class PublicKey(public val algorithm: Algorithm, public val payload: ByteArray) { override fun equals(other: Any?): Boolean { if (this === other) return true if (other !is PublicKey) return false diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyPredicateAtom.kt similarity index 61% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyPredicateAtom.kt index 9ae7921f2..b810a1b5c 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyPredicateAtom.kt @@ -13,11 +13,11 @@ import kotlin.Int import kotlin.Unit /** - * PublicKeyPredicateBox + * PublicKeyPredicateAtom * - * Generated from 'PublicKeyPredicateBox' enum + * Generated from 'PublicKeyPredicateAtom' enum */ -public sealed class PublicKeyPredicateBox : ModelEnum { +public sealed class PublicKeyPredicateAtom : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -26,17 +26,15 @@ public sealed class PublicKeyPredicateBox : ModelEnum { /** * 'Equals' variant */ - public data class Equals( - public val publicKey: PublicKey, - ) : PublicKeyPredicateBox() { + public data class Equals(public val publicKey: PublicKey) : PublicKeyPredicateAtom() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PublicKeyPredicateBox.Equals = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PublicKeyPredicateAtom.Equals = try { Equals( PublicKey.read(reader), ) @@ -44,30 +42,29 @@ public sealed class PublicKeyPredicateBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.PublicKeyPredicateBox.Equals, - ): Unit = try { - PublicKey.write(writer, instance.publicKey) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.PublicKeyPredicateAtom.Equals): Unit = + try { + PublicKey.write(writer, instance.publicKey) + } catch (ex: Exception) { + throw wrapException(ex) + } } } - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): PublicKeyPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): PublicKeyPredicateAtom = when (val discriminant = reader.readUByte()) { 0 -> Equals.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: PublicKeyPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: PublicKeyPredicateAtom) { 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") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..f2b350e72 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyProjectionOfPredicateMarker.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 + +/** + * PublicKeyProjectionOfPredicateMarker + * + * Generated from 'PublicKeyProjectionOfPredicateMarker' enum + */ +public sealed class PublicKeyProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val publicKeyPredicateAtom: PublicKeyPredicateAtom) : PublicKeyProjectionOfPredicateMarker() { + 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.PublicKeyProjectionOfPredicateMarker.Atom = try { + Atom( + PublicKeyPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.PublicKeyProjectionOfPredicateMarker.Atom, + ): Unit = try { + PublicKeyPredicateAtom.write(writer, instance.publicKeyPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): PublicKeyProjectionOfPredicateMarker = 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: PublicKeyProjectionOfPredicateMarker) { + 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/PublicKeyProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..9fe1e73f8 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyProjectionOfSelectorMarker.kt @@ -0,0 +1,89 @@ +// +// 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 + +/** + * PublicKeyProjectionOfSelectorMarker + * + * Generated from 'PublicKeyProjectionOfSelectorMarker' enum + */ +public sealed class PublicKeyProjectionOfSelectorMarker : 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 : PublicKeyProjectionOfSelectorMarker() { + 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.PublicKeyProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.PublicKeyProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.PublicKeyProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".PublicKeyProjectionOfSelectorMarker.Atom".hashCode() + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): PublicKeyProjectionOfSelectorMarker = 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: PublicKeyProjectionOfSelectorMarker) { + 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/QueryBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryBox.kt index 75343e0a7..39dc2e4bd 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryBox.kt @@ -24,756 +24,26 @@ public sealed class QueryBox : ModelEnum { public abstract fun discriminant(): Int /** - * 'FindAllAccounts' variant + * 'FindDomains' variant */ - public data class FindAllAccounts( - public val findAllAccounts: jp.co.soramitsu.iroha2.generated.FindAllAccounts, - ) : QueryBox() { - 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.QueryBox.FindAllAccounts = try { - FindAllAccounts( - jp.co.soramitsu.iroha2.generated.FindAllAccounts.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAllAccounts, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllAccounts.write(writer, instance.findAllAccounts) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAccountById' variant - */ - public data class FindAccountById( - public val findAccountById: jp.co.soramitsu.iroha2.generated.FindAccountById, - ) : QueryBox() { - 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.QueryBox.FindAccountById = try { - FindAccountById( - jp.co.soramitsu.iroha2.generated.FindAccountById.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAccountById, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAccountById.write(writer, instance.findAccountById) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAccountKeyValueByIdAndKey' variant - */ - public data class FindAccountKeyValueByIdAndKey( - public val findAccountKeyValueByIdAndKey: - jp.co.soramitsu.iroha2.generated.FindAccountKeyValueByIdAndKey, - ) : QueryBox() { - 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.QueryBox.FindAccountKeyValueByIdAndKey = try { - FindAccountKeyValueByIdAndKey( - jp.co.soramitsu.iroha2.generated.FindAccountKeyValueByIdAndKey.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAccountKeyValueByIdAndKey, - ): Unit = - try { - jp.co.soramitsu.iroha2.generated.FindAccountKeyValueByIdAndKey.write( - writer, - instance.findAccountKeyValueByIdAndKey, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAccountsByDomainId' variant - */ - public data class FindAccountsByDomainId( - public val findAccountsByDomainId: jp.co.soramitsu.iroha2.generated.FindAccountsByDomainId, - ) : QueryBox() { - 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.QueryBox.FindAccountsByDomainId = try { - FindAccountsByDomainId( - jp.co.soramitsu.iroha2.generated.FindAccountsByDomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAccountsByDomainId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAccountsByDomainId.write( - writer, - instance.findAccountsByDomainId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAccountsWithAsset' variant - */ - public data class FindAccountsWithAsset( - public val findAccountsWithAsset: jp.co.soramitsu.iroha2.generated.FindAccountsWithAsset, - ) : QueryBox() { - 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.QueryBox.FindAccountsWithAsset = try { - FindAccountsWithAsset( - jp.co.soramitsu.iroha2.generated.FindAccountsWithAsset.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAccountsWithAsset, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAccountsWithAsset.write( - writer, - instance.findAccountsWithAsset, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAllAssets' variant - */ - public data class FindAllAssets( - public val findAllAssets: jp.co.soramitsu.iroha2.generated.FindAllAssets, - ) : QueryBox() { - 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.QueryBox.FindAllAssets = try { - FindAllAssets( - jp.co.soramitsu.iroha2.generated.FindAllAssets.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAllAssets, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllAssets.write(writer, instance.findAllAssets) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAllAssetsDefinitions' variant - */ - public data class FindAllAssetsDefinitions( - public val findAllAssetsDefinitions: jp.co.soramitsu.iroha2.generated.FindAllAssetsDefinitions, - ) : QueryBox() { - 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.QueryBox.FindAllAssetsDefinitions = try { - FindAllAssetsDefinitions( - jp.co.soramitsu.iroha2.generated.FindAllAssetsDefinitions.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAllAssetsDefinitions, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllAssetsDefinitions.write( - writer, - instance.findAllAssetsDefinitions, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAssetById' variant - */ - public data class FindAssetById( - public val findAssetById: jp.co.soramitsu.iroha2.generated.FindAssetById, - ) : QueryBox() { - 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.QueryBox.FindAssetById = try { - FindAssetById( - jp.co.soramitsu.iroha2.generated.FindAssetById.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetById, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetById.write(writer, instance.findAssetById) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAssetDefinitionById' variant - */ - public data class FindAssetDefinitionById( - public val findAssetDefinitionById: jp.co.soramitsu.iroha2.generated.FindAssetDefinitionById, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 8 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetDefinitionById = try { - FindAssetDefinitionById( - jp.co.soramitsu.iroha2.generated.FindAssetDefinitionById.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetDefinitionById, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetDefinitionById.write( - writer, - instance.findAssetDefinitionById, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAssetsByName' variant - */ - public data class FindAssetsByName( - public val findAssetsByName: jp.co.soramitsu.iroha2.generated.FindAssetsByName, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 9 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsByName = try { - FindAssetsByName( - jp.co.soramitsu.iroha2.generated.FindAssetsByName.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsByName, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetsByName.write(writer, instance.findAssetsByName) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAssetsByAccountId' variant - */ - public data class FindAssetsByAccountId( - public val findAssetsByAccountId: jp.co.soramitsu.iroha2.generated.FindAssetsByAccountId, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 10 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsByAccountId = try { - FindAssetsByAccountId( - jp.co.soramitsu.iroha2.generated.FindAssetsByAccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsByAccountId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetsByAccountId.write( - writer, - instance.findAssetsByAccountId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAssetsByAssetDefinitionId' variant - */ - public data class FindAssetsByAssetDefinitionId( - public val findAssetsByAssetDefinitionId: - jp.co.soramitsu.iroha2.generated.FindAssetsByAssetDefinitionId, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 11 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsByAssetDefinitionId = try { - FindAssetsByAssetDefinitionId( - jp.co.soramitsu.iroha2.generated.FindAssetsByAssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsByAssetDefinitionId, - ): Unit = - try { - jp.co.soramitsu.iroha2.generated.FindAssetsByAssetDefinitionId.write( - writer, - instance.findAssetsByAssetDefinitionId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAssetsByDomainId' variant - */ - public data class FindAssetsByDomainId( - public val findAssetsByDomainId: jp.co.soramitsu.iroha2.generated.FindAssetsByDomainId, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 12 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsByDomainId = try { - FindAssetsByDomainId( - jp.co.soramitsu.iroha2.generated.FindAssetsByDomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsByDomainId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetsByDomainId.write( - writer, - instance.findAssetsByDomainId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAssetsByDomainIdAndAssetDefinitionId' variant - */ - public data class FindAssetsByDomainIdAndAssetDefinitionId( - public val findAssetsByDomainIdAndAssetDefinitionId: - jp.co.soramitsu.iroha2.generated.FindAssetsByDomainIdAndAssetDefinitionId, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 13 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsByDomainIdAndAssetDefinitionId = try { - FindAssetsByDomainIdAndAssetDefinitionId( - jp.co.soramitsu.iroha2.generated.FindAssetsByDomainIdAndAssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsByDomainIdAndAssetDefinitionId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetsByDomainIdAndAssetDefinitionId.write( - writer, - instance.findAssetsByDomainIdAndAssetDefinitionId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAssetQuantityById' variant - */ - public data class FindAssetQuantityById( - public val findAssetQuantityById: jp.co.soramitsu.iroha2.generated.FindAssetQuantityById, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 14 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.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.QueryBox.FindAssetQuantityById, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetQuantityById.write( - writer, - instance.findAssetQuantityById, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindTotalAssetQuantityByAssetDefinitionId' variant - */ - public data class FindTotalAssetQuantityByAssetDefinitionId( - public val findTotalAssetQuantityByAssetDefinitionId: - jp.co.soramitsu.iroha2.generated.FindTotalAssetQuantityByAssetDefinitionId, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 15 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindTotalAssetQuantityByAssetDefinitionId = try { - FindTotalAssetQuantityByAssetDefinitionId( - jp.co.soramitsu.iroha2.generated.FindTotalAssetQuantityByAssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindTotalAssetQuantityByAssetDefinitionId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindTotalAssetQuantityByAssetDefinitionId.write( - writer, - instance.findTotalAssetQuantityByAssetDefinitionId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAssetKeyValueByIdAndKey' variant - */ - public data class FindAssetKeyValueByIdAndKey( - public val findAssetKeyValueByIdAndKey: - jp.co.soramitsu.iroha2.generated.FindAssetKeyValueByIdAndKey, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 16 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetKeyValueByIdAndKey = try { - FindAssetKeyValueByIdAndKey( - jp.co.soramitsu.iroha2.generated.FindAssetKeyValueByIdAndKey.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetKeyValueByIdAndKey, - ): Unit = - try { - jp.co.soramitsu.iroha2.generated.FindAssetKeyValueByIdAndKey.write( - writer, - instance.findAssetKeyValueByIdAndKey, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAssetDefinitionKeyValueByIdAndKey' variant - */ - public data class FindAssetDefinitionKeyValueByIdAndKey( - public val findAssetDefinitionKeyValueByIdAndKey: - jp.co.soramitsu.iroha2.generated.FindAssetDefinitionKeyValueByIdAndKey, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 17 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetDefinitionKeyValueByIdAndKey = try { - FindAssetDefinitionKeyValueByIdAndKey( - jp.co.soramitsu.iroha2.generated.FindAssetDefinitionKeyValueByIdAndKey.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetDefinitionKeyValueByIdAndKey, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetDefinitionKeyValueByIdAndKey.write( - writer, - instance.findAssetDefinitionKeyValueByIdAndKey, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAllDomains' variant - */ - public data class FindAllDomains( - public val findAllDomains: jp.co.soramitsu.iroha2.generated.FindAllDomains, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 18 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllDomains = try { - FindAllDomains( - jp.co.soramitsu.iroha2.generated.FindAllDomains.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAllDomains, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllDomains.write(writer, instance.findAllDomains) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindDomainById' variant - */ - public data class FindDomainById( - public val findDomainById: jp.co.soramitsu.iroha2.generated.FindDomainById, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 19 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindDomainById = try { - FindDomainById( - jp.co.soramitsu.iroha2.generated.FindDomainById.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindDomainById, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindDomainById.write(writer, instance.findDomainById) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindDomainKeyValueByIdAndKey' variant - */ - public data class FindDomainKeyValueByIdAndKey( - public val findDomainKeyValueByIdAndKey: - jp.co.soramitsu.iroha2.generated.FindDomainKeyValueByIdAndKey, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 20 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindDomainKeyValueByIdAndKey = try { - FindDomainKeyValueByIdAndKey( - jp.co.soramitsu.iroha2.generated.FindDomainKeyValueByIdAndKey.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindDomainKeyValueByIdAndKey, - ): Unit = - try { - jp.co.soramitsu.iroha2.generated.FindDomainKeyValueByIdAndKey.write( - writer, - instance.findDomainKeyValueByIdAndKey, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAllPeers' variant - */ - public data class FindAllPeers( - public val findAllPeers: jp.co.soramitsu.iroha2.generated.FindAllPeers, - ) : QueryBox() { + public data class FindDomains(public val queryWithFilterOfFindDomains: QueryWithFilterOfFindDomains) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 21 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllPeers = try { - FindAllPeers( - jp.co.soramitsu.iroha2.generated.FindAllPeers.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindDomains = try { + FindDomains( + QueryWithFilterOfFindDomains.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAllPeers, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllPeers.write(writer, instance.findAllPeers) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindDomains): Unit = try { + QueryWithFilterOfFindDomains.write(writer, instance.queryWithFilterOfFindDomains) } catch (ex: Exception) { throw wrapException(ex) } @@ -781,31 +51,26 @@ public sealed class QueryBox : ModelEnum { } /** - * 'FindAllBlocks' variant + * 'FindAccounts' variant */ - public data class FindAllBlocks( - public val findAllBlocks: jp.co.soramitsu.iroha2.generated.FindAllBlocks, - ) : QueryBox() { + public data class FindAccounts(public val queryWithFilterOfFindAccounts: QueryWithFilterOfFindAccounts) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 22 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllBlocks = try { - FindAllBlocks( - jp.co.soramitsu.iroha2.generated.FindAllBlocks.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAccounts = try { + FindAccounts( + QueryWithFilterOfFindAccounts.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAllBlocks, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllBlocks.write(writer, instance.findAllBlocks) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAccounts): Unit = try { + QueryWithFilterOfFindAccounts.write(writer, instance.queryWithFilterOfFindAccounts) } catch (ex: Exception) { throw wrapException(ex) } @@ -813,34 +78,26 @@ public sealed class QueryBox : ModelEnum { } /** - * 'FindAllBlockHeaders' variant + * 'FindAssets' variant */ - public data class FindAllBlockHeaders( - public val findAllBlockHeaders: jp.co.soramitsu.iroha2.generated.FindAllBlockHeaders, - ) : QueryBox() { + public data class FindAssets(public val queryWithFilterOfFindAssets: QueryWithFilterOfFindAssets) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 23 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllBlockHeaders = try { - FindAllBlockHeaders( - jp.co.soramitsu.iroha2.generated.FindAllBlockHeaders.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAssets = try { + FindAssets( + QueryWithFilterOfFindAssets.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAllBlockHeaders, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllBlockHeaders.write( - writer, - instance.findAllBlockHeaders, - ) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssets): Unit = try { + QueryWithFilterOfFindAssets.write(writer, instance.queryWithFilterOfFindAssets) } catch (ex: Exception) { throw wrapException(ex) } @@ -848,141 +105,82 @@ public sealed class QueryBox : ModelEnum { } /** - * 'FindBlockHeaderByHash' variant + * 'FindAssetsDefinitions' variant */ - public data class FindBlockHeaderByHash( - public val findBlockHeaderByHash: jp.co.soramitsu.iroha2.generated.FindBlockHeaderByHash, - ) : QueryBox() { + public data class FindAssetsDefinitions(public val queryWithFilterOfFindAssetsDefinitions: QueryWithFilterOfFindAssetsDefinitions) : + QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 24 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindBlockHeaderByHash = try { - FindBlockHeaderByHash( - jp.co.soramitsu.iroha2.generated.FindBlockHeaderByHash.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsDefinitions = try { + FindAssetsDefinitions( + QueryWithFilterOfFindAssetsDefinitions.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindBlockHeaderByHash, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindBlockHeaderByHash.write( - writer, - instance.findBlockHeaderByHash, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsDefinitions): Unit = + try { + QueryWithFilterOfFindAssetsDefinitions.write(writer, instance.queryWithFilterOfFindAssetsDefinitions) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAllTransactions' variant + * 'FindRoles' variant */ - public data class FindAllTransactions( - public val findAllTransactions: jp.co.soramitsu.iroha2.generated.FindAllTransactions, - ) : QueryBox() { + public data class FindRoles(public val queryWithFilterOfFindRoles: QueryWithFilterOfFindRoles) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 25 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllTransactions = try { - FindAllTransactions( - jp.co.soramitsu.iroha2.generated.FindAllTransactions.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 4 - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAllTransactions, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllTransactions.write( - writer, - instance.findAllTransactions, + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindRoles = try { + FindRoles( + QueryWithFilterOfFindRoles.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - } - } - - /** - * 'FindTransactionsByAccountId' variant - */ - public data class FindTransactionsByAccountId( - public val findTransactionsByAccountId: - jp.co.soramitsu.iroha2.generated.FindTransactionsByAccountId, - ) : QueryBox() { - 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.QueryBox.FindTransactionsByAccountId = try { - FindTransactionsByAccountId( - jp.co.soramitsu.iroha2.generated.FindTransactionsByAccountId.read(reader), - ) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindRoles): Unit = try { + QueryWithFilterOfFindRoles.write(writer, instance.queryWithFilterOfFindRoles) } catch (ex: Exception) { throw wrapException(ex) } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindTransactionsByAccountId, - ): Unit = - try { - jp.co.soramitsu.iroha2.generated.FindTransactionsByAccountId.write( - writer, - instance.findTransactionsByAccountId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } } } /** - * 'FindTransactionByHash' variant + * 'FindRoleIds' variant */ - public data class FindTransactionByHash( - public val findTransactionByHash: jp.co.soramitsu.iroha2.generated.FindTransactionByHash, - ) : QueryBox() { + public data class FindRoleIds(public val queryWithFilterOfFindRoleIds: QueryWithFilterOfFindRoleIds) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 27 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindTransactionByHash = try { - FindTransactionByHash( - jp.co.soramitsu.iroha2.generated.FindTransactionByHash.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindRoleIds = try { + FindRoleIds( + QueryWithFilterOfFindRoleIds.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindTransactionByHash, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindTransactionByHash.write( - writer, - instance.findTransactionByHash, - ) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindRoleIds): Unit = try { + QueryWithFilterOfFindRoleIds.write(writer, instance.queryWithFilterOfFindRoleIds) } catch (ex: Exception) { throw wrapException(ex) } @@ -993,19 +191,18 @@ public sealed class QueryBox : ModelEnum { * 'FindPermissionsByAccountId' variant */ public data class FindPermissionsByAccountId( - public val findPermissionsByAccountId: - jp.co.soramitsu.iroha2.generated.FindPermissionsByAccountId, + public val queryWithFilterOfFindPermissionsByAccountId: QueryWithFilterOfFindPermissionsByAccountId, ) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 28 + public const val DISCRIMINANT: Int = 6 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindPermissionsByAccountId = try { FindPermissionsByAccountId( - jp.co.soramitsu.iroha2.generated.FindPermissionsByAccountId.read(reader), + QueryWithFilterOfFindPermissionsByAccountId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -1014,114 +211,8 @@ public sealed class QueryBox : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindPermissionsByAccountId, - ): Unit = - try { - jp.co.soramitsu.iroha2.generated.FindPermissionsByAccountId.write( - writer, - instance.findPermissionsByAccountId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindExecutorDataModel' variant - */ - public data class FindExecutorDataModel( - public val findExecutorDataModel: jp.co.soramitsu.iroha2.generated.FindExecutorDataModel, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 29 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindExecutorDataModel = try { - FindExecutorDataModel( - jp.co.soramitsu.iroha2.generated.FindExecutorDataModel.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindExecutorDataModel, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindExecutorDataModel.write( - writer, - instance.findExecutorDataModel, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAllActiveTriggerIds' variant - */ - public data class FindAllActiveTriggerIds( - public val findAllActiveTriggerIds: jp.co.soramitsu.iroha2.generated.FindAllActiveTriggerIds, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 30 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllActiveTriggerIds = try { - FindAllActiveTriggerIds( - jp.co.soramitsu.iroha2.generated.FindAllActiveTriggerIds.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAllActiveTriggerIds, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllActiveTriggerIds.write( - writer, - instance.findAllActiveTriggerIds, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindTriggerById' variant - */ - public data class FindTriggerById( - public val findTriggerById: jp.co.soramitsu.iroha2.generated.FindTriggerById, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 31 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggerById = try { - FindTriggerById( - jp.co.soramitsu.iroha2.generated.FindTriggerById.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggerById, ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindTriggerById.write(writer, instance.findTriggerById) + QueryWithFilterOfFindPermissionsByAccountId.write(writer, instance.queryWithFilterOfFindPermissionsByAccountId) } catch (ex: Exception) { throw wrapException(ex) } @@ -1129,36 +220,28 @@ public sealed class QueryBox : ModelEnum { } /** - * 'FindTriggerKeyValueByIdAndKey' variant + * 'FindRolesByAccountId' variant */ - public data class FindTriggerKeyValueByIdAndKey( - public val findTriggerKeyValueByIdAndKey: - jp.co.soramitsu.iroha2.generated.FindTriggerKeyValueByIdAndKey, - ) : QueryBox() { + public data class FindRolesByAccountId(public val queryWithFilterOfFindRolesByAccountId: QueryWithFilterOfFindRolesByAccountId) : + QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 32 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 7 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggerKeyValueByIdAndKey = try { - FindTriggerKeyValueByIdAndKey( - jp.co.soramitsu.iroha2.generated.FindTriggerKeyValueByIdAndKey.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindRolesByAccountId = try { + FindRolesByAccountId( + QueryWithFilterOfFindRolesByAccountId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggerKeyValueByIdAndKey, - ): Unit = + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindRolesByAccountId): Unit = try { - jp.co.soramitsu.iroha2.generated.FindTriggerKeyValueByIdAndKey.write( - writer, - instance.findTriggerKeyValueByIdAndKey, - ) + QueryWithFilterOfFindRolesByAccountId.write(writer, instance.queryWithFilterOfFindRolesByAccountId) } catch (ex: Exception) { throw wrapException(ex) } @@ -1166,71 +249,55 @@ public sealed class QueryBox : ModelEnum { } /** - * 'FindTriggersByAuthorityId' variant + * 'FindAccountsWithAsset' variant */ - public data class FindTriggersByAuthorityId( - public val findTriggersByAuthorityId: - jp.co.soramitsu.iroha2.generated.FindTriggersByAuthorityId, - ) : QueryBox() { + public data class FindAccountsWithAsset(public val queryWithFilterOfFindAccountsWithAsset: QueryWithFilterOfFindAccountsWithAsset) : + QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 33 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 8 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggersByAuthorityId = try { - FindTriggersByAuthorityId( - jp.co.soramitsu.iroha2.generated.FindTriggersByAuthorityId.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAccountsWithAsset = try { + FindAccountsWithAsset( + QueryWithFilterOfFindAccountsWithAsset.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggersByAuthorityId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindTriggersByAuthorityId.write( - writer, - instance.findTriggersByAuthorityId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAccountsWithAsset): Unit = + try { + QueryWithFilterOfFindAccountsWithAsset.write(writer, instance.queryWithFilterOfFindAccountsWithAsset) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindTriggersByAuthorityDomainId' variant + * 'FindPeers' variant */ - public data class FindTriggersByAuthorityDomainId( - public val findTriggersByAuthorityDomainId: - jp.co.soramitsu.iroha2.generated.FindTriggersByAuthorityDomainId, - ) : QueryBox() { + public data class FindPeers(public val queryWithFilterOfFindPeers: QueryWithFilterOfFindPeers) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 34 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 9 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggersByAuthorityDomainId = try { - FindTriggersByAuthorityDomainId( - jp.co.soramitsu.iroha2.generated.FindTriggersByAuthorityDomainId.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindPeers = try { + FindPeers( + QueryWithFilterOfFindPeers.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggersByAuthorityDomainId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindTriggersByAuthorityDomainId.write( - writer, - instance.findTriggersByAuthorityDomainId, - ) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindPeers): Unit = try { + QueryWithFilterOfFindPeers.write(writer, instance.queryWithFilterOfFindPeers) } catch (ex: Exception) { throw wrapException(ex) } @@ -1238,63 +305,55 @@ public sealed class QueryBox : ModelEnum { } /** - * 'FindAllRoles' variant + * 'FindActiveTriggerIds' variant */ - public data class FindAllRoles( - public val findAllRoles: jp.co.soramitsu.iroha2.generated.FindAllRoles, - ) : QueryBox() { + public data class FindActiveTriggerIds(public val queryWithFilterOfFindActiveTriggerIds: QueryWithFilterOfFindActiveTriggerIds) : + QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 35 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 10 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllRoles = try { - FindAllRoles( - jp.co.soramitsu.iroha2.generated.FindAllRoles.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindActiveTriggerIds = try { + FindActiveTriggerIds( + QueryWithFilterOfFindActiveTriggerIds.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAllRoles, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllRoles.write(writer, instance.findAllRoles) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindActiveTriggerIds): Unit = + try { + QueryWithFilterOfFindActiveTriggerIds.write(writer, instance.queryWithFilterOfFindActiveTriggerIds) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAllRoleIds' variant + * 'FindTriggers' variant */ - public data class FindAllRoleIds( - public val findAllRoleIds: jp.co.soramitsu.iroha2.generated.FindAllRoleIds, - ) : QueryBox() { + public data class FindTriggers(public val queryWithFilterOfFindTriggers: QueryWithFilterOfFindTriggers) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 36 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 11 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllRoleIds = try { - FindAllRoleIds( - jp.co.soramitsu.iroha2.generated.FindAllRoleIds.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggers = try { + FindTriggers( + QueryWithFilterOfFindTriggers.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAllRoleIds, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllRoleIds.write(writer, instance.findAllRoleIds) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggers): Unit = try { + QueryWithFilterOfFindTriggers.write(writer, instance.queryWithFilterOfFindTriggers) } catch (ex: Exception) { throw wrapException(ex) } @@ -1302,31 +361,26 @@ public sealed class QueryBox : ModelEnum { } /** - * 'FindRoleByRoleId' variant + * 'FindTransactions' variant */ - public data class FindRoleByRoleId( - public val findRoleByRoleId: jp.co.soramitsu.iroha2.generated.FindRoleByRoleId, - ) : QueryBox() { + public data class FindTransactions(public val queryWithFilterOfFindTransactions: QueryWithFilterOfFindTransactions) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 37 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 12 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindRoleByRoleId = try { - FindRoleByRoleId( - jp.co.soramitsu.iroha2.generated.FindRoleByRoleId.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindTransactions = try { + FindTransactions( + QueryWithFilterOfFindTransactions.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindRoleByRoleId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindRoleByRoleId.write(writer, instance.findRoleByRoleId) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindTransactions): Unit = try { + QueryWithFilterOfFindTransactions.write(writer, instance.queryWithFilterOfFindTransactions) } catch (ex: Exception) { throw wrapException(ex) } @@ -1334,34 +388,26 @@ public sealed class QueryBox : ModelEnum { } /** - * 'FindRolesByAccountId' variant + * 'FindBlocks' variant */ - public data class FindRolesByAccountId( - public val findRolesByAccountId: jp.co.soramitsu.iroha2.generated.FindRolesByAccountId, - ) : QueryBox() { + public data class FindBlocks(public val queryWithFilterOfFindBlocks: QueryWithFilterOfFindBlocks) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 38 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 13 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindRolesByAccountId = try { - FindRolesByAccountId( - jp.co.soramitsu.iroha2.generated.FindRolesByAccountId.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindBlocks = try { + FindBlocks( + QueryWithFilterOfFindBlocks.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindRolesByAccountId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindRolesByAccountId.write( - writer, - instance.findRolesByAccountId, - ) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindBlocks): Unit = try { + QueryWithFilterOfFindBlocks.write(writer, instance.queryWithFilterOfFindBlocks) } catch (ex: Exception) { throw wrapException(ex) } @@ -1369,31 +415,26 @@ public sealed class QueryBox : ModelEnum { } /** - * 'FindAllParameters' variant + * 'FindBlockHeaders' variant */ - public data class FindAllParameters( - public val findAllParameters: jp.co.soramitsu.iroha2.generated.FindAllParameters, - ) : QueryBox() { + public data class FindBlockHeaders(public val queryWithFilterOfFindBlockHeaders: QueryWithFilterOfFindBlockHeaders) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 39 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 14 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllParameters = try { - FindAllParameters( - jp.co.soramitsu.iroha2.generated.FindAllParameters.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindBlockHeaders = try { + FindBlockHeaders( + QueryWithFilterOfFindBlockHeaders.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAllParameters, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllParameters.write(writer, instance.findAllParameters) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindBlockHeaders): Unit = try { + QueryWithFilterOfFindBlockHeaders.write(writer, instance.queryWithFilterOfFindBlockHeaders) } catch (ex: Exception) { throw wrapException(ex) } @@ -1401,112 +442,45 @@ public sealed class QueryBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> FindAllAccounts.read(reader) - 1 -> FindAccountById.read(reader) - 2 -> FindAccountKeyValueByIdAndKey.read(reader) - 3 -> FindAccountsByDomainId.read(reader) - 4 -> FindAccountsWithAsset.read(reader) - 5 -> FindAllAssets.read(reader) - 6 -> FindAllAssetsDefinitions.read(reader) - 7 -> FindAssetById.read(reader) - 8 -> FindAssetDefinitionById.read(reader) - 9 -> FindAssetsByName.read(reader) - 10 -> FindAssetsByAccountId.read(reader) - 11 -> FindAssetsByAssetDefinitionId.read(reader) - 12 -> FindAssetsByDomainId.read(reader) - 13 -> FindAssetsByDomainIdAndAssetDefinitionId.read(reader) - 14 -> FindAssetQuantityById.read(reader) - 15 -> FindTotalAssetQuantityByAssetDefinitionId.read(reader) - 16 -> FindAssetKeyValueByIdAndKey.read(reader) - 17 -> FindAssetDefinitionKeyValueByIdAndKey.read(reader) - 18 -> FindAllDomains.read(reader) - 19 -> FindDomainById.read(reader) - 20 -> FindDomainKeyValueByIdAndKey.read(reader) - 21 -> FindAllPeers.read(reader) - 22 -> FindAllBlocks.read(reader) - 23 -> FindAllBlockHeaders.read(reader) - 24 -> FindBlockHeaderByHash.read(reader) - 25 -> FindAllTransactions.read(reader) - 26 -> FindTransactionsByAccountId.read(reader) - 27 -> FindTransactionByHash.read(reader) - 28 -> FindPermissionsByAccountId.read(reader) - 29 -> FindExecutorDataModel.read(reader) - 30 -> FindAllActiveTriggerIds.read(reader) - 31 -> FindTriggerById.read(reader) - 32 -> FindTriggerKeyValueByIdAndKey.read(reader) - 33 -> FindTriggersByAuthorityId.read(reader) - 34 -> FindTriggersByAuthorityDomainId.read(reader) - 35 -> FindAllRoles.read(reader) - 36 -> FindAllRoleIds.read(reader) - 37 -> FindRoleByRoleId.read(reader) - 38 -> FindRolesByAccountId.read(reader) - 39 -> FindAllParameters.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + override fun read(reader: ScaleCodecReader): QueryBox = when (val discriminant = reader.readUByte()) { + 0 -> FindDomains.read(reader) + 1 -> FindAccounts.read(reader) + 2 -> FindAssets.read(reader) + 3 -> FindAssetsDefinitions.read(reader) + 4 -> FindRoles.read(reader) + 5 -> FindRoleIds.read(reader) + 6 -> FindPermissionsByAccountId.read(reader) + 7 -> FindRolesByAccountId.read(reader) + 8 -> FindAccountsWithAsset.read(reader) + 9 -> FindPeers.read(reader) + 10 -> FindActiveTriggerIds.read(reader) + 11 -> FindTriggers.read(reader) + 12 -> FindTransactions.read(reader) + 13 -> FindBlocks.read(reader) + 14 -> FindBlockHeaders.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: QueryBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> FindAllAccounts.write(writer, instance as FindAllAccounts) - 1 -> FindAccountById.write(writer, instance as FindAccountById) - 2 -> FindAccountKeyValueByIdAndKey.write(writer, instance as FindAccountKeyValueByIdAndKey) - 3 -> FindAccountsByDomainId.write(writer, instance as FindAccountsByDomainId) - 4 -> FindAccountsWithAsset.write(writer, instance as FindAccountsWithAsset) - 5 -> FindAllAssets.write(writer, instance as FindAllAssets) - 6 -> FindAllAssetsDefinitions.write(writer, instance as FindAllAssetsDefinitions) - 7 -> FindAssetById.write(writer, instance as FindAssetById) - 8 -> FindAssetDefinitionById.write(writer, instance as FindAssetDefinitionById) - 9 -> FindAssetsByName.write(writer, instance as FindAssetsByName) - 10 -> FindAssetsByAccountId.write(writer, instance as FindAssetsByAccountId) - 11 -> FindAssetsByAssetDefinitionId.write(writer, instance as FindAssetsByAssetDefinitionId) - 12 -> FindAssetsByDomainId.write(writer, instance as FindAssetsByDomainId) - 13 -> FindAssetsByDomainIdAndAssetDefinitionId.write( - writer, - instance as - FindAssetsByDomainIdAndAssetDefinitionId, - ) - 14 -> FindAssetQuantityById.write(writer, instance as FindAssetQuantityById) - 15 -> FindTotalAssetQuantityByAssetDefinitionId.write( - writer, - instance as - FindTotalAssetQuantityByAssetDefinitionId, - ) - 16 -> FindAssetKeyValueByIdAndKey.write(writer, instance as FindAssetKeyValueByIdAndKey) - 17 -> FindAssetDefinitionKeyValueByIdAndKey.write( - writer, - instance as - FindAssetDefinitionKeyValueByIdAndKey, - ) - 18 -> FindAllDomains.write(writer, instance as FindAllDomains) - 19 -> FindDomainById.write(writer, instance as FindDomainById) - 20 -> FindDomainKeyValueByIdAndKey.write(writer, instance as FindDomainKeyValueByIdAndKey) - 21 -> FindAllPeers.write(writer, instance as FindAllPeers) - 22 -> FindAllBlocks.write(writer, instance as FindAllBlocks) - 23 -> FindAllBlockHeaders.write(writer, instance as FindAllBlockHeaders) - 24 -> FindBlockHeaderByHash.write(writer, instance as FindBlockHeaderByHash) - 25 -> FindAllTransactions.write(writer, instance as FindAllTransactions) - 26 -> FindTransactionsByAccountId.write(writer, instance as FindTransactionsByAccountId) - 27 -> FindTransactionByHash.write(writer, instance as FindTransactionByHash) - 28 -> FindPermissionsByAccountId.write(writer, instance as FindPermissionsByAccountId) - 29 -> FindExecutorDataModel.write(writer, instance as FindExecutorDataModel) - 30 -> FindAllActiveTriggerIds.write(writer, instance as FindAllActiveTriggerIds) - 31 -> FindTriggerById.write(writer, instance as FindTriggerById) - 32 -> FindTriggerKeyValueByIdAndKey.write(writer, instance as FindTriggerKeyValueByIdAndKey) - 33 -> FindTriggersByAuthorityId.write(writer, instance as FindTriggersByAuthorityId) - 34 -> FindTriggersByAuthorityDomainId.write( - writer, - instance as - FindTriggersByAuthorityDomainId, - ) - 35 -> FindAllRoles.write(writer, instance as FindAllRoles) - 36 -> FindAllRoleIds.write(writer, instance as FindAllRoleIds) - 37 -> FindRoleByRoleId.write(writer, instance as FindRoleByRoleId) - 38 -> FindRolesByAccountId.write(writer, instance as FindRolesByAccountId) - 39 -> FindAllParameters.write(writer, instance as FindAllParameters) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 0 -> FindDomains.write(writer, instance as FindDomains) + 1 -> FindAccounts.write(writer, instance as FindAccounts) + 2 -> FindAssets.write(writer, instance as FindAssets) + 3 -> FindAssetsDefinitions.write(writer, instance as FindAssetsDefinitions) + 4 -> FindRoles.write(writer, instance as FindRoles) + 5 -> FindRoleIds.write(writer, instance as FindRoleIds) + 6 -> FindPermissionsByAccountId.write(writer, instance as FindPermissionsByAccountId) + 7 -> FindRolesByAccountId.write(writer, instance as FindRolesByAccountId) + 8 -> FindAccountsWithAsset.write(writer, instance as FindAccountsWithAsset) + 9 -> FindPeers.write(writer, instance as FindPeers) + 10 -> FindActiveTriggerIds.write(writer, instance as FindActiveTriggerIds) + 11 -> FindTriggers.write(writer, instance as FindTriggers) + 12 -> FindTransactions.write(writer, instance as FindTransactions) + 13 -> FindBlocks.write(writer, instance as FindBlocks) + 14 -> FindBlockHeaders.write(writer, instance as FindBlockHeaders) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryExecutionFail.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryExecutionFail.kt index 95ae72765..7211f9fc3 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryExecutionFail.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryExecutionFail.kt @@ -27,25 +27,29 @@ public sealed class QueryExecutionFail : ModelEnum { public abstract fun discriminant(): Int override fun equals(other: Any?): Boolean = when (this) { - is UnknownCursor -> UnknownCursor.equals(this, other) + is NotFound -> NotFound.equals(this, other) + is CursorMismatch -> CursorMismatch.equals(this, other) + is CursorDone -> CursorDone.equals(this, other) is FetchSizeTooBig -> FetchSizeTooBig.equals(this, other) is InvalidSingularParameters -> InvalidSingularParameters.equals(this, other) is CapacityLimit -> CapacityLimit.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { - is UnknownCursor -> UnknownCursor.hashCode() + is NotFound -> NotFound.hashCode() + is CursorMismatch -> CursorMismatch.hashCode() + is CursorDone -> CursorDone.hashCode() is FetchSizeTooBig -> FetchSizeTooBig.hashCode() is InvalidSingularParameters -> InvalidSingularParameters.hashCode() is CapacityLimit -> CapacityLimit.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'Find' variant */ - public data class Find( - public val findError: FindError, - ) : QueryExecutionFail() { + public data class Find(public val findError: FindError) : QueryExecutionFail() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -61,10 +65,7 @@ public sealed class QueryExecutionFail : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.Find, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.Find): Unit = try { FindError.write(writer, instance.findError) } catch (ex: Exception) { throw wrapException(ex) @@ -75,9 +76,7 @@ public sealed class QueryExecutionFail : ModelEnum { /** * 'Conversion' variant */ - public data class Conversion( - public val string: String, - ) : QueryExecutionFail() { + public data class Conversion(public val string: String) : QueryExecutionFail() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -93,51 +92,110 @@ public sealed class QueryExecutionFail : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.Conversion, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.Conversion): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'NotFound' variant + */ + public class NotFound : QueryExecutionFail() { + 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.QueryExecutionFail.NotFound = try { + NotFound() } catch (ex: Exception) { throw wrapException(ex) } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.NotFound): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.NotFound, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".QueryExecutionFail.NotFound".hashCode() } } /** - * 'UnknownCursor' variant + * 'CursorMismatch' variant */ - public class UnknownCursor : QueryExecutionFail() { + public class CursorMismatch : QueryExecutionFail() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 2 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryExecutionFail.UnknownCursor = try { - UnknownCursor() + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryExecutionFail.CursorMismatch = try { + CursorMismatch() } catch (ex: Exception) { throw wrapException(ex) } override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.UnknownCursor, + instance: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.CursorMismatch, ): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.UnknownCursor, - o2: Any?, - ): Boolean = when (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.CursorMismatch, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } - override fun hashCode(): Int = ".QueryExecutionFail.UnknownCursor".hashCode() + override fun hashCode(): Int = ".QueryExecutionFail.CursorMismatch".hashCode() + } + } + + /** + * 'CursorDone' variant + */ + public class CursorDone : QueryExecutionFail() { + 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.QueryExecutionFail.CursorDone = try { + CursorDone() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.CursorDone): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.CursorDone, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".QueryExecutionFail.CursorDone".hashCode() } } @@ -150,7 +208,7 @@ public sealed class QueryExecutionFail : 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.QueryExecutionFail.FetchSizeTooBig = try { FetchSizeTooBig() @@ -166,10 +224,7 @@ public sealed class QueryExecutionFail : ModelEnum { throw wrapException(ex) } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.FetchSizeTooBig, - o2: Any?, - ): Boolean = when (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.FetchSizeTooBig, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -187,13 +242,14 @@ public sealed class QueryExecutionFail : 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.QueryExecutionFail.InvalidSingularParameters = try { - InvalidSingularParameters() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryExecutionFail.InvalidSingularParameters = + try { + InvalidSingularParameters() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -203,13 +259,11 @@ public sealed class QueryExecutionFail : ModelEnum { throw wrapException(ex) } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.InvalidSingularParameters, - o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals(o1: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.InvalidSingularParameters, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".QueryExecutionFail.InvalidSingularParameters".hashCode() } @@ -224,7 +278,7 @@ public sealed class QueryExecutionFail : 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.QueryExecutionFail.CapacityLimit = try { CapacityLimit() @@ -240,10 +294,7 @@ public sealed class QueryExecutionFail : ModelEnum { throw wrapException(ex) } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.CapacityLimit, - o2: Any?, - ): Boolean = when (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.CapacityLimit, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -253,28 +304,31 @@ public sealed class QueryExecutionFail : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryExecutionFail = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): QueryExecutionFail = when (val discriminant = reader.readUByte()) { 0 -> Find.read(reader) 1 -> Conversion.read(reader) - 2 -> UnknownCursor.read(reader) - 3 -> FetchSizeTooBig.read(reader) - 4 -> InvalidSingularParameters.read(reader) - 5 -> CapacityLimit.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 2 -> NotFound.read(reader) + 3 -> CursorMismatch.read(reader) + 4 -> CursorDone.read(reader) + 5 -> FetchSizeTooBig.read(reader) + 6 -> InvalidSingularParameters.read(reader) + 7 -> CapacityLimit.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: QueryExecutionFail) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Find.write(writer, instance as Find) 1 -> Conversion.write(writer, instance as Conversion) - 2 -> UnknownCursor.write(writer, instance as UnknownCursor) - 3 -> FetchSizeTooBig.write(writer, instance as FetchSizeTooBig) - 4 -> InvalidSingularParameters.write(writer, instance as InvalidSingularParameters) - 5 -> CapacityLimit.write(writer, instance as CapacityLimit) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 2 -> NotFound.write(writer, instance as NotFound) + 3 -> CursorMismatch.write(writer, instance as CursorMismatch) + 4 -> CursorDone.write(writer, instance as CursorDone) + 5 -> FetchSizeTooBig.write(writer, instance as FetchSizeTooBig) + 6 -> InvalidSingularParameters.write(writer, instance as InvalidSingularParameters) + 7 -> CapacityLimit.write(writer, instance as CapacityLimit) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutput.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutput.kt index ca2118d63..f8eae3219 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutput.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutput.kt @@ -17,14 +17,14 @@ import kotlin.Unit * Generated from 'QueryOutput' regular structure */ public data class QueryOutput( - public val batch: QueryOutputBatchBox, + public val batch: QueryOutputBatchBoxTuple, public val remainingItems: BigInteger, public val continueCursor: ForwardCursor? = null, ) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): QueryOutput = try { QueryOutput( - QueryOutputBatchBox.read(reader), + QueryOutputBatchBoxTuple.read(reader), reader.readUint64(), reader.readNullable(ForwardCursor) as ForwardCursor?, ) @@ -33,7 +33,7 @@ public data class QueryOutput( } override fun write(writer: ScaleCodecWriter, instance: QueryOutput): Unit = try { - QueryOutputBatchBox.write(writer, instance.batch) + QueryOutputBatchBoxTuple.write(writer, instance.batch) writer.writeUint64(instance.remainingItems) writer.writeNullable(ForwardCursor, instance.continueCursor) } catch (ex: Exception) { 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 9e42159c6..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 @@ -24,18 +24,231 @@ public sealed class QueryOutputBatchBox : ModelEnum { */ public abstract fun discriminant(): Int + /** + * 'PublicKey' variant + */ + public data class PublicKey(public val vec: List) : QueryOutputBatchBox() { + 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.QueryOutputBatchBox.PublicKey = try { + PublicKey( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.PublicKey.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.PublicKey): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.PublicKey.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'String' variant + */ + public data class String(public val vec: List) : QueryOutputBatchBox() { + 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.QueryOutputBatchBox.String = try { + String( + reader.readVec(reader.readCompactInt()) { reader.readString() }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.String): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + writer.writeAsList(value.toByteArray(Charsets.UTF_8)) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Metadata' variant + */ + public data class Metadata(public val vec: List) : QueryOutputBatchBox() { + 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.QueryOutputBatchBox.Metadata = try { + Metadata( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Metadata.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Metadata): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.Metadata.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * '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 + */ + public data class Name(public val vec: List) : QueryOutputBatchBox() { + 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.QueryOutputBatchBox.Name = try { + Name( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Name.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Name): Unit = try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.Name.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'DomainId' variant + */ + public data class DomainId(public val vec: List) : QueryOutputBatchBox() { + 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.QueryOutputBatchBox.DomainId = try { + DomainId( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.DomainId.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.DomainId): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.DomainId.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + /** * 'Domain' variant */ - public data class Domain( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class Domain(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 0 + public const val DISCRIMINANT: Int = 7 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Domain = try { Domain( @@ -45,32 +258,59 @@ public sealed class QueryOutputBatchBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Domain, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.Domain.write(writer, value) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Domain): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.Domain.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } + } + } + + /** + * 'AccountId' variant + */ + public data class AccountId(public val vec: List) : QueryOutputBatchBox() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 8 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AccountId = try { + AccountId( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.AccountId.read(reader) }, + ) } catch (ex: Exception) { throw wrapException(ex) } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AccountId): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.AccountId.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Account' variant */ - public data class Account( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class Account(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 1 + public const val DISCRIMINANT: Int = 9 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Account = try { Account( @@ -80,32 +320,59 @@ public sealed class QueryOutputBatchBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Account, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.Account.write(writer, value) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Account): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.Account.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } + } + } + + /** + * 'AssetId' variant + */ + public data class AssetId(public val vec: List) : QueryOutputBatchBox() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 10 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetId = try { + AssetId( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.AssetId.read(reader) }, + ) } catch (ex: Exception) { throw wrapException(ex) } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetId): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.AssetId.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Asset' variant */ - public data class Asset( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class Asset(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 2 + public const val DISCRIMINANT: Int = 11 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Asset = try { Asset( @@ -115,13 +382,74 @@ public sealed class QueryOutputBatchBox : ModelEnum { throw wrapException(ex) } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Asset): Unit = try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.Asset.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'AssetValue' variant + */ + public data class AssetValue(public val vec: List) : QueryOutputBatchBox() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 12 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetValue = try { + AssetValue( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.AssetValue.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetValue): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.AssetValue.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'AssetDefinitionId' variant + */ + public data class AssetDefinitionId(public val vec: List) : QueryOutputBatchBox() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 13 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetDefinitionId = try { + AssetDefinitionId( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.AssetDefinitionId.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Asset, + instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetDefinitionId, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.Asset.write(writer, value) + jp.co.soramitsu.iroha2.generated.AssetDefinitionId.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -132,15 +460,13 @@ public sealed class QueryOutputBatchBox : ModelEnum { /** * 'AssetDefinition' variant */ - public data class AssetDefinition( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class AssetDefinition(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 3 + public const val DISCRIMINANT: Int = 14 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetDefinition = try { AssetDefinition( @@ -153,30 +479,27 @@ public sealed class QueryOutputBatchBox : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetDefinition, - ): Unit = - try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.AssetDefinition.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) + ): Unit = try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.AssetDefinition.write(writer, value) } + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Role' variant */ - public data class Role( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class Role(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 4 + public const val DISCRIMINANT: Int = 15 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Role = try { Role( @@ -186,10 +509,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Role, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Role): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> jp.co.soramitsu.iroha2.generated.Role.write(writer, value) @@ -203,15 +523,13 @@ public sealed class QueryOutputBatchBox : ModelEnum { /** * 'Parameter' variant */ - public data class Parameter( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class Parameter(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 5 + public const val DISCRIMINANT: Int = 16 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Parameter = try { Parameter( @@ -221,13 +539,76 @@ public sealed class QueryOutputBatchBox : ModelEnum { throw wrapException(ex) } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Parameter): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.Parameter.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Permission' variant + */ + public data class Permission(public val vec: List) : QueryOutputBatchBox() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 17 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Permission = try { + Permission( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Permission.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Permission): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.Permission.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'CommittedTransaction' variant + */ + public data class CommittedTransaction(public val vec: List) : + QueryOutputBatchBox() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 18 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.CommittedTransaction = try { + CommittedTransaction( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.CommittedTransaction.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Parameter, + instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.CommittedTransaction, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.Parameter.write(writer, value) + jp.co.soramitsu.iroha2.generated.CommittedTransaction.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -236,21 +617,19 @@ public sealed class QueryOutputBatchBox : ModelEnum { } /** - * 'Permission' variant + * 'SignedTransaction' variant */ - public data class Permission( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class SignedTransaction(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 6 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 19 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Permission = try { - Permission( - reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Permission.read(reader) }, + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.SignedTransaction = try { + SignedTransaction( + reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.SignedTransaction.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -258,11 +637,11 @@ public sealed class QueryOutputBatchBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Permission, + instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.SignedTransaction, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.Permission.write(writer, value) + jp.co.soramitsu.iroha2.generated.SignedTransaction.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -271,21 +650,22 @@ public sealed class QueryOutputBatchBox : ModelEnum { } /** - * 'Transaction' variant + * 'TransactionHash' variant */ - public data class Transaction( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class TransactionHash(public val vec: List>) : + QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 7 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 20 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Transaction = try { - Transaction( - reader.readVec(reader.readCompactInt()) { TransactionQueryOutput.read(reader) }, + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.TransactionHash = try { + TransactionHash( + reader.readVec( + reader.readCompactInt(), + ) { HashOf.read(reader) as HashOf }, ) } catch (ex: Exception) { throw wrapException(ex) @@ -293,11 +673,50 @@ public sealed class QueryOutputBatchBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Transaction, + instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.TransactionHash, + ): Unit = try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + HashOf.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'TransactionRejectionReason' variant + */ + public data class TransactionRejectionReason(public val vec: List) : + QueryOutputBatchBox() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 21 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.TransactionRejectionReason = + try { + TransactionRejectionReason( + reader.readVec(reader.readCompactInt()) { + reader.readNullable( + jp.co.soramitsu.iroha2.generated.TransactionRejectionReason, + ) as jp.co.soramitsu.iroha2.generated.TransactionRejectionReason? + }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.TransactionRejectionReason, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - TransactionQueryOutput.write(writer, value) + writer.writeNullable(jp.co.soramitsu.iroha2.generated.TransactionRejectionReason, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -308,31 +727,26 @@ public sealed class QueryOutputBatchBox : ModelEnum { /** * 'Peer' variant */ - public data class Peer( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class Peer(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 8 + public const val DISCRIMINANT: Int = 22 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Peer = try { Peer( - reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Peer.read(reader) }, + reader.readVec(reader.readCompactInt()) { PeerId.read(reader) }, ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Peer, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Peer): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.Peer.write(writer, value) + PeerId.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -343,15 +757,13 @@ public sealed class QueryOutputBatchBox : ModelEnum { /** * 'RoleId' variant */ - public data class RoleId( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class RoleId(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 9 + public const val DISCRIMINANT: Int = 23 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.RoleId = try { RoleId( @@ -361,32 +773,28 @@ public sealed class QueryOutputBatchBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.RoleId, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.RoleId.write(writer, value) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.RoleId): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.RoleId.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } /** * 'TriggerId' variant */ - public data class TriggerId( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class TriggerId(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 10 + public const val DISCRIMINANT: Int = 24 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.TriggerId = try { TriggerId( @@ -396,32 +804,28 @@ public sealed class QueryOutputBatchBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.TriggerId, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.TriggerId.write(writer, value) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.TriggerId): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.TriggerId.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } /** * 'Trigger' variant */ - public data class Trigger( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class Trigger(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 11 + public const val DISCRIMINANT: Int = 25 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Trigger = try { Trigger( @@ -431,32 +835,59 @@ public sealed class QueryOutputBatchBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Trigger, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.Trigger.write(writer, value) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Trigger): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.Trigger.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } + } + } + + /** + * '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 */ - public data class Block( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class Block(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 12 + public const val DISCRIMINANT: Int = 27 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Block = try { Block( @@ -466,10 +897,7 @@ public sealed class QueryOutputBatchBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Block, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Block): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> SignedBlock.write(writer, value) @@ -483,15 +911,13 @@ public sealed class QueryOutputBatchBox : ModelEnum { /** * 'BlockHeader' variant */ - public data class BlockHeader( - public val vec: List, - ) : QueryOutputBatchBox() { + public data class BlockHeader(public val vec: List) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 13 + public const val DISCRIMINANT: Int = 28 override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.BlockHeader = try { BlockHeader( @@ -501,13 +927,44 @@ public sealed class QueryOutputBatchBox : ModelEnum { throw wrapException(ex) } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.BlockHeader): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.BlockHeader.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'BlockHeaderHash' variant + */ + public data class BlockHeaderHash(public val vec: List>) : QueryOutputBatchBox() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 29 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.BlockHeaderHash = try { + BlockHeaderHash( + reader.readVec(reader.readCompactInt()) { HashOf.read(reader) as HashOf }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.BlockHeader, + instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.BlockHeaderHash, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.BlockHeader.write(writer, value) + HashOf.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -516,44 +973,75 @@ public sealed class QueryOutputBatchBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryOutputBatchBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Domain.read(reader) - 1 -> Account.read(reader) - 2 -> Asset.read(reader) - 3 -> AssetDefinition.read(reader) - 4 -> Role.read(reader) - 5 -> Parameter.read(reader) - 6 -> Permission.read(reader) - 7 -> Transaction.read(reader) - 8 -> Peer.read(reader) - 9 -> RoleId.read(reader) - 10 -> TriggerId.read(reader) - 11 -> Trigger.read(reader) - 12 -> Block.read(reader) - 13 -> BlockHeader.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + override fun read(reader: ScaleCodecReader): QueryOutputBatchBox = when (val discriminant = reader.readUByte()) { + 0 -> PublicKey.read(reader) + 1 -> String.read(reader) + 2 -> Metadata.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") + } override fun write(writer: ScaleCodecWriter, instance: QueryOutputBatchBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Domain.write(writer, instance as Domain) - 1 -> Account.write(writer, instance as Account) - 2 -> Asset.write(writer, instance as Asset) - 3 -> AssetDefinition.write(writer, instance as AssetDefinition) - 4 -> Role.write(writer, instance as Role) - 5 -> Parameter.write(writer, instance as Parameter) - 6 -> Permission.write(writer, instance as Permission) - 7 -> Transaction.write(writer, instance as Transaction) - 8 -> Peer.write(writer, instance as Peer) - 9 -> RoleId.write(writer, instance as RoleId) - 10 -> TriggerId.write(writer, instance as TriggerId) - 11 -> Trigger.write(writer, instance as Trigger) - 12 -> Block.write(writer, instance as Block) - 13 -> BlockHeader.write(writer, instance as BlockHeader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 0 -> PublicKey.write(writer, instance as PublicKey) + 1 -> String.write(writer, instance as String) + 2 -> Metadata.write(writer, instance as Metadata) + 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/QueryOutputBatchBoxTuple.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputBatchBoxTuple.kt new file mode 100644 index 000000000..0a5e29596 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputBatchBoxTuple.kt @@ -0,0 +1,40 @@ +// +// 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 +import kotlin.collections.List + +/** + * QueryOutputBatchBoxTuple + * + * Generated from 'QueryOutputBatchBoxTuple' regular structure + */ +public data class QueryOutputBatchBoxTuple(public val tuple: List) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryOutputBatchBoxTuple = try { + QueryOutputBatchBoxTuple( + reader.readVec(reader.readCompactInt()) { QueryOutputBatchBox.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryOutputBatchBoxTuple): Unit = try { + writer.writeCompact(instance.tuple.size) + instance.tuple.forEach { value -> + QueryOutputBatchBox.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputBox.kt deleted file mode 100644 index 6417bf9f1..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputBox.kt +++ /dev/null @@ -1,418 +0,0 @@ -// -// 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.String -import kotlin.Unit -import kotlin.collections.List - -/** - * QueryOutputBox - * - * Generated from 'QueryOutputBox' enum - */ -public sealed class QueryOutputBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Id' variant - */ - public data class Id( - public val idBox: IdBox, - ) : QueryOutputBox() { - 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.QueryOutputBox.Id = try { - Id( - IdBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBox.Id, - ): Unit = try { - IdBox.write(writer, instance.idBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Identifiable' variant - */ - public data class Identifiable( - public val identifiableBox: IdentifiableBox, - ) : QueryOutputBox() { - 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.QueryOutputBox.Identifiable = try { - Identifiable( - IdentifiableBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBox.Identifiable, - ): Unit = try { - IdentifiableBox.write(writer, instance.identifiableBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Transaction' variant - */ - public data class Transaction( - public val transactionQueryOutput: TransactionQueryOutput, - ) : QueryOutputBox() { - 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.QueryOutputBox.Transaction = try { - Transaction( - TransactionQueryOutput.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBox.Transaction, - ): Unit = try { - TransactionQueryOutput.write(writer, instance.transactionQueryOutput) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Permission' variant - */ - public data class Permission( - public val permission: jp.co.soramitsu.iroha2.generated.Permission, - ) : QueryOutputBox() { - 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.QueryOutputBox.Permission = try { - Permission( - jp.co.soramitsu.iroha2.generated.Permission.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBox.Permission, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Permission.write(writer, instance.permission) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Parameters' variant - */ - public data class Parameters( - public val parameters: jp.co.soramitsu.iroha2.generated.Parameters, - ) : QueryOutputBox() { - 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.QueryOutputBox.Parameters = try { - Parameters( - jp.co.soramitsu.iroha2.generated.Parameters.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBox.Parameters, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Parameters.write(writer, instance.parameters) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Metadata' variant - */ - public data class Metadata( - public val string: String, - ) : QueryOutputBox() { - 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.QueryOutputBox.Metadata = try { - Metadata( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBox.Metadata, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Numeric' variant - */ - public data class Numeric( - public val numeric: jp.co.soramitsu.iroha2.generated.Numeric, - ) : QueryOutputBox() { - 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.QueryOutputBox.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.QueryOutputBox.Numeric, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Numeric.write(writer, instance.numeric) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'BlockHeader' variant - */ - public data class BlockHeader( - public val blockHeader: jp.co.soramitsu.iroha2.generated.BlockHeader, - ) : QueryOutputBox() { - 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.QueryOutputBox.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.QueryOutputBox.BlockHeader, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.BlockHeader.write(writer, instance.blockHeader) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Block' variant - */ - public data class Block( - public val signedBlock: SignedBlock, - ) : QueryOutputBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 8 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBox.Block = try { - Block( - SignedBlock.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBox.Block, - ): Unit = try { - SignedBlock.write(writer, instance.signedBlock) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'ExecutorDataModel' variant - */ - public data class ExecutorDataModel( - public val executorDataModel: jp.co.soramitsu.iroha2.generated.ExecutorDataModel, - ) : QueryOutputBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 9 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBox.ExecutorDataModel = try { - ExecutorDataModel( - jp.co.soramitsu.iroha2.generated.ExecutorDataModel.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBox.ExecutorDataModel, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.ExecutorDataModel.write(writer, instance.executorDataModel) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Vec' variant - */ - public data class Vec( - public val vec: List, - ) : QueryOutputBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 10 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBox.Vec = try { - Vec( - reader.readVec(reader.readCompactInt()) { QueryOutputBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputBox.Vec, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - QueryOutputBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryOutputBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Id.read(reader) - 1 -> Identifiable.read(reader) - 2 -> Transaction.read(reader) - 3 -> Permission.read(reader) - 4 -> Parameters.read(reader) - 5 -> Metadata.read(reader) - 6 -> Numeric.read(reader) - 7 -> BlockHeader.read(reader) - 8 -> Block.read(reader) - 9 -> ExecutorDataModel.read(reader) - 10 -> Vec.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: QueryOutputBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Id.write(writer, instance as Id) - 1 -> Identifiable.write(writer, instance as Identifiable) - 2 -> Transaction.write(writer, instance as Transaction) - 3 -> Permission.write(writer, instance as Permission) - 4 -> Parameters.write(writer, instance as Parameters) - 5 -> Metadata.write(writer, instance as Metadata) - 6 -> Numeric.write(writer, instance as Numeric) - 7 -> BlockHeader.write(writer, instance as BlockHeader) - 8 -> Block.write(writer, instance as Block) - 9 -> ExecutorDataModel.write(writer, instance as ExecutorDataModel) - 10 -> Vec.write(writer, instance as Vec) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputPredicate.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputPredicate.kt deleted file mode 100644 index a7372b445..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputPredicate.kt +++ /dev/null @@ -1,255 +0,0 @@ -// -// 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 - -/** - * QueryOutputPredicate - * - * Generated from 'QueryOutputPredicate' enum - */ -public sealed class QueryOutputPredicate : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - override fun equals(other: Any?): Boolean = when (this) { - is Pass -> Pass.equals(this, other) - else -> super.equals(other) } - - override fun hashCode(): Int = when (this) { - is Pass -> Pass.hashCode() - else -> super.hashCode() } - - /** - * 'Identifiable' variant - */ - public data class Identifiable( - public val stringPredicate: StringPredicate, - ) : QueryOutputPredicate() { - 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.QueryOutputPredicate.Identifiable = try { - Identifiable( - StringPredicate.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputPredicate.Identifiable, - ): Unit = try { - StringPredicate.write(writer, instance.stringPredicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Container' variant - */ - public data class Container( - public val container: jp.co.soramitsu.iroha2.generated.Container, - ) : QueryOutputPredicate() { - 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.QueryOutputPredicate.Container = try { - Container( - jp.co.soramitsu.iroha2.generated.Container.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputPredicate.Container, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Container.write(writer, instance.container) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Display' variant - */ - public data class Display( - public val stringPredicate: StringPredicate, - ) : QueryOutputPredicate() { - 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.QueryOutputPredicate.Display = try { - Display( - StringPredicate.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputPredicate.Display, - ): Unit = try { - StringPredicate.write(writer, instance.stringPredicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Numerical' variant - */ - public data class Numerical( - public val semiRange: SemiRange, - ) : QueryOutputPredicate() { - 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.QueryOutputPredicate.Numerical = try { - Numerical( - SemiRange.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputPredicate.Numerical, - ): Unit = try { - SemiRange.write(writer, instance.semiRange) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'TimeStamp' variant - */ - public data class TimeStamp( - public val semiIntervalOfu128: SemiIntervalOfu128, - ) : QueryOutputPredicate() { - 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.QueryOutputPredicate.TimeStamp = try { - TimeStamp( - SemiIntervalOfu128.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputPredicate.TimeStamp, - ): Unit = try { - SemiIntervalOfu128.write(writer, instance.semiIntervalOfu128) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Pass' variant - */ - public class Pass : QueryOutputPredicate() { - 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.QueryOutputPredicate.Pass = try { - Pass() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryOutputPredicate.Pass, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: jp.co.soramitsu.iroha2.generated.QueryOutputPredicate.Pass, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".QueryOutputPredicate.Pass".hashCode() - } - } - - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryOutputPredicate = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Identifiable.read(reader) - 1 -> Container.read(reader) - 2 -> Display.read(reader) - 3 -> Numerical.read(reader) - 4 -> TimeStamp.read(reader) - 5 -> Pass.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: QueryOutputPredicate) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Identifiable.write(writer, instance as Identifiable) - 1 -> Container.write(writer, instance as Container) - 2 -> Display.write(writer, instance as Display) - 3 -> Numerical.write(writer, instance as Numerical) - 4 -> TimeStamp.write(writer, instance as TimeStamp) - 5 -> Pass.write(writer, instance as Pass) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryRequest.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryRequest.kt index ff3cfe367..e2b2fcbd7 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryRequest.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryRequest.kt @@ -26,9 +26,7 @@ public sealed class QueryRequest : ModelEnum { /** * 'Singular' variant */ - public data class Singular( - public val singularQueryBox: SingularQueryBox, - ) : QueryRequest() { + public data class Singular(public val singularQueryBox: SingularQueryBox) : QueryRequest() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class QueryRequest : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryRequest.Singular, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryRequest.Singular): Unit = try { SingularQueryBox.write(writer, instance.singularQueryBox) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class QueryRequest : ModelEnum { /** * 'Start' variant */ - public data class Start( - public val queryWithParams: QueryWithParams, - ) : QueryRequest() { + public data class Start(public val queryWithParams: QueryWithParams) : QueryRequest() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class QueryRequest : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryRequest.Start, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryRequest.Start): Unit = try { QueryWithParams.write(writer, instance.queryWithParams) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class QueryRequest : ModelEnum { /** * 'Continue' variant */ - public data class Continue( - public val forwardCursor: ForwardCursor, - ) : QueryRequest() { + public data class Continue(public val forwardCursor: ForwardCursor) : QueryRequest() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,10 +96,7 @@ public sealed class QueryRequest : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryRequest.Continue, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryRequest.Continue): Unit = try { ForwardCursor.write(writer, instance.forwardCursor) } catch (ex: Exception) { throw wrapException(ex) @@ -120,14 +105,12 @@ public sealed class QueryRequest : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryRequest = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): QueryRequest = when (val discriminant = reader.readUByte()) { 0 -> Singular.read(reader) 1 -> Start.read(reader) 2 -> Continue.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: QueryRequest) { writer.directWrite(instance.discriminant()) @@ -135,7 +118,8 @@ public sealed class QueryRequest : ModelEnum { 0 -> Singular.write(writer, instance as Singular) 1 -> Start.write(writer, instance as Start) 2 -> Continue.write(writer, instance as Continue) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryRequestWithAuthority.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryRequestWithAuthority.kt index d5022d5a4..f104adfcf 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryRequestWithAuthority.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryRequestWithAuthority.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'QueryRequestWithAuthority' regular structure */ -public data class QueryRequestWithAuthority( - public val authority: AccountId, - public val request: QueryRequest, -) { +public data class QueryRequestWithAuthority(public val authority: AccountId, public val request: QueryRequest) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryResponse.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryResponse.kt index 2d52787a9..31b185094 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryResponse.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryResponse.kt @@ -26,9 +26,7 @@ public sealed class QueryResponse : ModelEnum { /** * 'Singular' variant */ - public data class Singular( - public val singularQueryOutputBox: SingularQueryOutputBox, - ) : QueryResponse() { + public data class Singular(public val singularQueryOutputBox: SingularQueryOutputBox) : QueryResponse() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class QueryResponse : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryResponse.Singular, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryResponse.Singular): Unit = try { SingularQueryOutputBox.write(writer, instance.singularQueryOutputBox) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class QueryResponse : ModelEnum { /** * 'Iterable' variant */ - public data class Iterable( - public val queryOutput: QueryOutput, - ) : QueryResponse() { + public data class Iterable(public val queryOutput: QueryOutput) : QueryResponse() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class QueryResponse : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryResponse.Iterable, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryResponse.Iterable): Unit = try { QueryOutput.write(writer, instance.queryOutput) } catch (ex: Exception) { throw wrapException(ex) @@ -88,20 +78,19 @@ public sealed class QueryResponse : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryResponse = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): QueryResponse = when (val discriminant = reader.readUByte()) { 0 -> Singular.read(reader) 1 -> Iterable.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: QueryResponse) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Singular.write(writer, instance as Singular) 1 -> Iterable.write(writer, instance as Iterable) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QuerySignature.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QuerySignature.kt index 7528943ff..e981a49ec 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QuerySignature.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QuerySignature.kt @@ -15,20 +15,18 @@ import kotlin.Unit * * Generated from 'QuerySignature' regular structure */ -public data class QuerySignature( - public val signatureOfOfClientQueryPayload: SignatureOf, -) { +public data class QuerySignature(public val signatureOfOfQueryRequestWithAuthority: SignatureOf) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): QuerySignature = try { QuerySignature( - SignatureOf.read(reader) as SignatureOf, + SignatureOf.read(reader) as SignatureOf, ) } catch (ex: Exception) { throw wrapException(ex) } override fun write(writer: ScaleCodecWriter, instance: QuerySignature): Unit = try { - SignatureOf.write(writer, instance.signatureOfOfClientQueryPayload) + SignatureOf.write(writer, instance.signatureOfOfQueryRequestWithAuthority) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccounts.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccounts.kt new file mode 100644 index 000000000..c2b668623 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccounts.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindAccounts + * + * Generated from 'QueryWithFilterOfFindAccounts' regular structure + */ +public data class QueryWithFilterOfFindAccounts( + public val query: FindAccounts, + public val predicate: CompoundPredicateOfAccount, + public val selector: SelectorTupleOfAccount, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindAccounts = try { + QueryWithFilterOfFindAccounts( + FindAccounts.read(reader), + CompoundPredicateOfAccount.read(reader), + SelectorTupleOfAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindAccounts): Unit = try { + FindAccounts.write(writer, instance.query) + CompoundPredicateOfAccount.write(writer, instance.predicate) + SelectorTupleOfAccount.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccountsAndAccountPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccountsAndAccountPredicateBox.kt deleted file mode 100644 index a4a51d0ae..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccountsAndAccountPredicateBox.kt +++ /dev/null @@ -1,44 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindAccountsAndAccountPredicateBox - * - * Generated from 'QueryWithFilterOfFindAccountsAndAccountPredicateBox' regular structure - */ -public data class QueryWithFilterOfFindAccountsAndAccountPredicateBox( - public val query: FindAccounts, - public val predicate: CompoundPredicateOfAccountPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindAccountsAndAccountPredicateBox = try { - QueryWithFilterOfFindAccountsAndAccountPredicateBox( - FindAccounts.read(reader), - CompoundPredicateOfAccountPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindAccountsAndAccountPredicateBox, - ): Unit = try { - FindAccounts.write(writer, instance.query) - CompoundPredicateOfAccountPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccountsWithAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccountsWithAsset.kt new file mode 100644 index 000000000..19dc5c837 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccountsWithAsset.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindAccountsWithAsset + * + * Generated from 'QueryWithFilterOfFindAccountsWithAsset' regular structure + */ +public data class QueryWithFilterOfFindAccountsWithAsset( + public val query: FindAccountsWithAsset, + public val predicate: CompoundPredicateOfAccount, + public val selector: SelectorTupleOfAccount, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindAccountsWithAsset = try { + QueryWithFilterOfFindAccountsWithAsset( + FindAccountsWithAsset.read(reader), + CompoundPredicateOfAccount.read(reader), + SelectorTupleOfAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindAccountsWithAsset): Unit = try { + FindAccountsWithAsset.write(writer, instance.query) + CompoundPredicateOfAccount.write(writer, instance.predicate) + SelectorTupleOfAccount.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccountsWithAssetAndAccountPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccountsWithAssetAndAccountPredicateBox.kt deleted file mode 100644 index 9d646852b..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccountsWithAssetAndAccountPredicateBox.kt +++ /dev/null @@ -1,44 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindAccountsWithAssetAndAccountPredicateBox - * - * Generated from 'QueryWithFilterOfFindAccountsWithAssetAndAccountPredicateBox' regular structure - */ -public data class QueryWithFilterOfFindAccountsWithAssetAndAccountPredicateBox( - public val query: FindAccountsWithAsset, - public val predicate: CompoundPredicateOfAccountPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindAccountsWithAssetAndAccountPredicateBox = try { - QueryWithFilterOfFindAccountsWithAssetAndAccountPredicateBox( - FindAccountsWithAsset.read(reader), - CompoundPredicateOfAccountPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindAccountsWithAssetAndAccountPredicateBox, - ): Unit = try { - FindAccountsWithAsset.write(writer, instance.query) - CompoundPredicateOfAccountPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindActiveTriggerIds.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindActiveTriggerIds.kt new file mode 100644 index 000000000..a7b36dff0 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindActiveTriggerIds.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindActiveTriggerIds + * + * Generated from 'QueryWithFilterOfFindActiveTriggerIds' regular structure + */ +public data class QueryWithFilterOfFindActiveTriggerIds( + public val query: FindActiveTriggerIds, + public val predicate: CompoundPredicateOfTriggerId, + public val selector: SelectorTupleOfTriggerId, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindActiveTriggerIds = try { + QueryWithFilterOfFindActiveTriggerIds( + FindActiveTriggerIds.read(reader), + CompoundPredicateOfTriggerId.read(reader), + SelectorTupleOfTriggerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindActiveTriggerIds): Unit = try { + FindActiveTriggerIds.write(writer, instance.query) + CompoundPredicateOfTriggerId.write(writer, instance.predicate) + SelectorTupleOfTriggerId.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindActiveTriggerIdsAndTriggerIdPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindActiveTriggerIdsAndTriggerIdPredicateBox.kt deleted file mode 100644 index 920c2eaac..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindActiveTriggerIdsAndTriggerIdPredicateBox.kt +++ /dev/null @@ -1,44 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindActiveTriggerIdsAndTriggerIdPredicateBox - * - * Generated from 'QueryWithFilterOfFindActiveTriggerIdsAndTriggerIdPredicateBox' regular structure - */ -public data class QueryWithFilterOfFindActiveTriggerIdsAndTriggerIdPredicateBox( - public val query: FindActiveTriggerIds, - public val predicate: CompoundPredicateOfTriggerIdPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindActiveTriggerIdsAndTriggerIdPredicateBox = try { - QueryWithFilterOfFindActiveTriggerIdsAndTriggerIdPredicateBox( - FindActiveTriggerIds.read(reader), - CompoundPredicateOfTriggerIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindActiveTriggerIdsAndTriggerIdPredicateBox, - ): Unit = try { - FindActiveTriggerIds.write(writer, instance.query) - CompoundPredicateOfTriggerIdPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssets.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssets.kt new file mode 100644 index 000000000..f35ce3abf --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssets.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindAssets + * + * Generated from 'QueryWithFilterOfFindAssets' regular structure + */ +public data class QueryWithFilterOfFindAssets( + public val query: FindAssets, + public val predicate: CompoundPredicateOfAsset, + public val selector: SelectorTupleOfAsset, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindAssets = try { + QueryWithFilterOfFindAssets( + FindAssets.read(reader), + CompoundPredicateOfAsset.read(reader), + SelectorTupleOfAsset.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindAssets): Unit = try { + FindAssets.write(writer, instance.query) + CompoundPredicateOfAsset.write(writer, instance.predicate) + SelectorTupleOfAsset.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssetsAndAssetPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssetsAndAssetPredicateBox.kt deleted file mode 100644 index ea622c55d..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssetsAndAssetPredicateBox.kt +++ /dev/null @@ -1,45 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindAssetsAndAssetPredicateBox - * - * Generated from 'QueryWithFilterOfFindAssetsAndAssetPredicateBox' regular structure - */ -public data class QueryWithFilterOfFindAssetsAndAssetPredicateBox( - public val query: FindAssets, - public val predicate: CompoundPredicateOfAssetPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindAssetsAndAssetPredicateBox = - try { - QueryWithFilterOfFindAssetsAndAssetPredicateBox( - FindAssets.read(reader), - CompoundPredicateOfAssetPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindAssetsAndAssetPredicateBox, - ): Unit = try { - FindAssets.write(writer, instance.query) - CompoundPredicateOfAssetPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssetsDefinitions.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssetsDefinitions.kt new file mode 100644 index 000000000..51d0082d5 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssetsDefinitions.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindAssetsDefinitions + * + * Generated from 'QueryWithFilterOfFindAssetsDefinitions' regular structure + */ +public data class QueryWithFilterOfFindAssetsDefinitions( + public val query: FindAssetsDefinitions, + public val predicate: CompoundPredicateOfAssetDefinition, + public val selector: SelectorTupleOfAssetDefinition, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindAssetsDefinitions = try { + QueryWithFilterOfFindAssetsDefinitions( + FindAssetsDefinitions.read(reader), + CompoundPredicateOfAssetDefinition.read(reader), + SelectorTupleOfAssetDefinition.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindAssetsDefinitions): Unit = try { + FindAssetsDefinitions.write(writer, instance.query) + CompoundPredicateOfAssetDefinition.write(writer, instance.predicate) + SelectorTupleOfAssetDefinition.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssetsDefinitionsAndAssetDefinitionPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssetsDefinitionsAndAssetDefinitionPredicateBox.kt deleted file mode 100644 index c2ab18e3c..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssetsDefinitionsAndAssetDefinitionPredicateBox.kt +++ /dev/null @@ -1,45 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindAssetsDefinitionsAndAssetDefinitionPredicateBox - * - * Generated from 'QueryWithFilterOfFindAssetsDefinitionsAndAssetDefinitionPredicateBox' regular - * structure - */ -public data class QueryWithFilterOfFindAssetsDefinitionsAndAssetDefinitionPredicateBox( - public val query: FindAssetsDefinitions, - public val predicate: CompoundPredicateOfAssetDefinitionPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindAssetsDefinitionsAndAssetDefinitionPredicateBox = try { - QueryWithFilterOfFindAssetsDefinitionsAndAssetDefinitionPredicateBox( - FindAssetsDefinitions.read(reader), - CompoundPredicateOfAssetDefinitionPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindAssetsDefinitionsAndAssetDefinitionPredicateBox, - ): Unit = try { - FindAssetsDefinitions.write(writer, instance.query) - CompoundPredicateOfAssetDefinitionPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlockHeaders.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlockHeaders.kt new file mode 100644 index 000000000..5fa2bc7aa --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlockHeaders.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindBlockHeaders + * + * Generated from 'QueryWithFilterOfFindBlockHeaders' regular structure + */ +public data class QueryWithFilterOfFindBlockHeaders( + public val query: FindBlockHeaders, + public val predicate: CompoundPredicateOfBlockHeader, + public val selector: SelectorTupleOfBlockHeader, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindBlockHeaders = try { + QueryWithFilterOfFindBlockHeaders( + FindBlockHeaders.read(reader), + CompoundPredicateOfBlockHeader.read(reader), + SelectorTupleOfBlockHeader.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindBlockHeaders): Unit = try { + FindBlockHeaders.write(writer, instance.query) + CompoundPredicateOfBlockHeader.write(writer, instance.predicate) + SelectorTupleOfBlockHeader.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlockHeadersAndBlockHeaderPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlockHeadersAndBlockHeaderPredicateBox.kt deleted file mode 100644 index 443a157b9..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlockHeadersAndBlockHeaderPredicateBox.kt +++ /dev/null @@ -1,44 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindBlockHeadersAndBlockHeaderPredicateBox - * - * Generated from 'QueryWithFilterOfFindBlockHeadersAndBlockHeaderPredicateBox' regular structure - */ -public data class QueryWithFilterOfFindBlockHeadersAndBlockHeaderPredicateBox( - public val query: FindBlockHeaders, - public val predicate: CompoundPredicateOfBlockHeaderPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindBlockHeadersAndBlockHeaderPredicateBox = try { - QueryWithFilterOfFindBlockHeadersAndBlockHeaderPredicateBox( - FindBlockHeaders.read(reader), - CompoundPredicateOfBlockHeaderPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindBlockHeadersAndBlockHeaderPredicateBox, - ): Unit = try { - FindBlockHeaders.write(writer, instance.query) - CompoundPredicateOfBlockHeaderPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlocks.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlocks.kt new file mode 100644 index 000000000..604a2c3b6 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlocks.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindBlocks + * + * Generated from 'QueryWithFilterOfFindBlocks' regular structure + */ +public data class QueryWithFilterOfFindBlocks( + public val query: FindBlocks, + public val predicate: CompoundPredicateOfSignedBlock, + public val selector: SelectorTupleOfSignedBlock, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindBlocks = try { + QueryWithFilterOfFindBlocks( + FindBlocks.read(reader), + CompoundPredicateOfSignedBlock.read(reader), + SelectorTupleOfSignedBlock.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindBlocks): Unit = try { + FindBlocks.write(writer, instance.query) + CompoundPredicateOfSignedBlock.write(writer, instance.predicate) + SelectorTupleOfSignedBlock.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlocksAndSignedBlockPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlocksAndSignedBlockPredicateBox.kt deleted file mode 100644 index 1abc8b831..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlocksAndSignedBlockPredicateBox.kt +++ /dev/null @@ -1,44 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindBlocksAndSignedBlockPredicateBox - * - * Generated from 'QueryWithFilterOfFindBlocksAndSignedBlockPredicateBox' regular structure - */ -public data class QueryWithFilterOfFindBlocksAndSignedBlockPredicateBox( - public val query: FindBlocks, - public val predicate: CompoundPredicateOfSignedBlockPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindBlocksAndSignedBlockPredicateBox = try { - QueryWithFilterOfFindBlocksAndSignedBlockPredicateBox( - FindBlocks.read(reader), - CompoundPredicateOfSignedBlockPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindBlocksAndSignedBlockPredicateBox, - ): Unit = try { - FindBlocks.write(writer, instance.query) - CompoundPredicateOfSignedBlockPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindDomains.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindDomains.kt new file mode 100644 index 000000000..fb33bae32 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindDomains.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindDomains + * + * Generated from 'QueryWithFilterOfFindDomains' regular structure + */ +public data class QueryWithFilterOfFindDomains( + public val query: FindDomains, + public val predicate: CompoundPredicateOfDomain, + public val selector: SelectorTupleOfDomain, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindDomains = try { + QueryWithFilterOfFindDomains( + FindDomains.read(reader), + CompoundPredicateOfDomain.read(reader), + SelectorTupleOfDomain.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindDomains): Unit = try { + FindDomains.write(writer, instance.query) + CompoundPredicateOfDomain.write(writer, instance.predicate) + SelectorTupleOfDomain.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindDomainsAndDomainPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindDomainsAndDomainPredicateBox.kt deleted file mode 100644 index c006d5f81..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindDomainsAndDomainPredicateBox.kt +++ /dev/null @@ -1,45 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindDomainsAndDomainPredicateBox - * - * Generated from 'QueryWithFilterOfFindDomainsAndDomainPredicateBox' regular structure - */ -public data class QueryWithFilterOfFindDomainsAndDomainPredicateBox( - public val query: FindDomains, - public val predicate: CompoundPredicateOfDomainPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindDomainsAndDomainPredicateBox = - try { - QueryWithFilterOfFindDomainsAndDomainPredicateBox( - FindDomains.read(reader), - CompoundPredicateOfDomainPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindDomainsAndDomainPredicateBox, - ): Unit = try { - FindDomains.write(writer, instance.query) - CompoundPredicateOfDomainPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPeers.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPeers.kt new file mode 100644 index 000000000..4ab317dcd --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPeers.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindPeers + * + * Generated from 'QueryWithFilterOfFindPeers' regular structure + */ +public data class QueryWithFilterOfFindPeers( + public val query: FindPeers, + public val predicate: CompoundPredicateOfPeerId, + public val selector: SelectorTupleOfPeerId, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindPeers = try { + QueryWithFilterOfFindPeers( + FindPeers.read(reader), + CompoundPredicateOfPeerId.read(reader), + SelectorTupleOfPeerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindPeers): Unit = try { + FindPeers.write(writer, instance.query) + CompoundPredicateOfPeerId.write(writer, instance.predicate) + SelectorTupleOfPeerId.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPeersAndPeerPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPeersAndPeerPredicateBox.kt deleted file mode 100644 index 4946c4665..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPeersAndPeerPredicateBox.kt +++ /dev/null @@ -1,44 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindPeersAndPeerPredicateBox - * - * Generated from 'QueryWithFilterOfFindPeersAndPeerPredicateBox' regular structure - */ -public data class QueryWithFilterOfFindPeersAndPeerPredicateBox( - public val query: FindPeers, - public val predicate: CompoundPredicateOfPeerPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindPeersAndPeerPredicateBox = try { - QueryWithFilterOfFindPeersAndPeerPredicateBox( - FindPeers.read(reader), - CompoundPredicateOfPeerPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindPeersAndPeerPredicateBox, - ): Unit = try { - FindPeers.write(writer, instance.query) - CompoundPredicateOfPeerPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPermissionsByAccountId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPermissionsByAccountId.kt new file mode 100644 index 000000000..0865f3f05 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPermissionsByAccountId.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindPermissionsByAccountId + * + * Generated from 'QueryWithFilterOfFindPermissionsByAccountId' regular structure + */ +public data class QueryWithFilterOfFindPermissionsByAccountId( + public val query: FindPermissionsByAccountId, + public val predicate: CompoundPredicateOfPermission, + public val selector: SelectorTupleOfPermission, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindPermissionsByAccountId = try { + QueryWithFilterOfFindPermissionsByAccountId( + FindPermissionsByAccountId.read(reader), + CompoundPredicateOfPermission.read(reader), + SelectorTupleOfPermission.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindPermissionsByAccountId): Unit = try { + FindPermissionsByAccountId.write(writer, instance.query) + CompoundPredicateOfPermission.write(writer, instance.predicate) + SelectorTupleOfPermission.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPermissionsByAccountIdAndPermissionPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPermissionsByAccountIdAndPermissionPredicateBox.kt deleted file mode 100644 index ead92ed58..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPermissionsByAccountIdAndPermissionPredicateBox.kt +++ /dev/null @@ -1,45 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindPermissionsByAccountIdAndPermissionPredicateBox - * - * Generated from 'QueryWithFilterOfFindPermissionsByAccountIdAndPermissionPredicateBox' regular - * structure - */ -public data class QueryWithFilterOfFindPermissionsByAccountIdAndPermissionPredicateBox( - public val query: FindPermissionsByAccountId, - public val predicate: CompoundPredicateOfPermissionPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindPermissionsByAccountIdAndPermissionPredicateBox = try { - QueryWithFilterOfFindPermissionsByAccountIdAndPermissionPredicateBox( - FindPermissionsByAccountId.read(reader), - CompoundPredicateOfPermissionPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindPermissionsByAccountIdAndPermissionPredicateBox, - ): Unit = try { - FindPermissionsByAccountId.write(writer, instance.query) - CompoundPredicateOfPermissionPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRoleIds.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRoleIds.kt new file mode 100644 index 000000000..29a7cde8a --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRoleIds.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindRoleIds + * + * Generated from 'QueryWithFilterOfFindRoleIds' regular structure + */ +public data class QueryWithFilterOfFindRoleIds( + public val query: FindRoleIds, + public val predicate: CompoundPredicateOfRoleId, + public val selector: SelectorTupleOfRoleId, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindRoleIds = try { + QueryWithFilterOfFindRoleIds( + FindRoleIds.read(reader), + CompoundPredicateOfRoleId.read(reader), + SelectorTupleOfRoleId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindRoleIds): Unit = try { + FindRoleIds.write(writer, instance.query) + CompoundPredicateOfRoleId.write(writer, instance.predicate) + SelectorTupleOfRoleId.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRoleIdsAndRoleIdPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRoleIdsAndRoleIdPredicateBox.kt deleted file mode 100644 index a4c8c3dd9..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRoleIdsAndRoleIdPredicateBox.kt +++ /dev/null @@ -1,45 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindRoleIdsAndRoleIdPredicateBox - * - * Generated from 'QueryWithFilterOfFindRoleIdsAndRoleIdPredicateBox' regular structure - */ -public data class QueryWithFilterOfFindRoleIdsAndRoleIdPredicateBox( - public val query: FindRoleIds, - public val predicate: CompoundPredicateOfRoleIdPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindRoleIdsAndRoleIdPredicateBox = - try { - QueryWithFilterOfFindRoleIdsAndRoleIdPredicateBox( - FindRoleIds.read(reader), - CompoundPredicateOfRoleIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindRoleIdsAndRoleIdPredicateBox, - ): Unit = try { - FindRoleIds.write(writer, instance.query) - CompoundPredicateOfRoleIdPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRoles.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRoles.kt new file mode 100644 index 000000000..f4fdc1aaa --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRoles.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindRoles + * + * Generated from 'QueryWithFilterOfFindRoles' regular structure + */ +public data class QueryWithFilterOfFindRoles( + public val query: FindRoles, + public val predicate: CompoundPredicateOfRole, + public val selector: SelectorTupleOfRole, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindRoles = try { + QueryWithFilterOfFindRoles( + FindRoles.read(reader), + CompoundPredicateOfRole.read(reader), + SelectorTupleOfRole.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindRoles): Unit = try { + FindRoles.write(writer, instance.query) + CompoundPredicateOfRole.write(writer, instance.predicate) + SelectorTupleOfRole.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRolesAndRolePredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRolesAndRolePredicateBox.kt deleted file mode 100644 index b4704915c..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRolesAndRolePredicateBox.kt +++ /dev/null @@ -1,44 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindRolesAndRolePredicateBox - * - * Generated from 'QueryWithFilterOfFindRolesAndRolePredicateBox' regular structure - */ -public data class QueryWithFilterOfFindRolesAndRolePredicateBox( - public val query: FindRoles, - public val predicate: CompoundPredicateOfRolePredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindRolesAndRolePredicateBox = try { - QueryWithFilterOfFindRolesAndRolePredicateBox( - FindRoles.read(reader), - CompoundPredicateOfRolePredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindRolesAndRolePredicateBox, - ): Unit = try { - FindRoles.write(writer, instance.query) - CompoundPredicateOfRolePredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRolesByAccountId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRolesByAccountId.kt new file mode 100644 index 000000000..cd69f6145 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRolesByAccountId.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindRolesByAccountId + * + * Generated from 'QueryWithFilterOfFindRolesByAccountId' regular structure + */ +public data class QueryWithFilterOfFindRolesByAccountId( + public val query: FindRolesByAccountId, + public val predicate: CompoundPredicateOfRoleId, + public val selector: SelectorTupleOfRoleId, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindRolesByAccountId = try { + QueryWithFilterOfFindRolesByAccountId( + FindRolesByAccountId.read(reader), + CompoundPredicateOfRoleId.read(reader), + SelectorTupleOfRoleId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindRolesByAccountId): Unit = try { + FindRolesByAccountId.write(writer, instance.query) + CompoundPredicateOfRoleId.write(writer, instance.predicate) + SelectorTupleOfRoleId.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRolesByAccountIdAndRoleIdPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRolesByAccountIdAndRoleIdPredicateBox.kt deleted file mode 100644 index 5858cb40b..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRolesByAccountIdAndRoleIdPredicateBox.kt +++ /dev/null @@ -1,44 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindRolesByAccountIdAndRoleIdPredicateBox - * - * Generated from 'QueryWithFilterOfFindRolesByAccountIdAndRoleIdPredicateBox' regular structure - */ -public data class QueryWithFilterOfFindRolesByAccountIdAndRoleIdPredicateBox( - public val query: FindRolesByAccountId, - public val predicate: CompoundPredicateOfRoleIdPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindRolesByAccountIdAndRoleIdPredicateBox = try { - QueryWithFilterOfFindRolesByAccountIdAndRoleIdPredicateBox( - FindRolesByAccountId.read(reader), - CompoundPredicateOfRoleIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindRolesByAccountIdAndRoleIdPredicateBox, - ): Unit = try { - FindRolesByAccountId.write(writer, instance.query) - CompoundPredicateOfRoleIdPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTransactions.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTransactions.kt new file mode 100644 index 000000000..5abcc206d --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTransactions.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindTransactions + * + * Generated from 'QueryWithFilterOfFindTransactions' regular structure + */ +public data class QueryWithFilterOfFindTransactions( + public val query: FindTransactions, + public val predicate: CompoundPredicateOfCommittedTransaction, + public val selector: SelectorTupleOfCommittedTransaction, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindTransactions = try { + QueryWithFilterOfFindTransactions( + FindTransactions.read(reader), + CompoundPredicateOfCommittedTransaction.read(reader), + SelectorTupleOfCommittedTransaction.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindTransactions): Unit = try { + FindTransactions.write(writer, instance.query) + CompoundPredicateOfCommittedTransaction.write(writer, instance.predicate) + SelectorTupleOfCommittedTransaction.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTransactionsAndTransactionQueryOutputPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTransactionsAndTransactionQueryOutputPredicateBox.kt deleted file mode 100644 index e3981ae9b..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTransactionsAndTransactionQueryOutputPredicateBox.kt +++ /dev/null @@ -1,46 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindTransactionsAndTransactionQueryOutputPredicateBox - * - * Generated from 'QueryWithFilterOfFindTransactionsAndTransactionQueryOutputPredicateBox' regular - * structure - */ -public data class QueryWithFilterOfFindTransactionsAndTransactionQueryOutputPredicateBox( - public val query: FindTransactions, - public val predicate: CompoundPredicateOfTransactionQueryOutputPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindTransactionsAndTransactionQueryOutputPredicateBox = try { - QueryWithFilterOfFindTransactionsAndTransactionQueryOutputPredicateBox( - FindTransactions.read(reader), - CompoundPredicateOfTransactionQueryOutputPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindTransactionsAndTransactionQueryOutputPredicateBox, - ): Unit = - try { - FindTransactions.write(writer, instance.query) - CompoundPredicateOfTransactionQueryOutputPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTriggers.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTriggers.kt new file mode 100644 index 000000000..faafd0b33 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTriggers.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * QueryWithFilterOfFindTriggers + * + * Generated from 'QueryWithFilterOfFindTriggers' regular structure + */ +public data class QueryWithFilterOfFindTriggers( + public val query: FindTriggers, + public val predicate: CompoundPredicateOfTrigger, + public val selector: SelectorTupleOfTrigger, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindTriggers = try { + QueryWithFilterOfFindTriggers( + FindTriggers.read(reader), + CompoundPredicateOfTrigger.read(reader), + SelectorTupleOfTrigger.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: QueryWithFilterOfFindTriggers): Unit = try { + FindTriggers.write(writer, instance.query) + CompoundPredicateOfTrigger.write(writer, instance.predicate) + SelectorTupleOfTrigger.write(writer, instance.selector) + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTriggersAndTriggerPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTriggersAndTriggerPredicateBox.kt deleted file mode 100644 index 37f3623d4..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTriggersAndTriggerPredicateBox.kt +++ /dev/null @@ -1,44 +0,0 @@ -// -// 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 - -/** - * QueryWithFilterOfFindTriggersAndTriggerPredicateBox - * - * Generated from 'QueryWithFilterOfFindTriggersAndTriggerPredicateBox' regular structure - */ -public data class QueryWithFilterOfFindTriggersAndTriggerPredicateBox( - public val query: FindTriggers, - public val predicate: CompoundPredicateOfTriggerPredicateBox, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithFilterOfFindTriggersAndTriggerPredicateBox = try { - QueryWithFilterOfFindTriggersAndTriggerPredicateBox( - FindTriggers.read(reader), - CompoundPredicateOfTriggerPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: QueryWithFilterOfFindTriggersAndTriggerPredicateBox, - ): Unit = try { - FindTriggers.write(writer, instance.query) - CompoundPredicateOfTriggerPredicateBox.write(writer, instance.predicate) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithParams.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithParams.kt index 9005e17be..9f71f8b34 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithParams.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithParams.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'QueryWithParams' regular structure */ -public data class QueryWithParams( - public val query: QueryBox, - public val params: QueryParams, -) { +public data class QueryWithParams(public val query: QueryBox, public val params: QueryParams) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): QueryWithParams = try { QueryWithParams( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RawGenesisTransaction.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RawGenesisTransaction.kt index 46c194d64..d2410149f 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RawGenesisTransaction.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RawGenesisTransaction.kt @@ -20,8 +20,10 @@ import kotlin.collections.List public data class RawGenesisTransaction( public val chain: ChainId, public val executor: String, - public val parameters: List, + public val parameters: Parameters? = null, public val instructions: List, + public val wasmDir: String, + public val wasmTriggers: List, public val topology: List, ) { public companion object : ScaleReader, ScaleWriter { @@ -29,8 +31,10 @@ public data class RawGenesisTransaction( RawGenesisTransaction( ChainId.read(reader), reader.readString(), - reader.readVec(reader.readCompactInt()) { Parameter.read(reader) }, + reader.readNullable(Parameters) as Parameters?, reader.readVec(reader.readCompactInt()) { InstructionBox.read(reader) }, + reader.readString(), + reader.readVec(reader.readCompactInt()) { GenesisWasmTrigger.read(reader) }, reader.readVec(reader.readCompactInt()) { PeerId.read(reader) }, ) } catch (ex: Exception) { @@ -40,14 +44,16 @@ public data class RawGenesisTransaction( override fun write(writer: ScaleCodecWriter, instance: RawGenesisTransaction): Unit = try { ChainId.write(writer, instance.chain) writer.writeAsList(instance.executor.toByteArray(Charsets.UTF_8)) - writer.writeCompact(instance.parameters.size) - instance.parameters.forEach { value -> - Parameter.write(writer, value) - } + writer.writeNullable(Parameters, instance.parameters) writer.writeCompact(instance.instructions.size) instance.instructions.forEach { value -> InstructionBox.write(writer, value) } + writer.writeAsList(instance.wasmDir.toByteArray(Charsets.UTF_8)) + writer.writeCompact(instance.wasmTriggers.size) + instance.wasmTriggers.forEach { value -> + GenesisWasmTrigger.write(writer, value) + } writer.writeCompact(instance.topology.size) instance.topology.forEach { value -> PeerId.write(writer, value) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterBox.kt index e7f11559a..82155941c 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterBox.kt @@ -26,9 +26,7 @@ public sealed class RegisterBox : ModelEnum { /** * 'Peer' variant */ - public data class Peer( - public val registerOfPeer: RegisterOfPeer, - ) : RegisterBox() { + public data class Peer(public val registerOfPeer: RegisterOfPeer) : RegisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class RegisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RegisterBox.Peer, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RegisterBox.Peer): Unit = try { RegisterOfPeer.write(writer, instance.registerOfPeer) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class RegisterBox : ModelEnum { /** * 'Domain' variant */ - public data class Domain( - public val registerOfDomain: RegisterOfDomain, - ) : RegisterBox() { + public data class Domain(public val registerOfDomain: RegisterOfDomain) : RegisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class RegisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RegisterBox.Domain, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RegisterBox.Domain): Unit = try { RegisterOfDomain.write(writer, instance.registerOfDomain) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class RegisterBox : ModelEnum { /** * 'Account' variant */ - public data class Account( - public val registerOfAccount: RegisterOfAccount, - ) : RegisterBox() { + public data class Account(public val registerOfAccount: RegisterOfAccount) : RegisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,10 +96,7 @@ public sealed class RegisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RegisterBox.Account, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RegisterBox.Account): Unit = try { RegisterOfAccount.write(writer, instance.registerOfAccount) } catch (ex: Exception) { throw wrapException(ex) @@ -122,9 +107,7 @@ public sealed class RegisterBox : ModelEnum { /** * 'AssetDefinition' variant */ - public data class AssetDefinition( - public val registerOfAssetDefinition: RegisterOfAssetDefinition, - ) : RegisterBox() { + public data class AssetDefinition(public val registerOfAssetDefinition: RegisterOfAssetDefinition) : RegisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,23 +123,19 @@ public sealed class RegisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RegisterBox.AssetDefinition, - ): Unit = try { - RegisterOfAssetDefinition.write(writer, instance.registerOfAssetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RegisterBox.AssetDefinition): Unit = + try { + RegisterOfAssetDefinition.write(writer, instance.registerOfAssetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Asset' variant */ - public data class Asset( - public val registerOfAsset: RegisterOfAsset, - ) : RegisterBox() { + public data class Asset(public val registerOfAsset: RegisterOfAsset) : RegisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -172,10 +151,7 @@ public sealed class RegisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RegisterBox.Asset, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RegisterBox.Asset): Unit = try { RegisterOfAsset.write(writer, instance.registerOfAsset) } catch (ex: Exception) { throw wrapException(ex) @@ -186,9 +162,7 @@ public sealed class RegisterBox : ModelEnum { /** * 'Role' variant */ - public data class Role( - public val registerOfRole: RegisterOfRole, - ) : RegisterBox() { + public data class Role(public val registerOfRole: RegisterOfRole) : RegisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -204,10 +178,7 @@ public sealed class RegisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RegisterBox.Role, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RegisterBox.Role): Unit = try { RegisterOfRole.write(writer, instance.registerOfRole) } catch (ex: Exception) { throw wrapException(ex) @@ -218,9 +189,7 @@ public sealed class RegisterBox : ModelEnum { /** * 'Trigger' variant */ - public data class Trigger( - public val registerOfTrigger: RegisterOfTrigger, - ) : RegisterBox() { + public data class Trigger(public val registerOfTrigger: RegisterOfTrigger) : RegisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -236,10 +205,7 @@ public sealed class RegisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RegisterBox.Trigger, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RegisterBox.Trigger): Unit = try { RegisterOfTrigger.write(writer, instance.registerOfTrigger) } catch (ex: Exception) { throw wrapException(ex) @@ -248,10 +214,7 @@ public sealed class RegisterBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RegisterBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): RegisterBox = when (val discriminant = reader.readUByte()) { 0 -> Peer.read(reader) 1 -> Domain.read(reader) 2 -> Account.read(reader) @@ -259,7 +222,8 @@ public sealed class RegisterBox : ModelEnum { 4 -> Asset.read(reader) 5 -> Role.read(reader) 6 -> Trigger.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: RegisterBox) { writer.directWrite(instance.discriminant()) @@ -271,7 +235,8 @@ public sealed class RegisterBox : ModelEnum { 4 -> Asset.write(writer, instance as Asset) 5 -> Role.write(writer, instance as Role) 6 -> Trigger.write(writer, instance as Trigger) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfAccount.kt index c363b6de8..10e42d82d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfAccount.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'RegisterOfAccount' regular structure */ -public data class RegisterOfAccount( - public val `object`: NewAccount, -) { +public data class RegisterOfAccount(public val `object`: NewAccount) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): RegisterOfAccount = try { RegisterOfAccount( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfAsset.kt index e396d10a5..52d701e53 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfAsset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfAsset.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'RegisterOfAsset' regular structure */ -public data class RegisterOfAsset( - public val `object`: Asset, -) { +public data class RegisterOfAsset(public val `object`: Asset) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): RegisterOfAsset = try { RegisterOfAsset( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfAssetDefinition.kt index b10f8253d..29d334b3c 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfAssetDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfAssetDefinition.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'RegisterOfAssetDefinition' regular structure */ -public data class RegisterOfAssetDefinition( - public val `object`: NewAssetDefinition, -) { +public data class RegisterOfAssetDefinition(public val `object`: NewAssetDefinition) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfDomain.kt index 0ac22fac3..ae80468f1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfDomain.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfDomain.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'RegisterOfDomain' regular structure */ -public data class RegisterOfDomain( - public val `object`: NewDomain, -) { +public data class RegisterOfDomain(public val `object`: NewDomain) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): RegisterOfDomain = try { RegisterOfDomain( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfPeer.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfPeer.kt index d737b9d71..104868176 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfPeer.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfPeer.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,20 +18,20 @@ import kotlin.Unit * * Generated from 'RegisterOfPeer' regular structure */ -public data class RegisterOfPeer( - public val `object`: Peer, -) { +public data class RegisterOfPeer(public val `object`: PeerId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): RegisterOfPeer = try { RegisterOfPeer( - Peer.read(reader), + PeerId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } override fun write(writer: ScaleCodecWriter, instance: RegisterOfPeer): Unit = try { - Peer.write(writer, instance.`object`) + PeerId.write(writer, instance.`object`) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfRole.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfRole.kt index 365468328..7a08dd38f 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfRole.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfRole.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,20 +18,20 @@ import kotlin.Unit * * Generated from 'RegisterOfRole' regular structure */ -public data class RegisterOfRole( - public val `object`: Role, -) { +public data class RegisterOfRole(public val `object`: NewRole) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): RegisterOfRole = try { RegisterOfRole( - Role.read(reader), + NewRole.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } override fun write(writer: ScaleCodecWriter, instance: RegisterOfRole): Unit = try { - Role.write(writer, instance.`object`) + NewRole.write(writer, instance.`object`) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfTrigger.kt index df06f66b7..1f1bfa23f 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RegisterOfTrigger.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'RegisterOfTrigger' regular structure */ -public data class RegisterOfTrigger( - public val `object`: Trigger, -) { +public data class RegisterOfTrigger(public val `object`: Trigger) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): RegisterOfTrigger = try { RegisterOfTrigger( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueBox.kt index 79c343373..b63023b2c 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueBox.kt @@ -26,9 +26,7 @@ public sealed class RemoveKeyValueBox : ModelEnum { /** * 'Domain' variant */ - public data class Domain( - public val removeKeyValueOfDomain: RemoveKeyValueOfDomain, - ) : RemoveKeyValueBox() { + public data class Domain(public val removeKeyValueOfDomain: RemoveKeyValueOfDomain) : RemoveKeyValueBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class RemoveKeyValueBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Domain, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Domain): Unit = try { RemoveKeyValueOfDomain.write(writer, instance.removeKeyValueOfDomain) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class RemoveKeyValueBox : ModelEnum { /** * 'Account' variant */ - public data class Account( - public val removeKeyValueOfAccount: RemoveKeyValueOfAccount, - ) : RemoveKeyValueBox() { + public data class Account(public val removeKeyValueOfAccount: RemoveKeyValueOfAccount) : RemoveKeyValueBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class RemoveKeyValueBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Account, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Account): Unit = try { RemoveKeyValueOfAccount.write(writer, instance.removeKeyValueOfAccount) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class RemoveKeyValueBox : ModelEnum { /** * 'AssetDefinition' variant */ - public data class AssetDefinition( - public val removeKeyValueOfAssetDefinition: RemoveKeyValueOfAssetDefinition, - ) : RemoveKeyValueBox() { + public data class AssetDefinition(public val removeKeyValueOfAssetDefinition: RemoveKeyValueOfAssetDefinition) : RemoveKeyValueBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -122,9 +110,7 @@ public sealed class RemoveKeyValueBox : ModelEnum { /** * 'Asset' variant */ - public data class Asset( - public val removeKeyValueOfAsset: RemoveKeyValueOfAsset, - ) : RemoveKeyValueBox() { + public data class Asset(public val removeKeyValueOfAsset: RemoveKeyValueOfAsset) : RemoveKeyValueBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,10 +126,7 @@ public sealed class RemoveKeyValueBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Asset, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Asset): Unit = try { RemoveKeyValueOfAsset.write(writer, instance.removeKeyValueOfAsset) } catch (ex: Exception) { throw wrapException(ex) @@ -154,9 +137,7 @@ public sealed class RemoveKeyValueBox : ModelEnum { /** * 'Trigger' variant */ - public data class Trigger( - public val removeKeyValueOfTrigger: RemoveKeyValueOfTrigger, - ) : RemoveKeyValueBox() { + public data class Trigger(public val removeKeyValueOfTrigger: RemoveKeyValueOfTrigger) : RemoveKeyValueBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -172,10 +153,7 @@ public sealed class RemoveKeyValueBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Trigger, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Trigger): Unit = try { RemoveKeyValueOfTrigger.write(writer, instance.removeKeyValueOfTrigger) } catch (ex: Exception) { throw wrapException(ex) @@ -184,16 +162,14 @@ public sealed class RemoveKeyValueBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RemoveKeyValueBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): RemoveKeyValueBox = when (val discriminant = reader.readUByte()) { 0 -> Domain.read(reader) 1 -> Account.read(reader) 2 -> AssetDefinition.read(reader) 3 -> Asset.read(reader) 4 -> Trigger.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: RemoveKeyValueBox) { writer.directWrite(instance.discriminant()) @@ -203,7 +179,8 @@ public sealed class RemoveKeyValueBox : ModelEnum { 2 -> AssetDefinition.write(writer, instance as AssetDefinition) 3 -> Asset.write(writer, instance as Asset) 4 -> Trigger.write(writer, instance as Trigger) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAccount.kt index 0dd32975f..caf061944 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAccount.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,10 +18,9 @@ import kotlin.Unit * * Generated from 'RemoveKeyValueOfAccount' regular structure */ -public data class RemoveKeyValueOfAccount( - public val `object`: AccountId, - public val key: Name, -) { +public data class RemoveKeyValueOfAccount(public val `object`: AccountId, public val key: Name) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAsset.kt index 40b180b03..17e2a0557 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAsset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAsset.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,10 +18,9 @@ import kotlin.Unit * * Generated from 'RemoveKeyValueOfAsset' regular structure */ -public data class RemoveKeyValueOfAsset( - public val `object`: AssetId, - public val key: Name, -) { +public data class RemoveKeyValueOfAsset(public val `object`: AssetId, public val key: Name) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): RemoveKeyValueOfAsset = try { RemoveKeyValueOfAsset( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAssetDefinition.kt index 29112f1e2..2f7f0caa0 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAssetDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAssetDefinition.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,10 +18,9 @@ import kotlin.Unit * * Generated from 'RemoveKeyValueOfAssetDefinition' regular structure */ -public data class RemoveKeyValueOfAssetDefinition( - public val `object`: AssetDefinitionId, - public val key: Name, -) { +public data class RemoveKeyValueOfAssetDefinition(public val `object`: AssetDefinitionId, public val key: Name) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { @@ -31,12 +33,11 @@ public data class RemoveKeyValueOfAssetDefinition( throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: RemoveKeyValueOfAssetDefinition): Unit = - try { - AssetDefinitionId.write(writer, instance.`object`) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: RemoveKeyValueOfAssetDefinition): Unit = try { + AssetDefinitionId.write(writer, instance.`object`) + Name.write(writer, instance.key) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfDomain.kt index ff8e6d616..2c0efc675 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfDomain.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfDomain.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,11 +18,12 @@ import kotlin.Unit * * Generated from 'RemoveKeyValueOfDomain' regular structure */ -public data class RemoveKeyValueOfDomain( - public val `object`: DomainId, - public val key: Name, -) { - public companion object : ScaleReader, ScaleWriter { +public data class RemoveKeyValueOfDomain(public val `object`: DomainId, public val key: Name) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + + public companion object : + ScaleReader, + ScaleWriter { override fun read(reader: ScaleCodecReader): RemoveKeyValueOfDomain = try { RemoveKeyValueOfDomain( DomainId.read(reader), diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfTrigger.kt index a56c4aef6..d35598983 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfTrigger.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,10 +18,9 @@ import kotlin.Unit * * Generated from 'RemoveKeyValueOfTrigger' regular structure */ -public data class RemoveKeyValueOfTrigger( - public val `object`: TriggerId, - public val key: Name, -) { +public data class RemoveKeyValueOfTrigger(public val `object`: TriggerId, public val key: Name) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Repeats.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Repeats.kt index 3e24b8c18..d45e9ea0d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Repeats.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Repeats.kt @@ -28,11 +28,13 @@ public sealed class Repeats : ModelEnum { override fun equals(other: Any?): Boolean = when (this) { is Indefinitely -> Indefinitely.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is Indefinitely -> Indefinitely.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'Indefinitely' variant @@ -51,10 +53,7 @@ public sealed class Repeats : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Repeats.Indefinitely, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Repeats.Indefinitely): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -71,9 +70,7 @@ public sealed class Repeats : ModelEnum { /** * 'Exactly' variant */ - public data class Exactly( - public val u32: Long, - ) : Repeats() { + public data class Exactly(public val u32: Long) : Repeats() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -89,10 +86,7 @@ public sealed class Repeats : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.Repeats.Exactly, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Repeats.Exactly): Unit = try { writer.writeUint32(instance.u32) } catch (ex: Exception) { throw wrapException(ex) @@ -101,20 +95,19 @@ public sealed class Repeats : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Repeats = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): Repeats = when (val discriminant = reader.readUByte()) { 0 -> Indefinitely.read(reader) 1 -> Exactly.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: Repeats) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Indefinitely.write(writer, instance as Indefinitely) 1 -> Exactly.write(writer, instance as Exactly) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RepetitionError.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RepetitionError.kt index a06f9d5fb..c67694057 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RepetitionError.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RepetitionError.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'RepetitionError' regular structure */ -public data class RepetitionError( - public val instruction: InstructionType, - public val id: IdBox, -) { +public data class RepetitionError(public val instruction: InstructionType, public val id: IdBox) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): RepetitionError = try { RepetitionError( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeBox.kt index d33a4d908..33f5f7034 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeBox.kt @@ -26,9 +26,7 @@ public sealed class RevokeBox : ModelEnum { /** * 'Permission' variant */ - public data class Permission( - public val revokeOfPermissionAndAccount: RevokeOfPermissionAndAccount, - ) : RevokeBox() { + public data class Permission(public val revokeOfPermissionAndAccount: RevokeOfPermissionAndAccount) : RevokeBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class RevokeBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RevokeBox.Permission, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RevokeBox.Permission): Unit = try { RevokeOfPermissionAndAccount.write(writer, instance.revokeOfPermissionAndAccount) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class RevokeBox : ModelEnum { /** * 'Role' variant */ - public data class Role( - public val revokeOfRoleIdAndAccount: RevokeOfRoleIdAndAccount, - ) : RevokeBox() { + public data class Role(public val revokeOfRoleIdAndAccount: RevokeOfRoleIdAndAccount) : RevokeBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -68,19 +61,15 @@ public sealed class RevokeBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RevokeBox.Role = - try { - Role( - RevokeOfRoleIdAndAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RevokeBox.Role, - ): Unit = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RevokeBox.Role = try { + Role( + RevokeOfRoleIdAndAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RevokeBox.Role): Unit = try { RevokeOfRoleIdAndAccount.write(writer, instance.revokeOfRoleIdAndAccount) } catch (ex: Exception) { throw wrapException(ex) @@ -91,9 +80,7 @@ public sealed class RevokeBox : ModelEnum { /** * 'RolePermission' variant */ - public data class RolePermission( - public val revokeOfPermissionAndRole: RevokeOfPermissionAndRole, - ) : RevokeBox() { + public data class RolePermission(public val revokeOfPermissionAndRole: RevokeOfPermissionAndRole) : RevokeBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -109,10 +96,7 @@ public sealed class RevokeBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RevokeBox.RolePermission, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RevokeBox.RolePermission): Unit = try { RevokeOfPermissionAndRole.write(writer, instance.revokeOfPermissionAndRole) } catch (ex: Exception) { throw wrapException(ex) @@ -121,14 +105,12 @@ public sealed class RevokeBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RevokeBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): RevokeBox = when (val discriminant = reader.readUByte()) { 0 -> Permission.read(reader) 1 -> Role.read(reader) 2 -> RolePermission.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: RevokeBox) { writer.directWrite(instance.discriminant()) @@ -136,7 +118,8 @@ public sealed class RevokeBox : ModelEnum { 0 -> Permission.write(writer, instance as Permission) 1 -> Role.write(writer, instance as Role) 2 -> RolePermission.write(writer, instance as RolePermission) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeOfPermissionAndAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeOfPermissionAndAccount.kt index 4c9ad2cb6..badc72cc6 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeOfPermissionAndAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeOfPermissionAndAccount.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,10 +18,9 @@ import kotlin.Unit * * Generated from 'RevokeOfPermissionAndAccount' regular structure */ -public data class RevokeOfPermissionAndAccount( - public val `object`: Permission, - public val destination: AccountId, -) { +public data class RevokeOfPermissionAndAccount(public val `object`: Permission, public val destination: AccountId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeOfPermissionAndRole.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeOfPermissionAndRole.kt index 6fe6d70cd..7c982a6e2 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeOfPermissionAndRole.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeOfPermissionAndRole.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,10 +18,9 @@ import kotlin.Unit * * Generated from 'RevokeOfPermissionAndRole' regular structure */ -public data class RevokeOfPermissionAndRole( - public val `object`: Permission, - public val destination: RoleId, -) { +public data class RevokeOfPermissionAndRole(public val `object`: Permission, public val destination: RoleId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeOfRoleIdAndAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeOfRoleIdAndAccount.kt index 7387e7dec..8d7e4b732 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeOfRoleIdAndAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RevokeOfRoleIdAndAccount.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,10 +18,9 @@ import kotlin.Unit * * Generated from 'RevokeOfRoleIdAndAccount' regular structure */ -public data class RevokeOfRoleIdAndAccount( - public val `object`: RoleId, - public val destination: AccountId, -) { +public data class RevokeOfRoleIdAndAccount(public val `object`: RoleId, public val destination: AccountId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Role.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Role.kt index 4356646b9..a8bb409d4 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Role.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Role.kt @@ -17,10 +17,7 @@ import kotlin.collections.List * * Generated from 'Role' regular structure */ -public data class Role( - public val id: RoleId, - public val permissions: List, -) { +public data class Role(public val id: RoleId, public val permissions: List) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Role = try { Role( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleEvent.kt index aaba5e3b2..008679bf4 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleEvent.kt @@ -26,9 +26,7 @@ public sealed class RoleEvent : ModelEnum { /** * 'Created' variant */ - public data class Created( - public val role: Role, - ) : RoleEvent() { + public data class Created(public val role: Role) : RoleEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class RoleEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RoleEvent.Created, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RoleEvent.Created): Unit = try { Role.write(writer, instance.role) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class RoleEvent : ModelEnum { /** * 'Deleted' variant */ - public data class Deleted( - public val roleId: RoleId, - ) : RoleEvent() { + public data class Deleted(public val roleId: RoleId) : RoleEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class RoleEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RoleEvent.Deleted, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RoleEvent.Deleted): Unit = try { RoleId.write(writer, instance.roleId) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class RoleEvent : ModelEnum { /** * 'PermissionAdded' variant */ - public data class PermissionAdded( - public val rolePermissionChanged: RolePermissionChanged, - ) : RoleEvent() { + public data class PermissionAdded(public val rolePermissionChanged: RolePermissionChanged) : RoleEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,10 +96,7 @@ public sealed class RoleEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RoleEvent.PermissionAdded, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RoleEvent.PermissionAdded): Unit = try { RolePermissionChanged.write(writer, instance.rolePermissionChanged) } catch (ex: Exception) { throw wrapException(ex) @@ -122,9 +107,7 @@ public sealed class RoleEvent : ModelEnum { /** * 'PermissionRemoved' variant */ - public data class PermissionRemoved( - public val rolePermissionChanged: RolePermissionChanged, - ) : RoleEvent() { + public data class PermissionRemoved(public val rolePermissionChanged: RolePermissionChanged) : RoleEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,27 +123,23 @@ public sealed class RoleEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RoleEvent.PermissionRemoved, - ): Unit = try { - RolePermissionChanged.write(writer, instance.rolePermissionChanged) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RoleEvent.PermissionRemoved): Unit = + try { + RolePermissionChanged.write(writer, instance.rolePermissionChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RoleEvent = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): RoleEvent = when (val discriminant = reader.readUByte()) { 0 -> Created.read(reader) 1 -> Deleted.read(reader) 2 -> PermissionAdded.read(reader) 3 -> PermissionRemoved.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: RoleEvent) { writer.directWrite(instance.discriminant()) @@ -169,7 +148,8 @@ public sealed class RoleEvent : ModelEnum { 1 -> Deleted.write(writer, instance as Deleted) 2 -> PermissionAdded.write(writer, instance as PermissionAdded) 3 -> PermissionRemoved.write(writer, instance as PermissionRemoved) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleEventFilter.kt index 09e852602..da35ac4f8 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleEventFilter.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'RoleEventFilter' regular structure */ -public data class RoleEventFilter( - public val idMatcher: RoleId? = null, - public val eventSet: Long, -) { +public data class RoleEventFilter(public val idMatcher: RoleId? = null, public val eventSet: Long) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): RoleEventFilter = try { RoleEventFilter( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleId.kt index 4de915b52..4e419cec4 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleId.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'RoleId' regular structure */ -public data class RoleId( - public val name: Name, -) { +public data class RoleId(public val name: Name) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): RoleId = try { RoleId( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdPredicateAtom.kt new file mode 100644 index 000000000..c018bf6de --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdPredicateAtom.kt @@ -0,0 +1,68 @@ +// +// 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 + +/** + * RoleIdPredicateAtom + * + * Generated from 'RoleIdPredicateAtom' enum + */ +public sealed class RoleIdPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Equals' variant + */ + public data class Equals(public val roleId: RoleId) : RoleIdPredicateAtom() { + 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.RoleIdPredicateAtom.Equals = try { + Equals( + RoleId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RoleIdPredicateAtom.Equals): Unit = + try { + RoleId.write(writer, instance.roleId) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): RoleIdPredicateAtom = 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: RoleIdPredicateAtom) { + 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/RoleIdPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdProjectionOfPredicateMarker.kt similarity index 59% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdProjectionOfPredicateMarker.kt index b135134c4..3900b2b84 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdProjectionOfPredicateMarker.kt @@ -13,32 +13,30 @@ import kotlin.Int import kotlin.Unit /** - * RoleIdPredicateBox + * RoleIdProjectionOfPredicateMarker * - * Generated from 'RoleIdPredicateBox' enum + * Generated from 'RoleIdProjectionOfPredicateMarker' enum */ -public sealed class RoleIdPredicateBox : ModelEnum { +public sealed class RoleIdProjectionOfPredicateMarker : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int /** - * 'Equals' variant + * 'Atom' variant */ - public data class Equals( - public val roleId: RoleId, - ) : RoleIdPredicateBox() { + public data class Atom(public val roleIdPredicateAtom: RoleIdPredicateAtom) : RoleIdProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RoleIdPredicateBox.Equals = try { - Equals( - RoleId.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RoleIdProjectionOfPredicateMarker.Atom = try { + Atom( + RoleIdPredicateAtom.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -46,9 +44,9 @@ public sealed class RoleIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RoleIdPredicateBox.Equals, + instance: jp.co.soramitsu.iroha2.generated.RoleIdProjectionOfPredicateMarker.Atom, ): Unit = try { - RoleId.write(writer, instance.roleId) + RoleIdPredicateAtom.write(writer, instance.roleIdPredicateAtom) } catch (ex: Exception) { throw wrapException(ex) } @@ -58,19 +56,18 @@ public sealed class RoleIdPredicateBox : ModelEnum { /** * 'Name' variant */ - public data class Name( - public val stringPredicateBox: StringPredicateBox, - ) : RoleIdPredicateBox() { + public data class Name(public val nameProjectionOfPredicateMarker: NameProjectionOfPredicateMarker) : + RoleIdProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RoleIdPredicateBox.Name = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RoleIdProjectionOfPredicateMarker.Name = try { Name( - StringPredicateBox.read(reader), + NameProjectionOfPredicateMarker.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -78,30 +75,31 @@ public sealed class RoleIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RoleIdPredicateBox.Name, + instance: jp.co.soramitsu.iroha2.generated.RoleIdProjectionOfPredicateMarker.Name, ): Unit = try { - StringPredicateBox.write(writer, instance.stringPredicateBox) + NameProjectionOfPredicateMarker.write(writer, instance.nameProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } } } - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RoleIdPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Equals.read(reader) + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): RoleIdProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) 1 -> Name.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: RoleIdPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: RoleIdProjectionOfPredicateMarker) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Equals.write(writer, instance as Equals) + 0 -> Atom.write(writer, instance as Atom) 1 -> Name.write(writer, instance as Name) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..41a7d723d --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdProjectionOfSelectorMarker.kt @@ -0,0 +1,120 @@ +// +// 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 + +/** + * RoleIdProjectionOfSelectorMarker + * + * Generated from 'RoleIdProjectionOfSelectorMarker' enum + */ +public sealed class RoleIdProjectionOfSelectorMarker : 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 : RoleIdProjectionOfSelectorMarker() { + 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.RoleIdProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.RoleIdProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.RoleIdProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".RoleIdProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Name' variant + */ + public data class Name(public val nameProjectionOfSelectorMarker: NameProjectionOfSelectorMarker) : RoleIdProjectionOfSelectorMarker() { + 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.RoleIdProjectionOfSelectorMarker.Name = try { + Name( + NameProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.RoleIdProjectionOfSelectorMarker.Name, + ): Unit = try { + NameProjectionOfSelectorMarker.write(writer, instance.nameProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): RoleIdProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Name.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: RoleIdProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Name.write(writer, instance as Name) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RolePermissionChanged.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RolePermissionChanged.kt index 035ef8d14..b5b3be007 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RolePermissionChanged.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RolePermissionChanged.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'RolePermissionChanged' regular structure */ -public data class RolePermissionChanged( - public val role: RoleId, - public val permission: Permission, -) { +public data class RolePermissionChanged(public val role: RoleId, public val permission: Permission) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): RolePermissionChanged = try { RolePermissionChanged( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RolePredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RolePredicateAtom.kt new file mode 100644 index 000000000..9b639bf7d --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RolePredicateAtom.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 + +/** + * RolePredicateAtom + * + * Generated from 'RolePredicateAtom' enum + */ +public sealed class RolePredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): RolePredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: RolePredicateAtom) { + 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/RolePredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RolePredicateBox.kt deleted file mode 100644 index a7cbdd9a5..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RolePredicateBox.kt +++ /dev/null @@ -1,73 +0,0 @@ -// -// 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 - -/** - * RolePredicateBox - * - * Generated from 'RolePredicateBox' enum - */ -public sealed class RolePredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Id' variant - */ - public data class Id( - public val roleIdPredicateBox: RoleIdPredicateBox, - ) : RolePredicateBox() { - 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.RolePredicateBox.Id = try { - Id( - RoleIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RolePredicateBox.Id, - ): Unit = try { - RoleIdPredicateBox.write(writer, instance.roleIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RolePredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Id.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: RolePredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Id.write(writer, instance as Id) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..da91593b1 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleProjectionOfPredicateMarker.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 + +/** + * RoleProjectionOfPredicateMarker + * + * Generated from 'RoleProjectionOfPredicateMarker' enum + */ +public sealed class RoleProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val rolePredicateAtom: RolePredicateAtom) : RoleProjectionOfPredicateMarker() { + 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.RoleProjectionOfPredicateMarker.Atom = try { + Atom( + RolePredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.RoleProjectionOfPredicateMarker.Atom, + ): Unit = try { + RolePredicateAtom.write(writer, instance.rolePredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Id' variant + */ + public data class Id(public val roleIdProjectionOfPredicateMarker: RoleIdProjectionOfPredicateMarker) : + RoleProjectionOfPredicateMarker() { + 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.RoleProjectionOfPredicateMarker.Id = try { + Id( + RoleIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.RoleProjectionOfPredicateMarker.Id, + ): Unit = try { + RoleIdProjectionOfPredicateMarker.write(writer, instance.roleIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): RoleProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Id.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: RoleProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Id.write(writer, instance as Id) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..30e5f9937 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleProjectionOfSelectorMarker.kt @@ -0,0 +1,120 @@ +// +// 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 + +/** + * RoleProjectionOfSelectorMarker + * + * Generated from 'RoleProjectionOfSelectorMarker' enum + */ +public sealed class RoleProjectionOfSelectorMarker : 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 : RoleProjectionOfSelectorMarker() { + 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.RoleProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.RoleProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.RoleProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".RoleProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Id' variant + */ + public data class Id(public val roleIdProjectionOfSelectorMarker: RoleIdProjectionOfSelectorMarker) : RoleProjectionOfSelectorMarker() { + 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.RoleProjectionOfSelectorMarker.Id = try { + Id( + RoleIdProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.RoleProjectionOfSelectorMarker.Id, + ): Unit = try { + RoleIdProjectionOfSelectorMarker.write(writer, instance.roleIdProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): RoleProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Id.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: RoleProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Id.write(writer, instance as Id) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Schedule.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Schedule.kt index 32d3d9d0a..0a594f0a6 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Schedule.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Schedule.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'Schedule' regular structure */ -public data class Schedule( - public val startMs: BigInteger, - public val periodMs: BigInteger? = null, -) { +public data class Schedule(public val startMs: BigInteger, public val periodMs: BigInteger? = null) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Schedule = try { Schedule( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfAccount.kt new file mode 100644 index 000000000..d73f19dda --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfAccount.kt @@ -0,0 +1,40 @@ +// +// 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 +import kotlin.collections.List + +/** + * SelectorTupleOfAccount + * + * Generated from 'SelectorTupleOfAccount' regular structure + */ +public data class SelectorTupleOfAccount(public val vecOfAccountProjectionOfSelectorMarker: List) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfAccount = try { + SelectorTupleOfAccount( + reader.readVec(reader.readCompactInt()) { AccountProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfAccount): Unit = try { + writer.writeCompact(instance.vecOfAccountProjectionOfSelectorMarker.size) + instance.vecOfAccountProjectionOfSelectorMarker.forEach { value -> + AccountProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfAsset.kt new file mode 100644 index 000000000..1e0252f0e --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfAsset.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 +import kotlin.collections.List + +/** + * SelectorTupleOfAsset + * + * Generated from 'SelectorTupleOfAsset' regular structure + */ +public data class SelectorTupleOfAsset(public val vecOfAssetProjectionOfSelectorMarker: List) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfAsset = try { + SelectorTupleOfAsset( + reader.readVec(reader.readCompactInt()) { AssetProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfAsset): Unit = try { + writer.writeCompact(instance.vecOfAssetProjectionOfSelectorMarker.size) + instance.vecOfAssetProjectionOfSelectorMarker.forEach { value -> + AssetProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfAssetDefinition.kt new file mode 100644 index 000000000..b10b2435e --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfAssetDefinition.kt @@ -0,0 +1,42 @@ +// +// 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 +import kotlin.collections.List + +/** + * SelectorTupleOfAssetDefinition + * + * Generated from 'SelectorTupleOfAssetDefinition' regular structure + */ +public data class SelectorTupleOfAssetDefinition( + public val vecOfAssetDefinitionProjectionOfSelectorMarker: List, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfAssetDefinition = try { + SelectorTupleOfAssetDefinition( + reader.readVec(reader.readCompactInt()) { AssetDefinitionProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfAssetDefinition): Unit = try { + writer.writeCompact(instance.vecOfAssetDefinitionProjectionOfSelectorMarker.size) + instance.vecOfAssetDefinitionProjectionOfSelectorMarker.forEach { value -> + AssetDefinitionProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfBlockHeader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfBlockHeader.kt new file mode 100644 index 000000000..0977ca419 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfBlockHeader.kt @@ -0,0 +1,42 @@ +// +// 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 +import kotlin.collections.List + +/** + * SelectorTupleOfBlockHeader + * + * Generated from 'SelectorTupleOfBlockHeader' regular structure + */ +public data class SelectorTupleOfBlockHeader( + public val vecOfBlockHeaderProjectionOfSelectorMarker: List, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfBlockHeader = try { + SelectorTupleOfBlockHeader( + reader.readVec(reader.readCompactInt()) { BlockHeaderProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfBlockHeader): Unit = try { + writer.writeCompact(instance.vecOfBlockHeaderProjectionOfSelectorMarker.size) + instance.vecOfBlockHeaderProjectionOfSelectorMarker.forEach { value -> + BlockHeaderProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfCommittedTransaction.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfCommittedTransaction.kt new file mode 100644 index 000000000..781254802 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfCommittedTransaction.kt @@ -0,0 +1,42 @@ +// +// 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 +import kotlin.collections.List + +/** + * SelectorTupleOfCommittedTransaction + * + * Generated from 'SelectorTupleOfCommittedTransaction' regular structure + */ +public data class SelectorTupleOfCommittedTransaction( + public val vecOfCommittedTransactionProjectionOfSelectorMarker: List, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfCommittedTransaction = try { + SelectorTupleOfCommittedTransaction( + reader.readVec(reader.readCompactInt()) { CommittedTransactionProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfCommittedTransaction): Unit = try { + writer.writeCompact(instance.vecOfCommittedTransactionProjectionOfSelectorMarker.size) + instance.vecOfCommittedTransactionProjectionOfSelectorMarker.forEach { value -> + CommittedTransactionProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfDomain.kt new file mode 100644 index 000000000..821339573 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfDomain.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 +import kotlin.collections.List + +/** + * SelectorTupleOfDomain + * + * Generated from 'SelectorTupleOfDomain' regular structure + */ +public data class SelectorTupleOfDomain(public val vecOfDomainProjectionOfSelectorMarker: List) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfDomain = try { + SelectorTupleOfDomain( + reader.readVec(reader.readCompactInt()) { DomainProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfDomain): Unit = try { + writer.writeCompact(instance.vecOfDomainProjectionOfSelectorMarker.size) + instance.vecOfDomainProjectionOfSelectorMarker.forEach { value -> + DomainProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfPeerId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfPeerId.kt new file mode 100644 index 000000000..6559a401c --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfPeerId.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 +import kotlin.collections.List + +/** + * SelectorTupleOfPeerId + * + * Generated from 'SelectorTupleOfPeerId' regular structure + */ +public data class SelectorTupleOfPeerId(public val vecOfPeerIdProjectionOfSelectorMarker: List) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfPeerId = try { + SelectorTupleOfPeerId( + reader.readVec(reader.readCompactInt()) { PeerIdProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfPeerId): Unit = try { + writer.writeCompact(instance.vecOfPeerIdProjectionOfSelectorMarker.size) + instance.vecOfPeerIdProjectionOfSelectorMarker.forEach { value -> + PeerIdProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfPermission.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfPermission.kt new file mode 100644 index 000000000..f02fdb5d9 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfPermission.kt @@ -0,0 +1,42 @@ +// +// 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 +import kotlin.collections.List + +/** + * SelectorTupleOfPermission + * + * Generated from 'SelectorTupleOfPermission' regular structure + */ +public data class SelectorTupleOfPermission( + public val vecOfPermissionProjectionOfSelectorMarker: List, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfPermission = try { + SelectorTupleOfPermission( + reader.readVec(reader.readCompactInt()) { PermissionProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfPermission): Unit = try { + writer.writeCompact(instance.vecOfPermissionProjectionOfSelectorMarker.size) + instance.vecOfPermissionProjectionOfSelectorMarker.forEach { value -> + PermissionProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfRole.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfRole.kt new file mode 100644 index 000000000..f49ca9ee4 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfRole.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 +import kotlin.collections.List + +/** + * SelectorTupleOfRole + * + * Generated from 'SelectorTupleOfRole' regular structure + */ +public data class SelectorTupleOfRole(public val vecOfRoleProjectionOfSelectorMarker: List) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfRole = try { + SelectorTupleOfRole( + reader.readVec(reader.readCompactInt()) { RoleProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfRole): Unit = try { + writer.writeCompact(instance.vecOfRoleProjectionOfSelectorMarker.size) + instance.vecOfRoleProjectionOfSelectorMarker.forEach { value -> + RoleProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfRoleId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfRoleId.kt new file mode 100644 index 000000000..abddd942e --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfRoleId.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 +import kotlin.collections.List + +/** + * SelectorTupleOfRoleId + * + * Generated from 'SelectorTupleOfRoleId' regular structure + */ +public data class SelectorTupleOfRoleId(public val vecOfRoleIdProjectionOfSelectorMarker: List) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfRoleId = try { + SelectorTupleOfRoleId( + reader.readVec(reader.readCompactInt()) { RoleIdProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfRoleId): Unit = try { + writer.writeCompact(instance.vecOfRoleIdProjectionOfSelectorMarker.size) + instance.vecOfRoleIdProjectionOfSelectorMarker.forEach { value -> + RoleIdProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfSignedBlock.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfSignedBlock.kt new file mode 100644 index 000000000..629adf434 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfSignedBlock.kt @@ -0,0 +1,42 @@ +// +// 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 +import kotlin.collections.List + +/** + * SelectorTupleOfSignedBlock + * + * Generated from 'SelectorTupleOfSignedBlock' regular structure + */ +public data class SelectorTupleOfSignedBlock( + public val vecOfSignedBlockProjectionOfSelectorMarker: List, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfSignedBlock = try { + SelectorTupleOfSignedBlock( + reader.readVec(reader.readCompactInt()) { SignedBlockProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfSignedBlock): Unit = try { + writer.writeCompact(instance.vecOfSignedBlockProjectionOfSelectorMarker.size) + instance.vecOfSignedBlockProjectionOfSelectorMarker.forEach { value -> + SignedBlockProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfTrigger.kt new file mode 100644 index 000000000..d07fd08fe --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfTrigger.kt @@ -0,0 +1,40 @@ +// +// 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 +import kotlin.collections.List + +/** + * SelectorTupleOfTrigger + * + * Generated from 'SelectorTupleOfTrigger' regular structure + */ +public data class SelectorTupleOfTrigger(public val vecOfTriggerProjectionOfSelectorMarker: List) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfTrigger = try { + SelectorTupleOfTrigger( + reader.readVec(reader.readCompactInt()) { TriggerProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfTrigger): Unit = try { + writer.writeCompact(instance.vecOfTriggerProjectionOfSelectorMarker.size) + instance.vecOfTriggerProjectionOfSelectorMarker.forEach { value -> + TriggerProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfTriggerId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfTriggerId.kt new file mode 100644 index 000000000..7ba3b750a --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfTriggerId.kt @@ -0,0 +1,42 @@ +// +// 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 +import kotlin.collections.List + +/** + * SelectorTupleOfTriggerId + * + * Generated from 'SelectorTupleOfTriggerId' regular structure + */ +public data class SelectorTupleOfTriggerId( + public val vecOfTriggerIdProjectionOfSelectorMarker: List, +) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SelectorTupleOfTriggerId = try { + SelectorTupleOfTriggerId( + reader.readVec(reader.readCompactInt()) { TriggerIdProjectionOfSelectorMarker.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write(writer: ScaleCodecWriter, instance: SelectorTupleOfTriggerId): Unit = try { + writer.writeCompact(instance.vecOfTriggerIdProjectionOfSelectorMarker.size) + instance.vecOfTriggerIdProjectionOfSelectorMarker.forEach { value -> + TriggerIdProjectionOfSelectorMarker.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SemiIntervalOfNumeric.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SemiIntervalOfNumeric.kt deleted file mode 100644 index 1a07dae75..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SemiIntervalOfNumeric.kt +++ /dev/null @@ -1,39 +0,0 @@ -// -// 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 - -/** - * SemiIntervalOfNumeric - * - * Generated from 'SemiIntervalOfNumeric' regular structure - */ -public data class SemiIntervalOfNumeric( - public val start: Numeric, - public val limit: Numeric, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SemiIntervalOfNumeric = try { - SemiIntervalOfNumeric( - Numeric.read(reader), - Numeric.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: SemiIntervalOfNumeric): Unit = try { - Numeric.write(writer, instance.start) - Numeric.write(writer, instance.limit) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SemiIntervalOfu128.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SemiIntervalOfu128.kt deleted file mode 100644 index 92df5d35e..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SemiIntervalOfu128.kt +++ /dev/null @@ -1,40 +0,0 @@ -// -// 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 java.math.BigInteger -import kotlin.Unit - -/** - * SemiIntervalOfu128 - * - * Generated from 'SemiIntervalOfu128' regular structure - */ -public data class SemiIntervalOfu128( - public val start: BigInteger, - public val limit: BigInteger, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SemiIntervalOfu128 = try { - SemiIntervalOfu128( - reader.readUint128(), - reader.readUint128(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: SemiIntervalOfu128): Unit = try { - writer.writeUint128(instance.start) - writer.writeUint128(instance.limit) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SemiRange.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SemiRange.kt deleted file mode 100644 index c562ab382..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SemiRange.kt +++ /dev/null @@ -1,73 +0,0 @@ -// -// 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 - -/** - * SemiRange - * - * Generated from 'SemiRange' enum - */ -public sealed class SemiRange : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Numeric' variant - */ - public data class Numeric( - public val semiIntervalOfNumeric: SemiIntervalOfNumeric, - ) : SemiRange() { - 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.SemiRange.Numeric = try { - Numeric( - SemiIntervalOfNumeric.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SemiRange.Numeric, - ): Unit = try { - SemiIntervalOfNumeric.write(writer, instance.semiIntervalOfNumeric) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SemiRange = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Numeric.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: SemiRange) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Numeric.write(writer, instance as Numeric) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueBox.kt index c19a76f64..8de3dea71 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueBox.kt @@ -26,9 +26,7 @@ public sealed class SetKeyValueBox : ModelEnum { /** * 'Domain' variant */ - public data class Domain( - public val setKeyValueOfDomain: SetKeyValueOfDomain, - ) : SetKeyValueBox() { + public data class Domain(public val setKeyValueOfDomain: SetKeyValueOfDomain) : SetKeyValueBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class SetKeyValueBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Domain, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Domain): Unit = try { SetKeyValueOfDomain.write(writer, instance.setKeyValueOfDomain) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class SetKeyValueBox : ModelEnum { /** * 'Account' variant */ - public data class Account( - public val setKeyValueOfAccount: SetKeyValueOfAccount, - ) : SetKeyValueBox() { + public data class Account(public val setKeyValueOfAccount: SetKeyValueOfAccount) : SetKeyValueBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class SetKeyValueBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Account, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Account): Unit = try { SetKeyValueOfAccount.write(writer, instance.setKeyValueOfAccount) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class SetKeyValueBox : ModelEnum { /** * 'AssetDefinition' variant */ - public data class AssetDefinition( - public val setKeyValueOfAssetDefinition: SetKeyValueOfAssetDefinition, - ) : SetKeyValueBox() { + public data class AssetDefinition(public val setKeyValueOfAssetDefinition: SetKeyValueOfAssetDefinition) : SetKeyValueBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,23 +96,19 @@ public sealed class SetKeyValueBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SetKeyValueBox.AssetDefinition, - ): Unit = try { - SetKeyValueOfAssetDefinition.write(writer, instance.setKeyValueOfAssetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SetKeyValueBox.AssetDefinition): Unit = + try { + SetKeyValueOfAssetDefinition.write(writer, instance.setKeyValueOfAssetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Asset' variant */ - public data class Asset( - public val setKeyValueOfAsset: SetKeyValueOfAsset, - ) : SetKeyValueBox() { + public data class Asset(public val setKeyValueOfAsset: SetKeyValueOfAsset) : SetKeyValueBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,10 +124,7 @@ public sealed class SetKeyValueBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Asset, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Asset): Unit = try { SetKeyValueOfAsset.write(writer, instance.setKeyValueOfAsset) } catch (ex: Exception) { throw wrapException(ex) @@ -154,9 +135,7 @@ public sealed class SetKeyValueBox : ModelEnum { /** * 'Trigger' variant */ - public data class Trigger( - public val setKeyValueOfTrigger: SetKeyValueOfTrigger, - ) : SetKeyValueBox() { + public data class Trigger(public val setKeyValueOfTrigger: SetKeyValueOfTrigger) : SetKeyValueBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -172,10 +151,7 @@ public sealed class SetKeyValueBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Trigger, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Trigger): Unit = try { SetKeyValueOfTrigger.write(writer, instance.setKeyValueOfTrigger) } catch (ex: Exception) { throw wrapException(ex) @@ -184,16 +160,14 @@ public sealed class SetKeyValueBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SetKeyValueBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): SetKeyValueBox = when (val discriminant = reader.readUByte()) { 0 -> Domain.read(reader) 1 -> Account.read(reader) 2 -> AssetDefinition.read(reader) 3 -> Asset.read(reader) 4 -> Trigger.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: SetKeyValueBox) { writer.directWrite(instance.discriminant()) @@ -203,7 +177,8 @@ public sealed class SetKeyValueBox : ModelEnum { 2 -> AssetDefinition.write(writer, instance as AssetDefinition) 3 -> Asset.write(writer, instance as Asset) 4 -> Trigger.write(writer, instance as Trigger) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfAccount.kt index efad75449..7239507f6 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfAccount.kt @@ -3,12 +3,14 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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.String import kotlin.Unit /** @@ -19,14 +21,16 @@ import kotlin.Unit public data class SetKeyValueOfAccount( public val `object`: AccountId, public val key: Name, - public val `value`: String, -) { + public val `value`: Json, +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SetKeyValueOfAccount = try { SetKeyValueOfAccount( AccountId.read(reader), Name.read(reader), - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -35,7 +39,7 @@ public data class SetKeyValueOfAccount( override fun write(writer: ScaleCodecWriter, instance: SetKeyValueOfAccount): Unit = try { AccountId.write(writer, instance.`object`) Name.write(writer, instance.key) - writer.writeAsList(instance.`value`.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.`value`) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfAsset.kt index 2320c7fb3..68fba513d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfAsset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfAsset.kt @@ -3,12 +3,14 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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.String import kotlin.Unit /** @@ -19,14 +21,16 @@ import kotlin.Unit public data class SetKeyValueOfAsset( public val `object`: AssetId, public val key: Name, - public val `value`: String, -) { + public val `value`: Json, +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SetKeyValueOfAsset = try { SetKeyValueOfAsset( AssetId.read(reader), Name.read(reader), - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -35,7 +39,7 @@ public data class SetKeyValueOfAsset( override fun write(writer: ScaleCodecWriter, instance: SetKeyValueOfAsset): Unit = try { AssetId.write(writer, instance.`object`) Name.write(writer, instance.key) - writer.writeAsList(instance.`value`.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.`value`) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfAssetDefinition.kt index eb8709d8a..9015dd240 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfAssetDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfAssetDefinition.kt @@ -3,12 +3,14 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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.String import kotlin.Unit /** @@ -19,8 +21,10 @@ import kotlin.Unit public data class SetKeyValueOfAssetDefinition( public val `object`: AssetDefinitionId, public val key: Name, - public val `value`: String, -) { + public val `value`: Json, +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { @@ -28,7 +32,7 @@ public data class SetKeyValueOfAssetDefinition( SetKeyValueOfAssetDefinition( AssetDefinitionId.read(reader), Name.read(reader), - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -37,7 +41,7 @@ public data class SetKeyValueOfAssetDefinition( override fun write(writer: ScaleCodecWriter, instance: SetKeyValueOfAssetDefinition): Unit = try { AssetDefinitionId.write(writer, instance.`object`) Name.write(writer, instance.key) - writer.writeAsList(instance.`value`.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.`value`) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfDomain.kt index 10db30b74..c9b9fea33 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfDomain.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfDomain.kt @@ -3,12 +3,14 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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.String import kotlin.Unit /** @@ -19,14 +21,16 @@ import kotlin.Unit public data class SetKeyValueOfDomain( public val `object`: DomainId, public val key: Name, - public val `value`: String, -) { + public val `value`: Json, +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SetKeyValueOfDomain = try { SetKeyValueOfDomain( DomainId.read(reader), Name.read(reader), - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -35,7 +39,7 @@ public data class SetKeyValueOfDomain( override fun write(writer: ScaleCodecWriter, instance: SetKeyValueOfDomain): Unit = try { DomainId.write(writer, instance.`object`) Name.write(writer, instance.key) - writer.writeAsList(instance.`value`.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.`value`) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfTrigger.kt index 4fdf66491..6d1962ce9 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SetKeyValueOfTrigger.kt @@ -3,12 +3,14 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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.String import kotlin.Unit /** @@ -19,14 +21,16 @@ import kotlin.Unit public data class SetKeyValueOfTrigger( public val `object`: TriggerId, public val key: Name, - public val `value`: String, -) { + public val `value`: Json, +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SetKeyValueOfTrigger = try { SetKeyValueOfTrigger( TriggerId.read(reader), Name.read(reader), - reader.readString(), + Json.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -35,7 +39,7 @@ public data class SetKeyValueOfTrigger( override fun write(writer: ScaleCodecWriter, instance: SetKeyValueOfTrigger): Unit = try { TriggerId.write(writer, instance.`object`) Name.write(writer, instance.key) - writer.writeAsList(instance.`value`.toByteArray(Charsets.UTF_8)) + Json.write(writer, instance.`value`) } catch (ex: Exception) { throw wrapException(ex) } 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 6c4bf13ac..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 @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'SetParameter' regular structure */ -public data class SetParameter( - public val parameter: Parameter, -) { +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/Signature.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Signature.kt index 0a4d8663c..1cfc3e272 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Signature.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Signature.kt @@ -19,9 +19,7 @@ import kotlin.Unit * * Generated from 'Signature' regular structure */ -public data class Signature( - public val payload: ByteArray, -) { +public data class Signature(public val payload: ByteArray) { override fun equals(other: Any?): Boolean { if (this === other) return true if (other !is Signature) return false diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignatureOf.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignatureOf.kt index 20e1027d8..a1a4960e0 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignatureOf.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignatureOf.kt @@ -16,9 +16,7 @@ import kotlin.Unit * * Generated from 'SignatureOf' regular structure */ -public data class SignatureOf( - public val signature: Signature, -) { +public data class SignatureOf(public val signature: Signature) { public companion object : ScaleReader>, ScaleWriter> { override fun read(reader: ScaleCodecReader): SignatureOf = try { SignatureOf( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlock.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlock.kt index 78e399da4..c0b1eb3a1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlock.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlock.kt @@ -26,9 +26,7 @@ public sealed class SignedBlock : ModelEnum { /** * 'V1' variant */ - public data class V1( - public val signedBlockV1: SignedBlockV1, - ) : SignedBlock() { + public data class V1(public val signedBlockV1: SignedBlockV1) : SignedBlock() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -36,19 +34,15 @@ public sealed class SignedBlock : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SignedBlock.V1 = - try { - V1( - SignedBlockV1.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SignedBlock.V1 = try { + V1( + SignedBlockV1.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SignedBlock.V1, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SignedBlock.V1): Unit = try { SignedBlockV1.write(writer, instance.signedBlockV1) } catch (ex: Exception) { throw wrapException(ex) @@ -57,18 +51,17 @@ public sealed class SignedBlock : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SignedBlock = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): SignedBlock = when (val discriminant = reader.readUByte()) { 1 -> V1.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: SignedBlock) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 1 -> V1.write(writer, instance as V1) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockPredicateAtom.kt new file mode 100644 index 000000000..c4aa2520d --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockPredicateAtom.kt @@ -0,0 +1,38 @@ +// +// 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 + +/** + * SignedBlockPredicateAtom + * + * Generated from 'SignedBlockPredicateAtom' enum + */ +public sealed class SignedBlockPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SignedBlockPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: SignedBlockPredicateAtom) { + 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/SignedBlockProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..cf76b9076 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockProjectionOfPredicateMarker.kt @@ -0,0 +1,107 @@ +// +// 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 + +/** + * SignedBlockProjectionOfPredicateMarker + * + * Generated from 'SignedBlockProjectionOfPredicateMarker' enum + */ +public sealed class SignedBlockProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val signedBlockPredicateAtom: SignedBlockPredicateAtom) : SignedBlockProjectionOfPredicateMarker() { + 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.SignedBlockProjectionOfPredicateMarker.Atom = + try { + Atom( + SignedBlockPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.SignedBlockProjectionOfPredicateMarker.Atom, + ): Unit = try { + SignedBlockPredicateAtom.write(writer, instance.signedBlockPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Header' variant + */ + public data class Header(public val blockHeaderProjectionOfPredicateMarker: BlockHeaderProjectionOfPredicateMarker) : + SignedBlockProjectionOfPredicateMarker() { + 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.SignedBlockProjectionOfPredicateMarker.Header = + try { + Header( + BlockHeaderProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.SignedBlockProjectionOfPredicateMarker.Header, + ): Unit = try { + BlockHeaderProjectionOfPredicateMarker.write(writer, instance.blockHeaderProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SignedBlockProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Header.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: SignedBlockProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Header.write(writer, instance as Header) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..a352674a0 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockProjectionOfSelectorMarker.kt @@ -0,0 +1,123 @@ +// +// 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 + +/** + * SignedBlockProjectionOfSelectorMarker + * + * Generated from 'SignedBlockProjectionOfSelectorMarker' enum + */ +public sealed class SignedBlockProjectionOfSelectorMarker : 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 : SignedBlockProjectionOfSelectorMarker() { + 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.SignedBlockProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.SignedBlockProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.SignedBlockProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".SignedBlockProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Header' variant + */ + public data class Header(public val blockHeaderProjectionOfSelectorMarker: BlockHeaderProjectionOfSelectorMarker) : + SignedBlockProjectionOfSelectorMarker() { + 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.SignedBlockProjectionOfSelectorMarker.Header = + try { + Header( + BlockHeaderProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.SignedBlockProjectionOfSelectorMarker.Header, + ): Unit = try { + BlockHeaderProjectionOfSelectorMarker.write(writer, instance.blockHeaderProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SignedBlockProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Header.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: SignedBlockProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Header.write(writer, instance as Header) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockV1.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockV1.kt index 01a858097..c982369b4 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockV1.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockV1.kt @@ -8,8 +8,10 @@ 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 java.math.BigInteger import kotlin.Unit import kotlin.collections.List +import kotlin.collections.Map /** * SignedBlockV1 @@ -19,12 +21,14 @@ import kotlin.collections.List public data class SignedBlockV1( public val signatures: List, public val payload: BlockPayload, + public val errors: Map, ) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SignedBlockV1 = try { SignedBlockV1( reader.readVec(reader.readCompactInt()) { BlockSignature.read(reader) }, BlockPayload.read(reader), + reader.readMap(reader.readCompactInt(), { reader.readUint64() }, { TransactionRejectionReason.read(reader) }), ) } catch (ex: Exception) { throw wrapException(ex) @@ -36,6 +40,11 @@ public data class SignedBlockV1( BlockSignature.write(writer, value) } BlockPayload.write(writer, instance.payload) + writer.writeCompact(instance.errors.size) + instance.errors.toSortedMap().forEach { (key, value) -> + writer.writeUint64(key) + TransactionRejectionReason.write(writer, value) + } } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedQuery.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedQuery.kt index 5a7bb5853..bd2ccdc0d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedQuery.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedQuery.kt @@ -26,9 +26,7 @@ public sealed class SignedQuery : ModelEnum { /** * 'V1' variant */ - public data class V1( - public val signedQueryV1: SignedQueryV1, - ) : SignedQuery() { + public data class V1(public val signedQueryV1: SignedQueryV1) : SignedQuery() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -36,19 +34,15 @@ public sealed class SignedQuery : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SignedQuery.V1 = - try { - V1( - SignedQueryV1.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SignedQuery.V1 = try { + V1( + SignedQueryV1.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SignedQuery.V1, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SignedQuery.V1): Unit = try { SignedQueryV1.write(writer, instance.signedQueryV1) } catch (ex: Exception) { throw wrapException(ex) @@ -57,18 +51,17 @@ public sealed class SignedQuery : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SignedQuery = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): SignedQuery = when (val discriminant = reader.readUByte()) { 1 -> V1.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: SignedQuery) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 1 -> V1.write(writer, instance as V1) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedQueryV1.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedQueryV1.kt index 26b05dc30..8411736d0 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedQueryV1.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedQueryV1.kt @@ -15,15 +15,12 @@ import kotlin.Unit * * Generated from 'SignedQueryV1' regular structure */ -public data class SignedQueryV1( - public val signature: QuerySignature, - public val payload: ClientQueryPayload, -) { +public data class SignedQueryV1(public val signature: QuerySignature, public val payload: QueryRequestWithAuthority) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SignedQueryV1 = try { SignedQueryV1( QuerySignature.read(reader), - ClientQueryPayload.read(reader), + QueryRequestWithAuthority.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -31,7 +28,7 @@ public data class SignedQueryV1( override fun write(writer: ScaleCodecWriter, instance: SignedQueryV1): Unit = try { QuerySignature.write(writer, instance.signature) - ClientQueryPayload.write(writer, instance.payload) + QueryRequestWithAuthority.write(writer, instance.payload) } catch (ex: Exception) { throw wrapException(ex) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransaction.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransaction.kt index 18c1ad006..02b098b02 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransaction.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransaction.kt @@ -26,9 +26,7 @@ public sealed class SignedTransaction : ModelEnum { /** * 'V1' variant */ - public data class V1( - public val signedTransactionV1: SignedTransactionV1, - ) : SignedTransaction() { + public data class V1(public val signedTransactionV1: SignedTransactionV1) : SignedTransaction() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class SignedTransaction : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SignedTransaction.V1, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SignedTransaction.V1): Unit = try { SignedTransactionV1.write(writer, instance.signedTransactionV1) } catch (ex: Exception) { throw wrapException(ex) @@ -56,18 +51,17 @@ public sealed class SignedTransaction : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SignedTransaction = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): SignedTransaction = when (val discriminant = reader.readUByte()) { 1 -> V1.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: SignedTransaction) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 1 -> V1.write(writer, instance as V1) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionPredicateAtom.kt new file mode 100644 index 000000000..54b9f7448 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionPredicateAtom.kt @@ -0,0 +1,38 @@ +// +// 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 + +/** + * SignedTransactionPredicateAtom + * + * Generated from 'SignedTransactionPredicateAtom' enum + */ +public sealed class SignedTransactionPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SignedTransactionPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: SignedTransactionPredicateAtom) { + 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/SignedTransactionPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionPredicateBox.kt deleted file mode 100644 index 14b8caa70..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionPredicateBox.kt +++ /dev/null @@ -1,109 +0,0 @@ -// -// 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 - -/** - * SignedTransactionPredicateBox - * - * Generated from 'SignedTransactionPredicateBox' enum - */ -public sealed class SignedTransactionPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Hash' variant - */ - public data class Hash( - public val transactionHashPredicateBox: TransactionHashPredicateBox, - ) : SignedTransactionPredicateBox() { - 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.SignedTransactionPredicateBox.Hash = try { - Hash( - TransactionHashPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SignedTransactionPredicateBox.Hash, - ): Unit = try { - TransactionHashPredicateBox.write(writer, instance.transactionHashPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Authority' variant - */ - public data class Authority( - public val accountIdPredicateBox: AccountIdPredicateBox, - ) : SignedTransactionPredicateBox() { - 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.SignedTransactionPredicateBox.Authority = try { - Authority( - AccountIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SignedTransactionPredicateBox.Authority, - ): Unit = try { - AccountIdPredicateBox.write(writer, instance.accountIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): SignedTransactionPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { - 0 -> Hash.read(reader) - 1 -> Authority.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: SignedTransactionPredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Hash.write(writer, instance as Hash) - 1 -> Authority.write(writer, instance as Authority) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..e268ca68f --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionProjectionOfPredicateMarker.kt @@ -0,0 +1,146 @@ +// +// 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 + +/** + * SignedTransactionProjectionOfPredicateMarker + * + * Generated from 'SignedTransactionProjectionOfPredicateMarker' enum + */ +public sealed class SignedTransactionProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val signedTransactionPredicateAtom: SignedTransactionPredicateAtom) : + SignedTransactionProjectionOfPredicateMarker() { + 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.SignedTransactionProjectionOfPredicateMarker.Atom = try { + Atom( + SignedTransactionPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.SignedTransactionProjectionOfPredicateMarker.Atom, + ): Unit = try { + SignedTransactionPredicateAtom.write(writer, instance.signedTransactionPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Hash' variant + */ + public data class Hash(public val transactionHashProjectionOfPredicateMarker: TransactionHashProjectionOfPredicateMarker) : + SignedTransactionProjectionOfPredicateMarker() { + 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.SignedTransactionProjectionOfPredicateMarker.Hash = try { + Hash( + TransactionHashProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.SignedTransactionProjectionOfPredicateMarker.Hash, + ): Unit = try { + TransactionHashProjectionOfPredicateMarker.write(writer, instance.transactionHashProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Authority' variant + */ + public data class Authority(public val accountIdProjectionOfPredicateMarker: AccountIdProjectionOfPredicateMarker) : + SignedTransactionProjectionOfPredicateMarker() { + 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.SignedTransactionProjectionOfPredicateMarker.Authority = try { + Authority( + AccountIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.SignedTransactionProjectionOfPredicateMarker.Authority, + ): Unit = try { + AccountIdProjectionOfPredicateMarker.write(writer, instance.accountIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SignedTransactionProjectionOfPredicateMarker = + when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Hash.read(reader) + 2 -> Authority.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: SignedTransactionProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Hash.write(writer, instance as Hash) + 2 -> Authority.write(writer, instance as Authority) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..e6b324b13 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionProjectionOfSelectorMarker.kt @@ -0,0 +1,160 @@ +// +// 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 + +/** + * SignedTransactionProjectionOfSelectorMarker + * + * Generated from 'SignedTransactionProjectionOfSelectorMarker' enum + */ +public sealed class SignedTransactionProjectionOfSelectorMarker : 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 : SignedTransactionProjectionOfSelectorMarker() { + 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.SignedTransactionProjectionOfSelectorMarker.Atom = + try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.SignedTransactionProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.SignedTransactionProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".SignedTransactionProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Hash' variant + */ + public data class Hash(public val transactionHashProjectionOfSelectorMarker: TransactionHashProjectionOfSelectorMarker) : + SignedTransactionProjectionOfSelectorMarker() { + 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.SignedTransactionProjectionOfSelectorMarker.Hash = + try { + Hash( + TransactionHashProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.SignedTransactionProjectionOfSelectorMarker.Hash, + ): Unit = try { + TransactionHashProjectionOfSelectorMarker.write(writer, instance.transactionHashProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Authority' variant + */ + public data class Authority(public val accountIdProjectionOfSelectorMarker: AccountIdProjectionOfSelectorMarker) : + SignedTransactionProjectionOfSelectorMarker() { + 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.SignedTransactionProjectionOfSelectorMarker.Authority = try { + Authority( + AccountIdProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.SignedTransactionProjectionOfSelectorMarker.Authority, + ): Unit = try { + AccountIdProjectionOfSelectorMarker.write(writer, instance.accountIdProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SignedTransactionProjectionOfSelectorMarker = + when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Hash.read(reader) + 2 -> Authority.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: SignedTransactionProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Hash.write(writer, instance as Hash) + 2 -> Authority.write(writer, instance as Authority) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionV1.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionV1.kt index b34eb9e7b..176173253 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionV1.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionV1.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'SignedTransactionV1' regular structure */ -public data class SignedTransactionV1( - public val signature: TransactionSignature, - public val payload: TransactionPayload, -) { +public data class SignedTransactionV1(public val signature: TransactionSignature, public val payload: TransactionPayload) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SignedTransactionV1 = try { SignedTransactionV1( 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 ec13110e5..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,54 +23,17 @@ 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 */ - public data class FindExecutorDataModel( - public val findExecutorDataModel: jp.co.soramitsu.iroha2.generated.FindExecutorDataModel, - ) : SingularQueryBox() { + public data class FindExecutorDataModel(public val findExecutorDataModel: jp.co.soramitsu.iroha2.generated.FindExecutorDataModel) : + SingularQueryBox() { override fun discriminant(): Int = DISCRIMINANT 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( @@ -83,30 +46,24 @@ public sealed class SingularQueryBox : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindExecutorDataModel, - ): Unit = - try { - jp.co.soramitsu.iroha2.generated.FindExecutorDataModel.write( - writer, - instance.findExecutorDataModel, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = try { + jp.co.soramitsu.iroha2.generated.FindExecutorDataModel.write(writer, instance.findExecutorDataModel) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'FindParameters' variant */ - public data class FindParameters( - public val findParameters: jp.co.soramitsu.iroha2.generated.FindParameters, - ) : SingularQueryBox() { + public data class FindParameters(public val findParameters: jp.co.soramitsu.iroha2.generated.FindParameters) : SingularQueryBox() { override fun discriminant(): Int = DISCRIMINANT 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( @@ -116,187 +73,9 @@ public sealed class SingularQueryBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindParameters, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindParameters.write(writer, instance.findParameters) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * '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 = + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindParameters): 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, - ) + jp.co.soramitsu.iroha2.generated.FindParameters.write(writer, instance.findParameters) } catch (ex: Exception) { throw wrapException(ex) } @@ -304,32 +83,19 @@ public sealed class SingularQueryBox : ModelEnum { } 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) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + override fun read(reader: ScaleCodecReader): SingularQueryBox = when (val discriminant = reader.readUByte()) { + 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) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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 8e21942a4..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 @@ -10,7 +10,6 @@ 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.String import kotlin.Unit /** @@ -24,50 +23,17 @@ 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 */ - public data class ExecutorDataModel( - public val executorDataModel: jp.co.soramitsu.iroha2.generated.ExecutorDataModel, - ) : SingularQueryOutputBox() { + public data class ExecutorDataModel(public val executorDataModel: jp.co.soramitsu.iroha2.generated.ExecutorDataModel) : + SingularQueryOutputBox() { override fun discriminant(): Int = DISCRIMINANT 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( @@ -88,82 +54,16 @@ public sealed class SingularQueryOutputBox : ModelEnum { } } - /** - * 'JsonString' variant - */ - public data class JsonString( - public val string: String, - ) : 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.JsonString = try { - JsonString( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.JsonString, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } 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 */ - public data class Parameters( - public val parameters: jp.co.soramitsu.iroha2.generated.Parameters, - ) : SingularQueryOutputBox() { + public data class Parameters(public val parameters: jp.co.soramitsu.iroha2.generated.Parameters) : SingularQueryOutputBox() { override fun discriminant(): Int = DISCRIMINANT 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( @@ -184,95 +84,22 @@ public sealed class SingularQueryOutputBox : ModelEnum { } } - /** - * 'Transaction' variant - */ - public data class Transaction( - public val transactionQueryOutput: TransactionQueryOutput, - ) : 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( - TransactionQueryOutput.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Transaction, - ): Unit = try { - TransactionQueryOutput.write(writer, instance.transactionQueryOutput) - } 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 -> ExecutorDataModel.read(reader) + 1 -> Parameters.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - - 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 -> JsonString.read(reader) - 3 -> Trigger.read(reader) - 4 -> Parameters.read(reader) - 5 -> Transaction.read(reader) - 6 -> BlockHeader.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 -> JsonString.write(writer, instance as JsonString) - 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) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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/SmartContractParameter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SmartContractParameter.kt index afc27ff0d..cdd2b60eb 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SmartContractParameter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SmartContractParameter.kt @@ -26,9 +26,7 @@ public sealed class SmartContractParameter : ModelEnum { /** * 'Fuel' variant */ - public data class Fuel( - public val nonZeroOfu64: NonZeroOfu64, - ) : SmartContractParameter() { + public data class Fuel(public val nonZeroOfu64: NonZeroOfu64) : SmartContractParameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,23 +42,19 @@ public sealed class SmartContractParameter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SmartContractParameter.Fuel, - ): Unit = try { - NonZeroOfu64.write(writer, instance.nonZeroOfu64) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SmartContractParameter.Fuel): Unit = + try { + NonZeroOfu64.write(writer, instance.nonZeroOfu64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Memory' variant */ - public data class Memory( - public val nonZeroOfu64: NonZeroOfu64, - ) : SmartContractParameter() { + public data class Memory(public val nonZeroOfu64: NonZeroOfu64) : SmartContractParameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,32 +70,31 @@ public sealed class SmartContractParameter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SmartContractParameter.Memory, - ): Unit = try { - NonZeroOfu64.write(writer, instance.nonZeroOfu64) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SmartContractParameter.Memory): Unit = + try { + NonZeroOfu64.write(writer, instance.nonZeroOfu64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SmartContractParameter = when ( - val discriminant = - reader.readUByte() - ) { + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): SmartContractParameter = when (val discriminant = reader.readUByte()) { 0 -> Fuel.read(reader) 1 -> Memory.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: SmartContractParameter) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Fuel.write(writer, instance as Fuel) 1 -> Memory.write(writer, instance as Memory) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SmartContractParameters.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SmartContractParameters.kt index a3e22b873..aeda86734 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SmartContractParameters.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SmartContractParameters.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'SmartContractParameters' regular structure */ -public data class SmartContractParameters( - public val fuel: NonZeroOfu64, - public val memory: NonZeroOfu64, -) { +public data class SmartContractParameters(public val fuel: NonZeroOfu64, public val memory: NonZeroOfu64) { public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddr.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddr.kt index 5c6705f11..8a062b705 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddr.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddr.kt @@ -26,9 +26,7 @@ public sealed class SocketAddr : ModelEnum { /** * 'Ipv4' variant */ - public data class Ipv4( - public val socketAddrV4: SocketAddrV4, - ) : SocketAddr() { + public data class Ipv4(public val socketAddrV4: SocketAddrV4) : SocketAddr() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class SocketAddr : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SocketAddr.Ipv4, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SocketAddr.Ipv4): Unit = try { SocketAddrV4.write(writer, instance.socketAddrV4) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class SocketAddr : ModelEnum { /** * 'Ipv6' variant */ - public data class Ipv6( - public val socketAddrV6: SocketAddrV6, - ) : SocketAddr() { + public data class Ipv6(public val socketAddrV6: SocketAddrV6) : SocketAddr() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class SocketAddr : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SocketAddr.Ipv6, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SocketAddr.Ipv6): Unit = try { SocketAddrV6.write(writer, instance.socketAddrV6) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class SocketAddr : ModelEnum { /** * 'Host' variant */ - public data class Host( - public val socketAddrHost: SocketAddrHost, - ) : SocketAddr() { + public data class Host(public val socketAddrHost: SocketAddrHost) : SocketAddr() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,10 +96,7 @@ public sealed class SocketAddr : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SocketAddr.Host, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SocketAddr.Host): Unit = try { SocketAddrHost.write(writer, instance.socketAddrHost) } catch (ex: Exception) { throw wrapException(ex) @@ -120,14 +105,12 @@ public sealed class SocketAddr : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SocketAddr = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): SocketAddr = when (val discriminant = reader.readUByte()) { 0 -> Ipv4.read(reader) 1 -> Ipv6.read(reader) 2 -> Host.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: SocketAddr) { writer.directWrite(instance.discriminant()) @@ -135,7 +118,8 @@ public sealed class SocketAddr : ModelEnum { 0 -> Ipv4.write(writer, instance as Ipv4) 1 -> Ipv6.write(writer, instance as Ipv6) 2 -> Host.write(writer, instance as Host) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddrHost.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddrHost.kt index 6102cb384..408df3d0b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddrHost.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddrHost.kt @@ -17,10 +17,7 @@ import kotlin.Unit * * Generated from 'SocketAddrHost' regular structure */ -public data class SocketAddrHost( - public val host: String, - public val port: Int, -) { +public data class SocketAddrHost(public val host: String, public val port: Int) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SocketAddrHost = try { SocketAddrHost( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddrV4.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddrV4.kt index 5a07bb203..165e94ee4 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddrV4.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddrV4.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'SocketAddrV4' regular structure */ -public data class SocketAddrV4( - public val ip: Ipv4Addr, - public val port: Int, -) { +public data class SocketAddrV4(public val ip: Ipv4Addr, public val port: Int) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SocketAddrV4 = try { SocketAddrV4( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddrV6.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddrV6.kt index 75fd00e68..5095fe166 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddrV6.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SocketAddrV6.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'SocketAddrV6' regular structure */ -public data class SocketAddrV6( - public val ip: Ipv6Addr, - public val port: Int, -) { +public data class SocketAddrV6(public val ip: Ipv6Addr, public val port: Int) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): SocketAddrV6 = try { SocketAddrV6( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Sorting.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Sorting.kt index 288ecf551..1afe50335 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Sorting.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Sorting.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'Sorting' regular structure */ -public data class Sorting( - public val sortByMetadataKey: Name? = null, -) { +public data class Sorting(public val sortByMetadataKey: Name? = null) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Sorting = try { Sorting( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/StringPredicate.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/StringPredicate.kt deleted file mode 100644 index ffa690dd9..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/StringPredicate.kt +++ /dev/null @@ -1,176 +0,0 @@ -// -// 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.String -import kotlin.Unit - -/** - * StringPredicate - * - * Generated from 'StringPredicate' enum - */ -public sealed class StringPredicate : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Contains' variant - */ - public data class Contains( - public val string: String, - ) : StringPredicate() { - 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.StringPredicate.Contains = try { - Contains( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.StringPredicate.Contains, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'StartsWith' variant - */ - public data class StartsWith( - public val string: String, - ) : StringPredicate() { - 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.StringPredicate.StartsWith = try { - StartsWith( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.StringPredicate.StartsWith, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'EndsWith' variant - */ - public data class EndsWith( - public val string: String, - ) : StringPredicate() { - 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.StringPredicate.EndsWith = try { - EndsWith( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.StringPredicate.EndsWith, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Is' variant - */ - public data class Is( - public val string: String, - ) : StringPredicate() { - 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.StringPredicate.Is = try { - Is( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.StringPredicate.Is, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): StringPredicate = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Contains.read(reader) - 1 -> StartsWith.read(reader) - 2 -> EndsWith.read(reader) - 3 -> Is.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: StringPredicate) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Contains.write(writer, instance as Contains) - 1 -> StartsWith.write(writer, instance as StartsWith) - 2 -> EndsWith.write(writer, instance as EndsWith) - 3 -> Is.write(writer, instance as Is) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/StringPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/StringPredicateAtom.kt similarity index 57% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/StringPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/StringPredicateAtom.kt index d2e8c6820..5f16020c1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/StringPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/StringPredicateAtom.kt @@ -14,11 +14,11 @@ import kotlin.String import kotlin.Unit /** - * StringPredicateBox + * StringPredicateAtom * - * Generated from 'StringPredicateBox' enum + * Generated from 'StringPredicateAtom' enum */ -public sealed class StringPredicateBox : ModelEnum { +public sealed class StringPredicateAtom : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -27,17 +27,15 @@ public sealed class StringPredicateBox : ModelEnum { /** * 'Equals' variant */ - public data class Equals( - public val string: String, - ) : StringPredicateBox() { + public data class Equals(public val string: String) : StringPredicateAtom() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.StringPredicateBox.Equals = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.StringPredicateAtom.Equals = try { Equals( reader.readString(), ) @@ -45,31 +43,27 @@ public sealed class StringPredicateBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.StringPredicateBox.Equals, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.StringPredicateAtom.Equals): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Contains' variant */ - public data class Contains( - public val string: String, - ) : StringPredicateBox() { + public data class Contains(public val string: String) : StringPredicateAtom() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.StringPredicateBox.Contains = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.StringPredicateAtom.Contains = try { Contains( reader.readString(), ) @@ -77,31 +71,27 @@ public sealed class StringPredicateBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.StringPredicateBox.Contains, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.StringPredicateAtom.Contains): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'StartsWith' variant */ - public data class StartsWith( - public val string: String, - ) : StringPredicateBox() { + public data class StartsWith(public val string: String) : StringPredicateAtom() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.StringPredicateBox.StartsWith = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.StringPredicateAtom.StartsWith = try { StartsWith( reader.readString(), ) @@ -109,31 +99,27 @@ public sealed class StringPredicateBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.StringPredicateBox.StartsWith, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.StringPredicateAtom.StartsWith): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'EndsWith' variant */ - public data class EndsWith( - public val string: String, - ) : StringPredicateBox() { + public data class EndsWith(public val string: String) : StringPredicateAtom() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.StringPredicateBox.EndsWith = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.StringPredicateAtom.EndsWith = try { EndsWith( reader.readString(), ) @@ -141,36 +127,33 @@ public sealed class StringPredicateBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.StringPredicateBox.EndsWith, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.StringPredicateAtom.EndsWith): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): StringPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): StringPredicateAtom = when (val discriminant = reader.readUByte()) { 0 -> Equals.read(reader) 1 -> Contains.read(reader) 2 -> StartsWith.read(reader) 3 -> EndsWith.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: StringPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: StringPredicateAtom) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Equals.write(writer, instance as Equals) 1 -> Contains.write(writer, instance as Contains) 2 -> StartsWith.write(writer, instance as StartsWith) 3 -> EndsWith.write(writer, instance as EndsWith) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SumeragiParameter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SumeragiParameter.kt index a5dd27fc9..f66a1d5e7 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SumeragiParameter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SumeragiParameter.kt @@ -27,9 +27,7 @@ public sealed class SumeragiParameter : ModelEnum { /** * 'BlockTimeMs' variant */ - public data class BlockTimeMs( - public val u64: BigInteger, - ) : SumeragiParameter() { + public data class BlockTimeMs(public val u64: BigInteger) : SumeragiParameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -45,23 +43,19 @@ public sealed class SumeragiParameter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SumeragiParameter.BlockTimeMs, - ): Unit = try { - writer.writeUint64(instance.u64) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SumeragiParameter.BlockTimeMs): Unit = + try { + writer.writeUint64(instance.u64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'CommitTimeMs' variant */ - public data class CommitTimeMs( - public val u64: BigInteger, - ) : SumeragiParameter() { + public data class CommitTimeMs(public val u64: BigInteger) : SumeragiParameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -77,23 +71,19 @@ public sealed class SumeragiParameter : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SumeragiParameter.CommitTimeMs, - ): Unit = try { - writer.writeUint64(instance.u64) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SumeragiParameter.CommitTimeMs): Unit = + try { + writer.writeUint64(instance.u64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'MaxClockDriftMs' variant */ - public data class MaxClockDriftMs( - public val u64: BigInteger, - ) : SumeragiParameter() { + public data class MaxClockDriftMs(public val u64: BigInteger) : SumeragiParameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -121,14 +111,12 @@ public sealed class SumeragiParameter : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SumeragiParameter = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): SumeragiParameter = when (val discriminant = reader.readUByte()) { 0 -> BlockTimeMs.read(reader) 1 -> CommitTimeMs.read(reader) 2 -> MaxClockDriftMs.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: SumeragiParameter) { writer.directWrite(instance.discriminant()) @@ -136,7 +124,8 @@ public sealed class SumeragiParameter : ModelEnum { 0 -> BlockTimeMs.write(writer, instance as BlockTimeMs) 1 -> CommitTimeMs.write(writer, instance as CommitTimeMs) 2 -> MaxClockDriftMs.write(writer, instance as MaxClockDriftMs) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TimeEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TimeEvent.kt index a8120157d..f70a45450 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TimeEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TimeEvent.kt @@ -15,14 +15,10 @@ import kotlin.Unit * * Generated from 'TimeEvent' regular structure */ -public data class TimeEvent( - public val prevInterval: TimeInterval? = null, - public val interval: TimeInterval, -) { +public data class TimeEvent(public val interval: TimeInterval) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): TimeEvent = try { TimeEvent( - reader.readNullable(TimeInterval) as TimeInterval?, TimeInterval.read(reader), ) } catch (ex: Exception) { @@ -30,7 +26,6 @@ public data class TimeEvent( } override fun write(writer: ScaleCodecWriter, instance: TimeEvent): Unit = try { - writer.writeNullable(TimeInterval, instance.prevInterval) TimeInterval.write(writer, instance.interval) } catch (ex: Exception) { throw wrapException(ex) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TimeEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TimeEventFilter.kt index 453338f48..e9e59edb8 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TimeEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TimeEventFilter.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'TimeEventFilter' regular structure */ -public data class TimeEventFilter( - public val executionTime: ExecutionTime, -) { +public data class TimeEventFilter(public val executionTime: ExecutionTime) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): TimeEventFilter = try { TimeEventFilter( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TimeInterval.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TimeInterval.kt index a40d795a9..6af43d0c9 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TimeInterval.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TimeInterval.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'TimeInterval' regular structure */ -public data class TimeInterval( - public val sinceMs: BigInteger, - public val lengthMs: BigInteger, -) { +public data class TimeInterval(public val sinceMs: BigInteger, public val lengthMs: BigInteger) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): TimeInterval = try { TimeInterval( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorPredicateAtom.kt similarity index 64% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorPredicateAtom.kt index dba72f60f..a1390d7ee 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorPredicateAtom.kt @@ -15,11 +15,11 @@ import kotlin.Int import kotlin.Unit /** - * TransactionErrorPredicateBox + * TransactionErrorPredicateAtom * - * Generated from 'TransactionErrorPredicateBox' enum + * Generated from 'TransactionErrorPredicateAtom' enum */ -public sealed class TransactionErrorPredicateBox : ModelEnum { +public sealed class TransactionErrorPredicateAtom : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -27,24 +27,26 @@ public sealed class TransactionErrorPredicateBox : ModelEnum { override fun equals(other: Any?): Boolean = when (this) { is IsSome -> IsSome.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is IsSome -> IsSome.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'IsSome' variant */ - public class IsSome : TransactionErrorPredicateBox() { + public class IsSome : TransactionErrorPredicateAtom() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionErrorPredicateBox.IsSome = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionErrorPredicateAtom.IsSome = try { IsSome() } catch (ex: Exception) { throw wrapException(ex) @@ -52,40 +54,35 @@ public sealed class TransactionErrorPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransactionErrorPredicateBox.IsSome, - ): Unit = - try { - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.TransactionErrorPredicateAtom.IsSome, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.TransactionErrorPredicateBox.IsSome, - o2: Any?, - ): Boolean = when (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.TransactionErrorPredicateAtom.IsSome, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } - override fun hashCode(): Int = ".TransactionErrorPredicateBox.IsSome".hashCode() + override fun hashCode(): Int = ".TransactionErrorPredicateAtom.IsSome".hashCode() } } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionErrorPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): TransactionErrorPredicateAtom = when (val discriminant = reader.readUByte()) { 0 -> IsSome.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: TransactionErrorPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: TransactionErrorPredicateAtom) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> IsSome.write(writer, instance as IsSome) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..49a4fc74e --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorProjectionOfPredicateMarker.kt @@ -0,0 +1,75 @@ +// +// 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 + +/** + * TransactionErrorProjectionOfPredicateMarker + * + * Generated from 'TransactionErrorProjectionOfPredicateMarker' enum + */ +public sealed class TransactionErrorProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val transactionErrorPredicateAtom: TransactionErrorPredicateAtom) : + TransactionErrorProjectionOfPredicateMarker() { + 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.TransactionErrorProjectionOfPredicateMarker.Atom = + try { + Atom( + TransactionErrorPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TransactionErrorProjectionOfPredicateMarker.Atom, + ): Unit = try { + TransactionErrorPredicateAtom.write(writer, instance.transactionErrorPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): TransactionErrorProjectionOfPredicateMarker = + 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: TransactionErrorProjectionOfPredicateMarker) { + 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/TransactionErrorProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..65777de68 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorProjectionOfSelectorMarker.kt @@ -0,0 +1,91 @@ +// +// 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 + +/** + * TransactionErrorProjectionOfSelectorMarker + * + * Generated from 'TransactionErrorProjectionOfSelectorMarker' enum + */ +public sealed class TransactionErrorProjectionOfSelectorMarker : 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 : TransactionErrorProjectionOfSelectorMarker() { + 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.TransactionErrorProjectionOfSelectorMarker.Atom = + try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TransactionErrorProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.TransactionErrorProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".TransactionErrorProjectionOfSelectorMarker.Atom".hashCode() + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): TransactionErrorProjectionOfSelectorMarker = + 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: TransactionErrorProjectionOfSelectorMarker) { + 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/TransactionEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionEventFilter.kt index 43bb4990f..a089dc8fa 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionEventFilter.kt @@ -20,7 +20,9 @@ public data class TransactionEventFilter( public val blockHeight: NonZeroOfu64? = null, public val status: TransactionStatus? = null, ) { - public companion object : ScaleReader, ScaleWriter { + public companion object : + ScaleReader, + ScaleWriter { override fun read(reader: ScaleCodecReader): TransactionEventFilter = try { TransactionEventFilter( reader.readNullable(HashOf) as HashOf?, diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashPredicateAtom.kt similarity index 72% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashPredicateAtom.kt index 106954288..964e35f1b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashPredicateAtom.kt @@ -13,11 +13,11 @@ import kotlin.Int import kotlin.Unit /** - * TransactionHashPredicateBox + * TransactionHashPredicateAtom * - * Generated from 'TransactionHashPredicateBox' enum + * Generated from 'TransactionHashPredicateAtom' enum */ -public sealed class TransactionHashPredicateBox : ModelEnum { +public sealed class TransactionHashPredicateAtom : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -26,17 +26,15 @@ public sealed class TransactionHashPredicateBox : ModelEnum { /** * 'Equals' variant */ - public data class Equals( - public val hashOf: HashOf, - ) : TransactionHashPredicateBox() { + public data class Equals(public val hashOf: HashOf) : TransactionHashPredicateAtom() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionHashPredicateBox.Equals = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionHashPredicateAtom.Equals = try { Equals( HashOf.read(reader) as HashOf, ) @@ -46,7 +44,7 @@ public sealed class TransactionHashPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransactionHashPredicateBox.Equals, + instance: jp.co.soramitsu.iroha2.generated.TransactionHashPredicateAtom.Equals, ): Unit = try { HashOf.write(writer, instance.hashOf) } catch (ex: Exception) { @@ -56,20 +54,19 @@ public sealed class TransactionHashPredicateBox : ModelEnum { } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionHashPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): TransactionHashPredicateAtom = when (val discriminant = reader.readUByte()) { 0 -> Equals.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: TransactionHashPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: TransactionHashPredicateAtom) { 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") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..f423d9684 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashProjectionOfPredicateMarker.kt @@ -0,0 +1,75 @@ +// +// 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 + +/** + * TransactionHashProjectionOfPredicateMarker + * + * Generated from 'TransactionHashProjectionOfPredicateMarker' enum + */ +public sealed class TransactionHashProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val transactionHashPredicateAtom: TransactionHashPredicateAtom) : + TransactionHashProjectionOfPredicateMarker() { + 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.TransactionHashProjectionOfPredicateMarker.Atom = + try { + Atom( + TransactionHashPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TransactionHashProjectionOfPredicateMarker.Atom, + ): Unit = try { + TransactionHashPredicateAtom.write(writer, instance.transactionHashPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): TransactionHashProjectionOfPredicateMarker = + 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: TransactionHashProjectionOfPredicateMarker) { + 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/TransactionHashProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..bab3feca7 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashProjectionOfSelectorMarker.kt @@ -0,0 +1,91 @@ +// +// 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 + +/** + * TransactionHashProjectionOfSelectorMarker + * + * Generated from 'TransactionHashProjectionOfSelectorMarker' enum + */ +public sealed class TransactionHashProjectionOfSelectorMarker : 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 : TransactionHashProjectionOfSelectorMarker() { + 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.TransactionHashProjectionOfSelectorMarker.Atom = + try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TransactionHashProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.TransactionHashProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".TransactionHashProjectionOfSelectorMarker.Atom".hashCode() + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): TransactionHashProjectionOfSelectorMarker = + 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: TransactionHashProjectionOfSelectorMarker) { + 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/TransactionLimitError.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionLimitError.kt index 62d4d790e..b1e82fbc1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionLimitError.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionLimitError.kt @@ -16,9 +16,7 @@ import kotlin.Unit * * Generated from 'TransactionLimitError' regular structure */ -public data class TransactionLimitError( - public val reason: String, -) { +public data class TransactionLimitError(public val reason: String) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): TransactionLimitError = try { TransactionLimitError( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionParameter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionParameter.kt index 19acc0134..14cd8b0e6 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionParameter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionParameter.kt @@ -26,9 +26,7 @@ public sealed class TransactionParameter : ModelEnum { /** * 'MaxInstructions' variant */ - public data class MaxInstructions( - public val nonZeroOfu64: NonZeroOfu64, - ) : TransactionParameter() { + public data class MaxInstructions(public val nonZeroOfu64: NonZeroOfu64) : TransactionParameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -47,21 +45,18 @@ public sealed class TransactionParameter : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransactionParameter.MaxInstructions, - ): Unit = - try { - NonZeroOfu64.write(writer, instance.nonZeroOfu64) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = try { + NonZeroOfu64.write(writer, instance.nonZeroOfu64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'SmartContractSize' variant */ - public data class SmartContractSize( - public val nonZeroOfu64: NonZeroOfu64, - ) : TransactionParameter() { + public data class SmartContractSize(public val nonZeroOfu64: NonZeroOfu64) : TransactionParameter() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -80,30 +75,28 @@ public sealed class TransactionParameter : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransactionParameter.SmartContractSize, - ): Unit = - try { - NonZeroOfu64.write(writer, instance.nonZeroOfu64) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = try { + NonZeroOfu64.write(writer, instance.nonZeroOfu64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionParameter = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): TransactionParameter = when (val discriminant = reader.readUByte()) { 0 -> MaxInstructions.read(reader) 1 -> SmartContractSize.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: TransactionParameter) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> MaxInstructions.write(writer, instance as MaxInstructions) 1 -> SmartContractSize.write(writer, instance as SmartContractSize) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionParameters.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionParameters.kt index 08b4b85b0..98c65fe5d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionParameters.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionParameters.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'TransactionParameters' regular structure */ -public data class TransactionParameters( - public val maxInstructions: NonZeroOfu64, - public val smartContractSize: NonZeroOfu64, -) { +public data class TransactionParameters(public val maxInstructions: NonZeroOfu64, public val smartContractSize: NonZeroOfu64) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): TransactionParameters = try { TransactionParameters( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionQueryOutput.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionQueryOutput.kt deleted file mode 100644 index 4e9d70bf6..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionQueryOutput.kt +++ /dev/null @@ -1,39 +0,0 @@ -// -// 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 - -/** - * TransactionQueryOutput - * - * Generated from 'TransactionQueryOutput' regular structure - */ -public data class TransactionQueryOutput( - public val blockHash: HashOf, - public val transaction: CommittedTransaction, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionQueryOutput = try { - TransactionQueryOutput( - HashOf.read(reader) as HashOf, - CommittedTransaction.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: TransactionQueryOutput): Unit = try { - HashOf.write(writer, instance.blockHash) - CommittedTransaction.write(writer, instance.transaction) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionQueryOutputPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionQueryOutputPredicateBox.kt deleted file mode 100644 index 759a9f58c..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionQueryOutputPredicateBox.kt +++ /dev/null @@ -1,109 +0,0 @@ -// -// 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 - -/** - * TransactionQueryOutputPredicateBox - * - * Generated from 'TransactionQueryOutputPredicateBox' enum - */ -public sealed class TransactionQueryOutputPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Transaction' variant - */ - public data class Transaction( - public val committedTransactionPredicateBox: CommittedTransactionPredicateBox, - ) : TransactionQueryOutputPredicateBox() { - 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.TransactionQueryOutputPredicateBox.Transaction = try { - Transaction( - CommittedTransactionPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransactionQueryOutputPredicateBox.Transaction, - ): Unit = try { - CommittedTransactionPredicateBox.write(writer, instance.committedTransactionPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'BlockHash' variant - */ - public data class BlockHash( - public val blockHashPredicateBox: BlockHashPredicateBox, - ) : TransactionQueryOutputPredicateBox() { - 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.TransactionQueryOutputPredicateBox.BlockHash = try { - BlockHash( - BlockHashPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransactionQueryOutputPredicateBox.BlockHash, - ): Unit = try { - BlockHashPredicateBox.write(writer, instance.blockHashPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionQueryOutputPredicateBox = when ( - val - discriminant = reader.readUByte() - ) { - 0 -> Transaction.read(reader) - 1 -> BlockHash.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: TransactionQueryOutputPredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Transaction.write(writer, instance as Transaction) - 1 -> BlockHash.write(writer, instance as BlockHash) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionRejectionReason.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionRejectionReason.kt index 3d0165528..60f497460 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionRejectionReason.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionRejectionReason.kt @@ -26,9 +26,7 @@ public sealed class TransactionRejectionReason : ModelEnum { /** * 'AccountDoesNotExist' variant */ - public data class AccountDoesNotExist( - public val findError: FindError, - ) : TransactionRejectionReason() { + public data class AccountDoesNotExist(public val findError: FindError) : TransactionRejectionReason() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -36,13 +34,14 @@ public sealed class TransactionRejectionReason : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.AccountDoesNotExist = try { - AccountDoesNotExist( - FindError.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.AccountDoesNotExist = + try { + AccountDoesNotExist( + FindError.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -58,9 +57,7 @@ public sealed class TransactionRejectionReason : ModelEnum { /** * 'LimitCheck' variant */ - public data class LimitCheck( - public val transactionLimitError: TransactionLimitError, - ) : TransactionRejectionReason() { + public data class LimitCheck(public val transactionLimitError: TransactionLimitError) : TransactionRejectionReason() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -79,21 +76,18 @@ public sealed class TransactionRejectionReason : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.LimitCheck, - ): Unit = - try { - TransactionLimitError.write(writer, instance.transactionLimitError) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = try { + TransactionLimitError.write(writer, instance.transactionLimitError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Validation' variant */ - public data class Validation( - public val validationFail: ValidationFail, - ) : TransactionRejectionReason() { + public data class Validation(public val validationFail: ValidationFail) : TransactionRejectionReason() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -112,21 +106,18 @@ public sealed class TransactionRejectionReason : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.Validation, - ): Unit = - try { - ValidationFail.write(writer, instance.validationFail) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = try { + ValidationFail.write(writer, instance.validationFail) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'InstructionExecution' variant */ - public data class InstructionExecution( - public val instructionExecutionFail: InstructionExecutionFail, - ) : TransactionRejectionReason() { + public data class InstructionExecution(public val instructionExecutionFail: InstructionExecutionFail) : TransactionRejectionReason() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -134,13 +125,14 @@ public sealed class TransactionRejectionReason : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.InstructionExecution = try { - InstructionExecution( - InstructionExecutionFail.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.InstructionExecution = + try { + InstructionExecution( + InstructionExecutionFail.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -156,9 +148,7 @@ public sealed class TransactionRejectionReason : ModelEnum { /** * 'WasmExecution' variant */ - public data class WasmExecution( - public val wasmExecutionFail: WasmExecutionFail, - ) : TransactionRejectionReason() { + public data class WasmExecution(public val wasmExecutionFail: WasmExecutionFail) : TransactionRejectionReason() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -188,16 +178,14 @@ public sealed class TransactionRejectionReason : ModelEnum { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionRejectionReason = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): TransactionRejectionReason = when (val discriminant = reader.readUByte()) { 0 -> AccountDoesNotExist.read(reader) 1 -> LimitCheck.read(reader) 2 -> Validation.read(reader) 3 -> InstructionExecution.read(reader) 4 -> WasmExecution.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: TransactionRejectionReason) { writer.directWrite(instance.discriminant()) @@ -207,7 +195,8 @@ public sealed class TransactionRejectionReason : ModelEnum { 2 -> Validation.write(writer, instance as Validation) 3 -> InstructionExecution.write(writer, instance as InstructionExecution) 4 -> WasmExecution.write(writer, instance as WasmExecution) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionSignature.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionSignature.kt index 3b0641777..2edcc9677 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionSignature.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionSignature.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'TransactionSignature' regular structure */ -public data class TransactionSignature( - public val signatureOfOfTransactionPayload: SignatureOf, -) { +public data class TransactionSignature(public val signatureOfOfTransactionPayload: SignatureOf) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): TransactionSignature = try { TransactionSignature( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionStatus.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionStatus.kt index edbf679b6..23386d9bf 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionStatus.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionStatus.kt @@ -29,13 +29,15 @@ public sealed class TransactionStatus : ModelEnum { is Queued -> Queued.equals(this, other) is Expired -> Expired.equals(this, other) is Approved -> Approved.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is Queued -> Queued.hashCode() is Expired -> Expired.hashCode() is Approved -> Approved.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'Queued' variant @@ -54,10 +56,7 @@ public sealed class TransactionStatus : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransactionStatus.Queued, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransactionStatus.Queued): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -88,10 +87,7 @@ public sealed class TransactionStatus : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransactionStatus.Expired, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransactionStatus.Expired): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -122,13 +118,11 @@ public sealed class TransactionStatus : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransactionStatus.Approved, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransactionStatus.Approved): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } public fun equals(o1: jp.co.soramitsu.iroha2.generated.TransactionStatus.Approved, o2: Any?): Boolean = when (o2) { null -> false @@ -142,9 +136,7 @@ public sealed class TransactionStatus : ModelEnum { /** * 'Rejected' variant */ - public data class Rejected( - public val transactionRejectionReason: TransactionRejectionReason, - ) : TransactionStatus() { + public data class Rejected(public val transactionRejectionReason: TransactionRejectionReason) : TransactionStatus() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -160,27 +152,23 @@ public sealed class TransactionStatus : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransactionStatus.Rejected, - ): Unit = try { - TransactionRejectionReason.write(writer, instance.transactionRejectionReason) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransactionStatus.Rejected): Unit = + try { + TransactionRejectionReason.write(writer, instance.transactionRejectionReason) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionStatus = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): TransactionStatus = when (val discriminant = reader.readUByte()) { 0 -> Queued.read(reader) 1 -> Expired.read(reader) 2 -> Approved.read(reader) 3 -> Rejected.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: TransactionStatus) { writer.directWrite(instance.discriminant()) @@ -189,7 +177,8 @@ public sealed class TransactionStatus : ModelEnum { 1 -> Expired.write(writer, instance as Expired) 2 -> Approved.write(writer, instance as Approved) 3 -> Rejected.write(writer, instance as Rejected) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferBox.kt index c5ffdca08..1436134b0 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferBox.kt @@ -26,9 +26,7 @@ public sealed class TransferBox : ModelEnum { /** * 'Domain' variant */ - public data class Domain( - public val transferOfAccountAndDomainIdAndAccount: TransferOfAccountAndDomainIdAndAccount, - ) : TransferBox() { + public data class Domain(public val transferOfAccountAndDomainIdAndAccount: TransferOfAccountAndDomainIdAndAccount) : TransferBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,14 +42,8 @@ public sealed class TransferBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransferBox.Domain, - ): Unit = try { - TransferOfAccountAndDomainIdAndAccount.write( - writer, - instance.transferOfAccountAndDomainIdAndAccount, - ) + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransferBox.Domain): Unit = try { + TransferOfAccountAndDomainIdAndAccount.write(writer, instance.transferOfAccountAndDomainIdAndAccount) } catch (ex: Exception) { throw wrapException(ex) } @@ -62,8 +54,7 @@ public sealed class TransferBox : ModelEnum { * 'AssetDefinition' variant */ public data class AssetDefinition( - public val transferOfAccountAndAssetDefinitionIdAndAccount: - TransferOfAccountAndAssetDefinitionIdAndAccount, + public val transferOfAccountAndAssetDefinitionIdAndAccount: TransferOfAccountAndAssetDefinitionIdAndAccount, ) : TransferBox() { override fun discriminant(): Int = DISCRIMINANT @@ -80,26 +71,19 @@ public sealed class TransferBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransferBox.AssetDefinition, - ): Unit = try { - TransferOfAccountAndAssetDefinitionIdAndAccount.write( - writer, - instance.transferOfAccountAndAssetDefinitionIdAndAccount, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransferBox.AssetDefinition): Unit = + try { + TransferOfAccountAndAssetDefinitionIdAndAccount.write(writer, instance.transferOfAccountAndAssetDefinitionIdAndAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Asset' variant */ - public data class Asset( - public val assetTransferBox: AssetTransferBox, - ) : TransferBox() { + public data class Asset(public val assetTransferBox: AssetTransferBox) : TransferBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -115,10 +99,7 @@ public sealed class TransferBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransferBox.Asset, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransferBox.Asset): Unit = try { AssetTransferBox.write(writer, instance.assetTransferBox) } catch (ex: Exception) { throw wrapException(ex) @@ -127,14 +108,12 @@ public sealed class TransferBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TransferBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): TransferBox = when (val discriminant = reader.readUByte()) { 0 -> Domain.read(reader) 1 -> AssetDefinition.read(reader) 2 -> Asset.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: TransferBox) { writer.directWrite(instance.discriminant()) @@ -142,7 +121,8 @@ public sealed class TransferBox : ModelEnum { 0 -> Domain.write(writer, instance as Domain) 1 -> AssetDefinition.write(writer, instance as AssetDefinition) 2 -> Asset.write(writer, instance as Asset) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAccountAndAssetDefinitionIdAndAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAccountAndAssetDefinitionIdAndAccount.kt index cc718549b..3d7c23933 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAccountAndAssetDefinitionIdAndAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAccountAndAssetDefinitionIdAndAccount.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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,25 +22,23 @@ public data class TransferOfAccountAndAssetDefinitionIdAndAccount( public val source: AccountId, public val `object`: AssetDefinitionId, public val destination: AccountId, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TransferOfAccountAndAssetDefinitionIdAndAccount = - try { - TransferOfAccountAndAssetDefinitionIdAndAccount( - AccountId.read(reader), - AssetDefinitionId.read(reader), - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TransferOfAccountAndAssetDefinitionIdAndAccount = try { + TransferOfAccountAndAssetDefinitionIdAndAccount( + AccountId.read(reader), + AssetDefinitionId.read(reader), + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write( - writer: ScaleCodecWriter, - instance: TransferOfAccountAndAssetDefinitionIdAndAccount, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: TransferOfAccountAndAssetDefinitionIdAndAccount): Unit = try { AccountId.write(writer, instance.source) AssetDefinitionId.write(writer, instance.`object`) AccountId.write(writer, instance.destination) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAccountAndDomainIdAndAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAccountAndDomainIdAndAccount.kt index 6161fa14c..eb06c8911 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAccountAndDomainIdAndAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAccountAndDomainIdAndAccount.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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,7 +22,9 @@ public data class TransferOfAccountAndDomainIdAndAccount( public val source: AccountId, public val `object`: DomainId, public val destination: AccountId, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAssetAndMetadataAndAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAssetAndMetadataAndAccount.kt index da8e344a0..23cc961ef 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAssetAndMetadataAndAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAssetAndMetadataAndAccount.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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,7 +22,9 @@ public data class TransferOfAssetAndMetadataAndAccount( public val source: AssetId, public val `object`: Metadata, public val destination: AccountId, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAssetAndNumericAndAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAssetAndNumericAndAccount.kt index 2612f94f4..ba3449f66 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAssetAndNumericAndAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransferOfAssetAndNumericAndAccount.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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,7 +22,9 @@ public data class TransferOfAssetAndNumericAndAccount( public val source: AssetId, public val `object`: Numeric, public val destination: AccountId, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Trigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Trigger.kt index 309e54abf..e15fae04b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Trigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Trigger.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'Trigger' regular structure */ -public data class Trigger( - public val id: TriggerId, - public val action: Action, -) { +public data class Trigger(public val id: TriggerId, public val action: Action) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Trigger = try { Trigger( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedEvent.kt index d741a20d7..31ae02336 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedEvent.kt @@ -15,10 +15,7 @@ import kotlin.Unit * * Generated from 'TriggerCompletedEvent' regular structure */ -public data class TriggerCompletedEvent( - public val triggerId: TriggerId, - public val outcome: TriggerCompletedOutcome, -) { +public data class TriggerCompletedEvent(public val triggerId: TriggerId, public val outcome: TriggerCompletedOutcome) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): TriggerCompletedEvent = try { TriggerCompletedEvent( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedOutcome.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedOutcome.kt index ff963e5bf..75363ef97 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedOutcome.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedOutcome.kt @@ -28,11 +28,13 @@ public sealed class TriggerCompletedOutcome : ModelEnum { override fun equals(other: Any?): Boolean = when (this) { is Success -> Success.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is Success -> Success.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'Success' variant @@ -51,18 +53,13 @@ public sealed class TriggerCompletedOutcome : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcome.Success, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcome.Success): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcome.Success, - o2: Any?, - ): Boolean = when (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcome.Success, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -74,9 +71,7 @@ public sealed class TriggerCompletedOutcome : ModelEnum { /** * 'Failure' variant */ - public data class Failure( - public val string: String, - ) : TriggerCompletedOutcome() { + public data class Failure(public val string: String) : TriggerCompletedOutcome() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -92,34 +87,31 @@ public sealed class TriggerCompletedOutcome : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcome.Failure, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcome.Failure): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TriggerCompletedOutcome = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): TriggerCompletedOutcome = when (val discriminant = reader.readUByte()) { 0 -> Success.read(reader) 1 -> Failure.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: TriggerCompletedOutcome) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Success.write(writer, instance as Success) 1 -> Failure.write(writer, instance as Failure) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedOutcomeType.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedOutcomeType.kt index 2e1dbff1a..d9e9f3120 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedOutcomeType.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedOutcomeType.kt @@ -28,12 +28,14 @@ public sealed class TriggerCompletedOutcomeType : ModelEnum { override fun equals(other: Any?): Boolean = when (this) { is Success -> Success.equals(this, other) is Failure -> Failure.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is Success -> Success.hashCode() is Failure -> Failure.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'Success' variant @@ -55,16 +57,12 @@ public sealed class TriggerCompletedOutcomeType : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcomeType.Success, - ): Unit = - try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcomeType.Success, - o2: Any?, - ): Boolean = when (o2) { + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcomeType.Success, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -93,16 +91,12 @@ public sealed class TriggerCompletedOutcomeType : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcomeType.Failure, - ): Unit = - try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcomeType.Failure, - o2: Any?, - ): Boolean = when (o2) { + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcomeType.Failure, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -114,20 +108,19 @@ public sealed class TriggerCompletedOutcomeType : ModelEnum { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TriggerCompletedOutcomeType = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): TriggerCompletedOutcomeType = when (val discriminant = reader.readUByte()) { 0 -> Success.read(reader) 1 -> Failure.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: TriggerCompletedOutcomeType) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Success.write(writer, instance as Success) 1 -> Failure.write(writer, instance as Failure) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerEvent.kt index 842418358..6dcd290d2 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerEvent.kt @@ -26,9 +26,7 @@ public sealed class TriggerEvent : ModelEnum { /** * 'Created' variant */ - public data class Created( - public val triggerId: TriggerId, - ) : TriggerEvent() { + public data class Created(public val triggerId: TriggerId) : TriggerEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class TriggerEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.Created, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.Created): Unit = try { TriggerId.write(writer, instance.triggerId) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class TriggerEvent : ModelEnum { /** * 'Deleted' variant */ - public data class Deleted( - public val triggerId: TriggerId, - ) : TriggerEvent() { + public data class Deleted(public val triggerId: TriggerId) : TriggerEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class TriggerEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.Deleted, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.Deleted): Unit = try { TriggerId.write(writer, instance.triggerId) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class TriggerEvent : ModelEnum { /** * 'Extended' variant */ - public data class Extended( - public val triggerNumberOfExecutionsChanged: TriggerNumberOfExecutionsChanged, - ) : TriggerEvent() { + public data class Extended(public val triggerNumberOfExecutionsChanged: TriggerNumberOfExecutionsChanged) : TriggerEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,10 +96,7 @@ public sealed class TriggerEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.Extended, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.Extended): Unit = try { TriggerNumberOfExecutionsChanged.write(writer, instance.triggerNumberOfExecutionsChanged) } catch (ex: Exception) { throw wrapException(ex) @@ -122,9 +107,7 @@ public sealed class TriggerEvent : ModelEnum { /** * 'Shortened' variant */ - public data class Shortened( - public val triggerNumberOfExecutionsChanged: TriggerNumberOfExecutionsChanged, - ) : TriggerEvent() { + public data class Shortened(public val triggerNumberOfExecutionsChanged: TriggerNumberOfExecutionsChanged) : TriggerEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,10 +123,7 @@ public sealed class TriggerEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.Shortened, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.Shortened): Unit = try { TriggerNumberOfExecutionsChanged.write(writer, instance.triggerNumberOfExecutionsChanged) } catch (ex: Exception) { throw wrapException(ex) @@ -154,9 +134,7 @@ public sealed class TriggerEvent : ModelEnum { /** * 'MetadataInserted' variant */ - public data class MetadataInserted( - public val metadataChangedOfTriggerId: MetadataChangedOfTriggerId, - ) : TriggerEvent() { + public data class MetadataInserted(public val metadataChangedOfTriggerId: MetadataChangedOfTriggerId) : TriggerEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -172,23 +150,19 @@ public sealed class TriggerEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataInserted, - ): Unit = try { - MetadataChangedOfTriggerId.write(writer, instance.metadataChangedOfTriggerId) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataInserted): Unit = + try { + MetadataChangedOfTriggerId.write(writer, instance.metadataChangedOfTriggerId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'MetadataRemoved' variant */ - public data class MetadataRemoved( - public val metadataChangedOfTriggerId: MetadataChangedOfTriggerId, - ) : TriggerEvent() { + public data class MetadataRemoved(public val metadataChangedOfTriggerId: MetadataChangedOfTriggerId) : TriggerEvent() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -204,29 +178,25 @@ public sealed class TriggerEvent : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataRemoved, - ): Unit = try { - MetadataChangedOfTriggerId.write(writer, instance.metadataChangedOfTriggerId) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataRemoved): Unit = + try { + MetadataChangedOfTriggerId.write(writer, instance.metadataChangedOfTriggerId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TriggerEvent = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): TriggerEvent = when (val discriminant = reader.readUByte()) { 0 -> Created.read(reader) 1 -> Deleted.read(reader) 2 -> Extended.read(reader) 3 -> Shortened.read(reader) 4 -> MetadataInserted.read(reader) 5 -> MetadataRemoved.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: TriggerEvent) { writer.directWrite(instance.discriminant()) @@ -237,7 +207,8 @@ public sealed class TriggerEvent : ModelEnum { 3 -> Shortened.write(writer, instance as Shortened) 4 -> MetadataInserted.write(writer, instance as MetadataInserted) 5 -> MetadataRemoved.write(writer, instance as MetadataRemoved) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerEventFilter.kt index 239257a3e..0fa9da0ec 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerEventFilter.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'TriggerEventFilter' regular structure */ -public data class TriggerEventFilter( - public val idMatcher: TriggerId? = null, - public val eventSet: Long, -) { +public data class TriggerEventFilter(public val idMatcher: TriggerId? = null, public val eventSet: Long) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): TriggerEventFilter = try { TriggerEventFilter( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerId.kt index f023fd8f9..cb2c04240 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerId.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerId.kt @@ -15,9 +15,7 @@ import kotlin.Unit * * Generated from 'TriggerId' regular structure */ -public data class TriggerId( - public val name: Name, -) { +public data class TriggerId(public val name: Name) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): TriggerId = try { TriggerId( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdPredicateAtom.kt similarity index 52% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdPredicateAtom.kt index 018dfee8b..2dfafe5dc 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdPredicateAtom.kt @@ -13,61 +13,58 @@ import kotlin.Int import kotlin.Unit /** - * TriggerPredicateBox + * TriggerIdPredicateAtom * - * Generated from 'TriggerPredicateBox' enum + * Generated from 'TriggerIdPredicateAtom' enum */ -public sealed class TriggerPredicateBox : ModelEnum { +public sealed class TriggerIdPredicateAtom : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int /** - * 'Id' variant + * 'Equals' variant */ - public data class Id( - public val triggerIdPredicateBox: TriggerIdPredicateBox, - ) : TriggerPredicateBox() { + public data class Equals(public val triggerId: TriggerId) : TriggerIdPredicateAtom() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerPredicateBox.Id = try { - Id( - TriggerIdPredicateBox.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerIdPredicateAtom.Equals = try { + Equals( + TriggerId.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerPredicateBox.Id, - ): Unit = try { - TriggerIdPredicateBox.write(writer, instance.triggerIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerIdPredicateAtom.Equals): Unit = + try { + TriggerId.write(writer, instance.triggerId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TriggerPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Id.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): TriggerIdPredicateAtom = 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: TriggerPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: TriggerIdPredicateAtom) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Id.write(writer, instance as Id) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $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/TriggerIdPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdProjectionOfPredicateMarker.kt similarity index 60% rename from modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdPredicateBox.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdProjectionOfPredicateMarker.kt index 103be10a3..c9de5cf87 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdPredicateBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdProjectionOfPredicateMarker.kt @@ -13,32 +13,30 @@ import kotlin.Int import kotlin.Unit /** - * TriggerIdPredicateBox + * TriggerIdProjectionOfPredicateMarker * - * Generated from 'TriggerIdPredicateBox' enum + * Generated from 'TriggerIdProjectionOfPredicateMarker' enum */ -public sealed class TriggerIdPredicateBox : ModelEnum { +public sealed class TriggerIdProjectionOfPredicateMarker : ModelEnum { /** * @return Discriminator of variant in enum */ public abstract fun discriminant(): Int /** - * 'Equals' variant + * 'Atom' variant */ - public data class Equals( - public val triggerId: TriggerId, - ) : TriggerIdPredicateBox() { + public data class Atom(public val triggerIdPredicateAtom: TriggerIdPredicateAtom) : TriggerIdProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerIdPredicateBox.Equals = try { - Equals( - TriggerId.read(reader), + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerIdProjectionOfPredicateMarker.Atom = try { + Atom( + TriggerIdPredicateAtom.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -46,9 +44,9 @@ public sealed class TriggerIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerIdPredicateBox.Equals, + instance: jp.co.soramitsu.iroha2.generated.TriggerIdProjectionOfPredicateMarker.Atom, ): Unit = try { - TriggerId.write(writer, instance.triggerId) + TriggerIdPredicateAtom.write(writer, instance.triggerIdPredicateAtom) } catch (ex: Exception) { throw wrapException(ex) } @@ -58,19 +56,18 @@ public sealed class TriggerIdPredicateBox : ModelEnum { /** * 'Name' variant */ - public data class Name( - public val stringPredicateBox: StringPredicateBox, - ) : TriggerIdPredicateBox() { + public data class Name(public val nameProjectionOfPredicateMarker: NameProjectionOfPredicateMarker) : + TriggerIdProjectionOfPredicateMarker() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + ScaleReader, + ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerIdPredicateBox.Name = try { + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerIdProjectionOfPredicateMarker.Name = try { Name( - StringPredicateBox.read(reader), + NameProjectionOfPredicateMarker.read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -78,30 +75,31 @@ public sealed class TriggerIdPredicateBox : ModelEnum { override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerIdPredicateBox.Name, + instance: jp.co.soramitsu.iroha2.generated.TriggerIdProjectionOfPredicateMarker.Name, ): Unit = try { - StringPredicateBox.write(writer, instance.stringPredicateBox) + NameProjectionOfPredicateMarker.write(writer, instance.nameProjectionOfPredicateMarker) } catch (ex: Exception) { throw wrapException(ex) } } } - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TriggerIdPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Equals.read(reader) + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): TriggerIdProjectionOfPredicateMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) 1 -> Name.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } - override fun write(writer: ScaleCodecWriter, instance: TriggerIdPredicateBox) { + override fun write(writer: ScaleCodecWriter, instance: TriggerIdProjectionOfPredicateMarker) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { - 0 -> Equals.write(writer, instance as Equals) + 0 -> Atom.write(writer, instance as Atom) 1 -> Name.write(writer, instance as Name) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..2784d9c65 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdProjectionOfSelectorMarker.kt @@ -0,0 +1,122 @@ +// +// 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 + +/** + * TriggerIdProjectionOfSelectorMarker + * + * Generated from 'TriggerIdProjectionOfSelectorMarker' enum + */ +public sealed class TriggerIdProjectionOfSelectorMarker : 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 : TriggerIdProjectionOfSelectorMarker() { + 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.TriggerIdProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TriggerIdProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.TriggerIdProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".TriggerIdProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Name' variant + */ + public data class Name(public val nameProjectionOfSelectorMarker: NameProjectionOfSelectorMarker) : + TriggerIdProjectionOfSelectorMarker() { + 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.TriggerIdProjectionOfSelectorMarker.Name = try { + Name( + NameProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TriggerIdProjectionOfSelectorMarker.Name, + ): Unit = try { + NameProjectionOfSelectorMarker.write(writer, instance.nameProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): TriggerIdProjectionOfSelectorMarker = when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Name.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: TriggerIdProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Name.write(writer, instance as Name) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerNumberOfExecutionsChanged.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerNumberOfExecutionsChanged.kt index f63765280..4ca760ebe 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerNumberOfExecutionsChanged.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerNumberOfExecutionsChanged.kt @@ -16,10 +16,7 @@ import kotlin.Unit * * Generated from 'TriggerNumberOfExecutionsChanged' regular structure */ -public data class TriggerNumberOfExecutionsChanged( - public val trigger: TriggerId, - public val `by`: Long, -) { +public data class TriggerNumberOfExecutionsChanged(public val trigger: TriggerId, public val `by`: Long) { public companion object : ScaleReader, ScaleWriter { @@ -32,12 +29,11 @@ public data class TriggerNumberOfExecutionsChanged( throw wrapException(ex) } - override fun write(writer: ScaleCodecWriter, instance: TriggerNumberOfExecutionsChanged): Unit = - try { - TriggerId.write(writer, instance.trigger) - writer.writeUint32(instance.`by`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: TriggerNumberOfExecutionsChanged): Unit = try { + TriggerId.write(writer, instance.trigger) + writer.writeUint32(instance.`by`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerPredicateAtom.kt new file mode 100644 index 000000000..f4f9ca808 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerPredicateAtom.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 + +/** + * TriggerPredicateAtom + * + * Generated from 'TriggerPredicateAtom' enum + */ +public sealed class TriggerPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): TriggerPredicateAtom = when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write(writer: ScaleCodecWriter, instance: TriggerPredicateAtom) { + 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/TriggerProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..57d1aa688 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfPredicateMarker.kt @@ -0,0 +1,138 @@ +// +// 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 + +/** + * TriggerProjectionOfPredicateMarker + * + * Generated from 'TriggerProjectionOfPredicateMarker' enum + */ +public sealed class TriggerProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom(public val triggerPredicateAtom: TriggerPredicateAtom) : TriggerProjectionOfPredicateMarker() { + 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.TriggerProjectionOfPredicateMarker.Atom = try { + Atom( + TriggerPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TriggerProjectionOfPredicateMarker.Atom, + ): Unit = try { + TriggerPredicateAtom.write(writer, instance.triggerPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Id' variant + */ + public data class Id(public val triggerIdProjectionOfPredicateMarker: TriggerIdProjectionOfPredicateMarker) : + TriggerProjectionOfPredicateMarker() { + 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.TriggerProjectionOfPredicateMarker.Id = try { + Id( + TriggerIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TriggerProjectionOfPredicateMarker.Id, + ): Unit = try { + TriggerIdProjectionOfPredicateMarker.write(writer, instance.triggerIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * '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") + } + + override fun write(writer: ScaleCodecWriter, instance: TriggerProjectionOfPredicateMarker) { + writer.directWrite(instance.discriminant()) + 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 new file mode 100644 index 000000000..0a0f4e487 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfSelectorMarker.kt @@ -0,0 +1,154 @@ +// +// 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 + +/** + * TriggerProjectionOfSelectorMarker + * + * Generated from 'TriggerProjectionOfSelectorMarker' enum + */ +public sealed class TriggerProjectionOfSelectorMarker : 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 : TriggerProjectionOfSelectorMarker() { + 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.TriggerProjectionOfSelectorMarker.Atom = try { + Atom() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TriggerProjectionOfSelectorMarker.Atom, + ): Unit = try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals(o1: jp.co.soramitsu.iroha2.generated.TriggerProjectionOfSelectorMarker.Atom, o2: Any?): Boolean = when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".TriggerProjectionOfSelectorMarker.Atom".hashCode() + } + } + + /** + * 'Id' variant + */ + public data class Id(public val triggerIdProjectionOfSelectorMarker: TriggerIdProjectionOfSelectorMarker) : + TriggerProjectionOfSelectorMarker() { + 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.TriggerProjectionOfSelectorMarker.Id = try { + Id( + TriggerIdProjectionOfSelectorMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TriggerProjectionOfSelectorMarker.Id, + ): Unit = try { + TriggerIdProjectionOfSelectorMarker.write(writer, instance.triggerIdProjectionOfSelectorMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * '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") + } + + override fun write(writer: ScaleCodecWriter, instance: TriggerProjectionOfSelectorMarker) { + writer.directWrite(instance.discriminant()) + 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/TypeError.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TypeError.kt index ff5c5b8b2..2ced62667 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TypeError.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TypeError.kt @@ -26,9 +26,7 @@ public sealed class TypeError : ModelEnum { /** * 'AssetType' variant */ - public data class AssetType( - public val mismatch: Mismatch, - ) : TypeError() { + public data class AssetType(public val mismatch: Mismatch) : TypeError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class TypeError : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TypeError.AssetType, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TypeError.AssetType): Unit = try { Mismatch.write(writer, instance.mismatch) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class TypeError : ModelEnum { /** * 'NumericAssetTypeExpected' variant */ - public data class NumericAssetTypeExpected( - public val assetType: jp.co.soramitsu.iroha2.generated.AssetType, - ) : TypeError() { + public data class NumericAssetTypeExpected(public val assetType: jp.co.soramitsu.iroha2.generated.AssetType) : TypeError() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -88,20 +81,19 @@ public sealed class TypeError : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TypeError = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): TypeError = when (val discriminant = reader.readUByte()) { 0 -> AssetType.read(reader) 1 -> NumericAssetTypeExpected.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: TypeError) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> AssetType.write(writer, instance as AssetType) 1 -> NumericAssetTypeExpected.write(writer, instance as NumericAssetTypeExpected) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterBox.kt index f173e1122..752c4c704 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterBox.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterBox.kt @@ -26,9 +26,7 @@ public sealed class UnregisterBox : ModelEnum { /** * 'Peer' variant */ - public data class Peer( - public val unregisterOfPeer: UnregisterOfPeer, - ) : UnregisterBox() { + public data class Peer(public val unregisterOfPeer: UnregisterOfPeer) : UnregisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -44,10 +42,7 @@ public sealed class UnregisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.Peer, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.Peer): Unit = try { UnregisterOfPeer.write(writer, instance.unregisterOfPeer) } catch (ex: Exception) { throw wrapException(ex) @@ -58,9 +53,7 @@ public sealed class UnregisterBox : ModelEnum { /** * 'Domain' variant */ - public data class Domain( - public val unregisterOfDomain: UnregisterOfDomain, - ) : UnregisterBox() { + public data class Domain(public val unregisterOfDomain: UnregisterOfDomain) : UnregisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -76,10 +69,7 @@ public sealed class UnregisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.Domain, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.Domain): Unit = try { UnregisterOfDomain.write(writer, instance.unregisterOfDomain) } catch (ex: Exception) { throw wrapException(ex) @@ -90,9 +80,7 @@ public sealed class UnregisterBox : ModelEnum { /** * 'Account' variant */ - public data class Account( - public val unregisterOfAccount: UnregisterOfAccount, - ) : UnregisterBox() { + public data class Account(public val unregisterOfAccount: UnregisterOfAccount) : UnregisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -108,10 +96,7 @@ public sealed class UnregisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.Account, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.Account): Unit = try { UnregisterOfAccount.write(writer, instance.unregisterOfAccount) } catch (ex: Exception) { throw wrapException(ex) @@ -122,9 +107,7 @@ public sealed class UnregisterBox : ModelEnum { /** * 'AssetDefinition' variant */ - public data class AssetDefinition( - public val unregisterOfAssetDefinition: UnregisterOfAssetDefinition, - ) : UnregisterBox() { + public data class AssetDefinition(public val unregisterOfAssetDefinition: UnregisterOfAssetDefinition) : UnregisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -140,23 +123,19 @@ public sealed class UnregisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.AssetDefinition, - ): Unit = try { - UnregisterOfAssetDefinition.write(writer, instance.unregisterOfAssetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.AssetDefinition): Unit = + try { + UnregisterOfAssetDefinition.write(writer, instance.unregisterOfAssetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'Asset' variant */ - public data class Asset( - public val unregisterOfAsset: UnregisterOfAsset, - ) : UnregisterBox() { + public data class Asset(public val unregisterOfAsset: UnregisterOfAsset) : UnregisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -172,10 +151,7 @@ public sealed class UnregisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.Asset, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.Asset): Unit = try { UnregisterOfAsset.write(writer, instance.unregisterOfAsset) } catch (ex: Exception) { throw wrapException(ex) @@ -186,9 +162,7 @@ public sealed class UnregisterBox : ModelEnum { /** * 'Role' variant */ - public data class Role( - public val unregisterOfRole: UnregisterOfRole, - ) : UnregisterBox() { + public data class Role(public val unregisterOfRole: UnregisterOfRole) : UnregisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -204,10 +178,7 @@ public sealed class UnregisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.Role, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.Role): Unit = try { UnregisterOfRole.write(writer, instance.unregisterOfRole) } catch (ex: Exception) { throw wrapException(ex) @@ -218,9 +189,7 @@ public sealed class UnregisterBox : ModelEnum { /** * 'Trigger' variant */ - public data class Trigger( - public val unregisterOfTrigger: UnregisterOfTrigger, - ) : UnregisterBox() { + public data class Trigger(public val unregisterOfTrigger: UnregisterOfTrigger) : UnregisterBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -236,10 +205,7 @@ public sealed class UnregisterBox : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.Trigger, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.UnregisterBox.Trigger): Unit = try { UnregisterOfTrigger.write(writer, instance.unregisterOfTrigger) } catch (ex: Exception) { throw wrapException(ex) @@ -248,10 +214,7 @@ public sealed class UnregisterBox : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): UnregisterBox = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): UnregisterBox = when (val discriminant = reader.readUByte()) { 0 -> Peer.read(reader) 1 -> Domain.read(reader) 2 -> Account.read(reader) @@ -259,7 +222,8 @@ public sealed class UnregisterBox : ModelEnum { 4 -> Asset.read(reader) 5 -> Role.read(reader) 6 -> Trigger.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: UnregisterBox) { writer.directWrite(instance.discriminant()) @@ -271,7 +235,8 @@ public sealed class UnregisterBox : ModelEnum { 4 -> Asset.write(writer, instance as Asset) 5 -> Role.write(writer, instance as Role) 6 -> Trigger.write(writer, instance as Trigger) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfAccount.kt index 689a7d1fb..ba190d0e9 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfAccount.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfAccount.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'UnregisterOfAccount' regular structure */ -public data class UnregisterOfAccount( - public val `object`: AccountId, -) { +public data class UnregisterOfAccount(public val `object`: AccountId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): UnregisterOfAccount = try { UnregisterOfAccount( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfAsset.kt index 3a96a92c2..e3d5425d1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfAsset.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfAsset.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'UnregisterOfAsset' regular structure */ -public data class UnregisterOfAsset( - public val `object`: AssetId, -) { +public data class UnregisterOfAsset(public val `object`: AssetId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): UnregisterOfAsset = try { UnregisterOfAsset( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfAssetDefinition.kt index 1dec40c59..7f0270739 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfAssetDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfAssetDefinition.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'UnregisterOfAssetDefinition' regular structure */ -public data class UnregisterOfAssetDefinition( - public val `object`: AssetDefinitionId, -) { +public data class UnregisterOfAssetDefinition(public val `object`: AssetDefinitionId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfDomain.kt index a4f9ecb75..c207b0ad6 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfDomain.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfDomain.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'UnregisterOfDomain' regular structure */ -public data class UnregisterOfDomain( - public val `object`: DomainId, -) { +public data class UnregisterOfDomain(public val `object`: DomainId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): UnregisterOfDomain = try { UnregisterOfDomain( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfPeer.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfPeer.kt index 712774fe1..6fb6b41ee 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfPeer.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfPeer.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'UnregisterOfPeer' regular structure */ -public data class UnregisterOfPeer( - public val `object`: PeerId, -) { +public data class UnregisterOfPeer(public val `object`: PeerId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): UnregisterOfPeer = try { UnregisterOfPeer( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfRole.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfRole.kt index 72c9846b7..77e969dbc 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfRole.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfRole.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'UnregisterOfRole' regular structure */ -public data class UnregisterOfRole( - public val `object`: RoleId, -) { +public data class UnregisterOfRole(public val `object`: RoleId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): UnregisterOfRole = try { UnregisterOfRole( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfTrigger.kt index 690a7fc84..2d9f0c9e3 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfTrigger.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/UnregisterOfTrigger.kt @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'UnregisterOfTrigger' regular structure */ -public data class UnregisterOfTrigger( - public val `object`: TriggerId, -) { +public data class UnregisterOfTrigger(public val `object`: TriggerId) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): UnregisterOfTrigger = try { UnregisterOfTrigger( 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 ebc064f02..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 @@ -3,10 +3,13 @@ // package jp.co.soramitsu.iroha2.generated +import jp.co.soramitsu.iroha2.asInstructionBoxExt 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 @@ -15,9 +18,9 @@ import kotlin.Unit * * Generated from 'Upgrade' regular structure */ -public data class Upgrade( - public val executor: Executor, -) { +public data class Upgrade(public val executor: Executor) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): Upgrade = try { Upgrade( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ValidationFail.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ValidationFail.kt index 0934322db..394bffd44 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ValidationFail.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ValidationFail.kt @@ -29,19 +29,19 @@ public sealed class ValidationFail : ModelEnum { override fun equals(other: Any?): Boolean = when (this) { is TooComplex -> TooComplex.equals(this, other) is InternalError -> InternalError.equals(this, other) - else -> super.equals(other) } + else -> super.equals(other) + } override fun hashCode(): Int = when (this) { is TooComplex -> TooComplex.hashCode() is InternalError -> InternalError.hashCode() - else -> super.hashCode() } + else -> super.hashCode() + } /** * 'NotPermitted' variant */ - public data class NotPermitted( - public val string: String, - ) : ValidationFail() { + public data class NotPermitted(public val string: String) : ValidationFail() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -57,23 +57,19 @@ public sealed class ValidationFail : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.ValidationFail.NotPermitted, - ): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.ValidationFail.NotPermitted): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** * 'InstructionFailed' variant */ - public data class InstructionFailed( - public val instructionExecutionError: InstructionExecutionError, - ) : ValidationFail() { + public data class InstructionFailed(public val instructionExecutionError: InstructionExecutionError) : ValidationFail() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -103,9 +99,7 @@ public sealed class ValidationFail : ModelEnum { /** * 'QueryFailed' variant */ - public data class QueryFailed( - public val queryExecutionFail: QueryExecutionFail, - ) : ValidationFail() { + public data class QueryFailed(public val queryExecutionFail: QueryExecutionFail) : ValidationFail() { override fun discriminant(): Int = DISCRIMINANT public companion object : @@ -121,14 +115,12 @@ public sealed class ValidationFail : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.ValidationFail.QueryFailed, - ): Unit = try { - QueryExecutionFail.write(writer, instance.queryExecutionFail) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.ValidationFail.QueryFailed): Unit = + try { + QueryExecutionFail.write(writer, instance.queryExecutionFail) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -149,10 +141,7 @@ public sealed class ValidationFail : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.ValidationFail.TooComplex, - ): Unit = try { + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.ValidationFail.TooComplex): Unit = try { } catch (ex: Exception) { throw wrapException(ex) } @@ -183,18 +172,13 @@ public sealed class ValidationFail : ModelEnum { throw wrapException(ex) } - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.ValidationFail.InternalError, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write(writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.ValidationFail.InternalError): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals( - o1: jp.co.soramitsu.iroha2.generated.ValidationFail.InternalError, - o2: Any?, - ): Boolean = when (o2) { + public fun equals(o1: jp.co.soramitsu.iroha2.generated.ValidationFail.InternalError, o2: Any?): Boolean = when (o2) { null -> false else -> o2::class == o1::class } @@ -204,16 +188,14 @@ public sealed class ValidationFail : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): ValidationFail = when ( - val discriminant = - reader.readUByte() - ) { + override fun read(reader: ScaleCodecReader): ValidationFail = when (val discriminant = reader.readUByte()) { 0 -> NotPermitted.read(reader) 1 -> InstructionFailed.read(reader) 2 -> QueryFailed.read(reader) 3 -> TooComplex.read(reader) 4 -> InternalError.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } override fun write(writer: ScaleCodecWriter, instance: ValidationFail) { writer.directWrite(instance.discriminant()) @@ -223,7 +205,8 @@ public sealed class ValidationFail : ModelEnum { 2 -> QueryFailed.write(writer, instance as QueryFailed) 3 -> TooComplex.write(writer, instance as TooComplex) 4 -> InternalError.write(writer, instance as InternalError) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/WasmExecutionFail.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/WasmExecutionFail.kt index 564d512f9..f7d7f1db6 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/WasmExecutionFail.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/WasmExecutionFail.kt @@ -16,9 +16,7 @@ import kotlin.Unit * * Generated from 'WasmExecutionFail' regular structure */ -public data class WasmExecutionFail( - public val reason: String, -) { +public data class WasmExecutionFail(public val reason: String) { public companion object : ScaleReader, ScaleWriter { override fun read(reader: ScaleCodecReader): WasmExecutionFail = try { WasmExecutionFail( diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/WasmSmartContract.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/WasmSmartContract.kt index d9bde4975..ba2279bd1 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/WasmSmartContract.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/WasmSmartContract.kt @@ -19,9 +19,7 @@ import kotlin.Unit * * Generated from 'WasmSmartContract' regular structure */ -public data class WasmSmartContract( - public val vecOfU8: ByteArray, -) { +public data class WasmSmartContract(public val vecOfU8: ByteArray) { override fun equals(other: Any?): Boolean { if (this === other) return true if (other !is WasmSmartContract) return false diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Filters.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Filters.kt similarity index 63% rename from modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Filters.kt rename to modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Filters.kt index 83c4bc129..ce5f7e824 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Filters.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Filters.kt @@ -13,17 +13,13 @@ import jp.co.soramitsu.iroha2.generated.DomainId import jp.co.soramitsu.iroha2.generated.EventFilterBox import jp.co.soramitsu.iroha2.generated.ExecuteTriggerEventFilter import jp.co.soramitsu.iroha2.generated.ExecutionTime -import jp.co.soramitsu.iroha2.generated.GenericPredicateBox -import jp.co.soramitsu.iroha2.generated.NonTrivial import jp.co.soramitsu.iroha2.generated.NonZeroOfu64 import jp.co.soramitsu.iroha2.generated.PeerEventFilter import jp.co.soramitsu.iroha2.generated.PeerId import jp.co.soramitsu.iroha2.generated.PipelineEventFilterBox -import jp.co.soramitsu.iroha2.generated.QueryOutputPredicate import jp.co.soramitsu.iroha2.generated.RoleEventFilter import jp.co.soramitsu.iroha2.generated.RoleId import jp.co.soramitsu.iroha2.generated.Schedule -import jp.co.soramitsu.iroha2.generated.StringPredicate import jp.co.soramitsu.iroha2.generated.TimeEventFilter import jp.co.soramitsu.iroha2.generated.TransactionEventFilter import jp.co.soramitsu.iroha2.generated.TransactionStatus @@ -52,10 +48,7 @@ object Filters { /** * Execute a given trigger based on a specified [authority] */ - fun executeTrigger( - triggerId: TriggerId, - authority: AccountId, - ) = EventFilterBox.ExecuteTrigger( + fun executeTrigger(triggerId: TriggerId, authority: AccountId) = EventFilterBox.ExecuteTrigger( ExecuteTriggerEventFilter(triggerId, authority), ) @@ -90,10 +83,7 @@ object EntityFilters { * Match events associated with asset definition and apply another filter referenced by * its [id][OriginFilterOfAssetDefinitionEvent] or [event type][AssetDefinitionEventFilter] */ - fun byAssetDefinition( - eventSet: Long, - definitionId: AssetDefinitionId? = null, - ) = DataEventFilter.AssetDefinition( + fun byAssetDefinition(eventSet: Long, definitionId: AssetDefinitionId? = null) = DataEventFilter.AssetDefinition( AssetDefinitionEventFilter(definitionId, eventSet), ) @@ -101,10 +91,7 @@ object EntityFilters { * Match events associated with accounts and apply another filter referenced by * its [id][OriginFilterOfAccountEvent] or [event type][AccountEventFilter] */ - fun byAccount( - eventSet: Long, - accountId: AccountId? = null, - ) = DataEventFilter.Account( + fun byAccount(eventSet: Long, accountId: AccountId? = null) = DataEventFilter.Account( AccountEventFilter(accountId, eventSet), ) @@ -112,10 +99,7 @@ object EntityFilters { * Match events associated with assets and apply another filter referenced by * its [id][FilterOptOfOriginFilterOfAssetEvent] or [event type][AssetEventFilter] */ - fun byAsset( - eventSet: Long, - assetId: AssetId? = null, - ) = DataEventFilter.Asset( + fun byAsset(eventSet: Long, assetId: AssetId? = null) = DataEventFilter.Asset( AssetEventFilter(assetId, eventSet), ) @@ -123,10 +107,7 @@ object EntityFilters { * Match events associated with triggers and apply another filter referenced by * its [id][FilterOptOfOriginFilterOfTriggerEvent] or [event type][TriggerEventFilter] */ - fun byTrigger( - eventSet: Long, - triggerId: TriggerId? = null, - ) = DataEventFilter.Trigger( + fun byTrigger(eventSet: Long, triggerId: TriggerId? = null) = DataEventFilter.Trigger( TriggerEventFilter(triggerId, eventSet), ) @@ -134,10 +115,7 @@ object EntityFilters { * Match events associated with domains and apply another filter referenced by * its [id][FilterOptOfOriginFilterOfDomainEvent] or [event type][DomainEventFilter] */ - fun byDomain( - eventSet: Long, - domainId: DomainId? = null, - ) = DataEventFilter.Domain( + fun byDomain(eventSet: Long, domainId: DomainId? = null) = DataEventFilter.Domain( DomainEventFilter(domainId, eventSet), ) @@ -145,10 +123,7 @@ object EntityFilters { * Match events associated with peers and apply another filter referenced by * its [id][FilterOptOfOriginFilterOfPeerEvent] or [event type][PeerEventFilter] */ - fun byPeer( - eventSet: Long, - peerId: PeerId? = null, - ) = DataEventFilter.Peer( + fun byPeer(eventSet: Long, peerId: PeerId? = null) = DataEventFilter.Peer( PeerEventFilter(peerId, eventSet), ) @@ -156,10 +131,7 @@ object EntityFilters { * Match events associated with roles and apply another filter referenced by * its [id][FilterOptOriginFilterRoleEvent] or [event type][RoleEventFilter] */ - fun byRole( - eventSet: Long, - roleId: RoleId? = null, - ) = DataEventFilter.Role( + fun byRole(eventSet: Long, roleId: RoleId? = null) = DataEventFilter.Role( RoleEventFilter(roleId, eventSet), ) } @@ -172,63 +144,10 @@ object EventFilters { /** * Create a filter with a timed execution */ - fun timeEventFilter( - start: BigInteger, - period: BigInteger? = null, - ) = TimeEventFilter(ExecutionTime.Schedule(Schedule(start, period))) + fun timeEventFilter(start: BigInteger, period: BigInteger? = null) = TimeEventFilter(ExecutionTime.Schedule(Schedule(start, period))) /** * Create a pre-commit filter */ fun timeEventFilter() = TimeEventFilter(ExecutionTime.PreCommit()) } - -/** - * Query filters - */ -object QueryFilters { - - /** - * Starts with filter - */ - fun startsWith(prefix: String) = GenericPredicateBox.Raw( - QueryOutputPredicate.Identifiable(StringPredicate.StartsWith(prefix)), - ) - - /** - * Ends with filter - */ - fun endsWith(suffix: String) = GenericPredicateBox.Raw( - QueryOutputPredicate.Identifiable(StringPredicate.EndsWith(suffix)), - ) - - /** - * Contains filter - */ - fun contains(value: String) = GenericPredicateBox.Raw( - QueryOutputPredicate.Identifiable(StringPredicate.Contains(value)), - ) - - /** - * Is filter - */ - fun `is`(value: String) = GenericPredicateBox.Raw( - QueryOutputPredicate.Identifiable(StringPredicate.Is(value)), - ) - - /** - * Filter for multiple matches (OR) - */ - fun or(vararg predicates: StringPredicate) = predicates - .map { GenericPredicateBox.Raw(QueryOutputPredicate.Identifiable(it)) }.toList() - .let { NonTrivial>(it) } - .let { GenericPredicateBox.Or(it) } - - /** - * Filter for multiple matches (AND) - */ - fun and(vararg predicates: StringPredicate) = predicates - .map { GenericPredicateBox.Raw(QueryOutputPredicate.Identifiable(it)) }.toList() - .let { NonTrivial>(it) } - .let { GenericPredicateBox.And(it) } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Instructions.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Instructions.kt new file mode 100644 index 000000000..c8d2d9612 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Instructions.kt @@ -0,0 +1,443 @@ +package jp.co.soramitsu.iroha2.transaction + +import jp.co.soramitsu.iroha2.ModelParameter +import jp.co.soramitsu.iroha2.ModelPermission +import jp.co.soramitsu.iroha2.TriggerArgs +import jp.co.soramitsu.iroha2.asNumeric +import jp.co.soramitsu.iroha2.generated.AccountId +import jp.co.soramitsu.iroha2.generated.Action +import jp.co.soramitsu.iroha2.generated.Asset +import jp.co.soramitsu.iroha2.generated.AssetDefinitionId +import jp.co.soramitsu.iroha2.generated.AssetId +import jp.co.soramitsu.iroha2.generated.AssetType +import jp.co.soramitsu.iroha2.generated.AssetValue +import jp.co.soramitsu.iroha2.generated.BlockParameter +import jp.co.soramitsu.iroha2.generated.BurnOfNumericAndAsset +import jp.co.soramitsu.iroha2.generated.BurnOfu32AndTrigger +import jp.co.soramitsu.iroha2.generated.CustomParameter +import jp.co.soramitsu.iroha2.generated.CustomParameterId +import jp.co.soramitsu.iroha2.generated.DomainId +import jp.co.soramitsu.iroha2.generated.EventFilterBox +import jp.co.soramitsu.iroha2.generated.Executable +import jp.co.soramitsu.iroha2.generated.ExecuteTrigger +import jp.co.soramitsu.iroha2.generated.Executor +import jp.co.soramitsu.iroha2.generated.GrantOfPermissionAndAccount +import jp.co.soramitsu.iroha2.generated.GrantOfPermissionAndRole +import jp.co.soramitsu.iroha2.generated.GrantOfRoleIdAndAccount +import jp.co.soramitsu.iroha2.generated.HashOf +import jp.co.soramitsu.iroha2.generated.InstructionBox +import jp.co.soramitsu.iroha2.generated.IpfsPath +import jp.co.soramitsu.iroha2.generated.Json +import jp.co.soramitsu.iroha2.generated.Metadata +import jp.co.soramitsu.iroha2.generated.MintOfNumericAndAsset +import jp.co.soramitsu.iroha2.generated.MintOfu32AndTrigger +import jp.co.soramitsu.iroha2.generated.Mintable +import jp.co.soramitsu.iroha2.generated.MultisigApprove +import jp.co.soramitsu.iroha2.generated.MultisigPropose +import jp.co.soramitsu.iroha2.generated.MultisigRegister +import jp.co.soramitsu.iroha2.generated.MultisigSpec +import jp.co.soramitsu.iroha2.generated.Name +import jp.co.soramitsu.iroha2.generated.NewAccount +import jp.co.soramitsu.iroha2.generated.NewAssetDefinition +import jp.co.soramitsu.iroha2.generated.NewDomain +import jp.co.soramitsu.iroha2.generated.NewRole +import jp.co.soramitsu.iroha2.generated.NonZeroOfu64 +import jp.co.soramitsu.iroha2.generated.Parameter +import jp.co.soramitsu.iroha2.generated.PeerId +import jp.co.soramitsu.iroha2.generated.RegisterOfAccount +import jp.co.soramitsu.iroha2.generated.RegisterOfAsset +import jp.co.soramitsu.iroha2.generated.RegisterOfAssetDefinition +import jp.co.soramitsu.iroha2.generated.RegisterOfDomain +import jp.co.soramitsu.iroha2.generated.RegisterOfPeer +import jp.co.soramitsu.iroha2.generated.RegisterOfRole +import jp.co.soramitsu.iroha2.generated.RegisterOfTrigger +import jp.co.soramitsu.iroha2.generated.RemoveKeyValueOfAccount +import jp.co.soramitsu.iroha2.generated.RemoveKeyValueOfAsset +import jp.co.soramitsu.iroha2.generated.RemoveKeyValueOfAssetDefinition +import jp.co.soramitsu.iroha2.generated.RemoveKeyValueOfDomain +import jp.co.soramitsu.iroha2.generated.RemoveKeyValueOfTrigger +import jp.co.soramitsu.iroha2.generated.Repeats +import jp.co.soramitsu.iroha2.generated.RevokeOfPermissionAndAccount +import jp.co.soramitsu.iroha2.generated.RevokeOfPermissionAndRole +import jp.co.soramitsu.iroha2.generated.RevokeOfRoleIdAndAccount +import jp.co.soramitsu.iroha2.generated.Role +import jp.co.soramitsu.iroha2.generated.RoleId +import jp.co.soramitsu.iroha2.generated.SetKeyValueOfAccount +import jp.co.soramitsu.iroha2.generated.SetKeyValueOfAsset +import jp.co.soramitsu.iroha2.generated.SetKeyValueOfAssetDefinition +import jp.co.soramitsu.iroha2.generated.SetKeyValueOfDomain +import jp.co.soramitsu.iroha2.generated.SetKeyValueOfTrigger +import jp.co.soramitsu.iroha2.generated.SetParameter +import jp.co.soramitsu.iroha2.generated.SmartContractParameter +import jp.co.soramitsu.iroha2.generated.SumeragiParameter +import jp.co.soramitsu.iroha2.generated.TransactionParameter +import jp.co.soramitsu.iroha2.generated.TransferOfAccountAndAssetDefinitionIdAndAccount +import jp.co.soramitsu.iroha2.generated.TransferOfAccountAndDomainIdAndAccount +import jp.co.soramitsu.iroha2.generated.TransferOfAssetAndMetadataAndAccount +import jp.co.soramitsu.iroha2.generated.TransferOfAssetAndNumericAndAccount +import jp.co.soramitsu.iroha2.generated.Trigger +import jp.co.soramitsu.iroha2.generated.TriggerId +import jp.co.soramitsu.iroha2.generated.UnregisterOfAccount +import jp.co.soramitsu.iroha2.generated.UnregisterOfAsset +import jp.co.soramitsu.iroha2.generated.UnregisterOfAssetDefinition +import jp.co.soramitsu.iroha2.generated.UnregisterOfDomain +import jp.co.soramitsu.iroha2.generated.UnregisterOfPeer +import jp.co.soramitsu.iroha2.generated.UnregisterOfRole +import jp.co.soramitsu.iroha2.generated.UnregisterOfTrigger +import jp.co.soramitsu.iroha2.generated.Upgrade +import jp.co.soramitsu.iroha2.generated.WasmSmartContract +import jp.co.soramitsu.iroha2.writeValue +import java.math.BigDecimal + +interface Instruction { + fun asInstructionBox(): InstructionBox +} + +class Register { + companion object { + /** + * Register a peer + */ + fun peer(peerId: PeerId) = RegisterOfPeer(peerId) + + /** + * Register a domain + */ + fun domain( + domainId: DomainId, + metadata: Map = mapOf(), + logo: IpfsPath? = null, + ) = RegisterOfDomain(NewDomain(domainId, logo, Metadata(metadata))) + + /** + * Register an asset + */ + fun assetDefinition( + id: AssetDefinitionId, + assetType: AssetType, + mintable: Mintable = Mintable.Infinitely(), + logo: IpfsPath? = null, + metadata: Metadata = Metadata(mapOf()), + ) = RegisterOfAssetDefinition(NewAssetDefinition(id, assetType, mintable, logo, metadata)) + + /** + * Register an account + */ + fun account(id: AccountId, metadata: Metadata = Metadata(mapOf())) = RegisterOfAccount(NewAccount(id, metadata)) + + /** + * Register an asset + */ + fun asset(id: AssetId, assetValue: AssetValue) = RegisterOfAsset(Asset(id, assetValue)) + + /** + * Register a role that has the specified permissions + */ + fun role( + grantTo: AccountId, + roleId: RoleId, + vararg tokens: ModelPermission, + ) = RegisterOfRole(NewRole(Role(roleId, tokens.map { it.asRaw() }), grantTo)) + + /** + * Register a trigger + */ + fun trigger( + triggerId: TriggerId, + isi: List, + repeats: Repeats, + accountId: AccountId, + filter: EventFilterBox, + metadata: Metadata = Metadata(mapOf()), + ) = RegisterOfTrigger( + Trigger( + triggerId, + Action(Executable.Instructions(isi.map { it.asInstructionBox() }), repeats, accountId, filter, metadata), + ), + ) + + /** + * Register a WASM trigger + */ + fun trigger( + triggerId: TriggerId, + wasm: ByteArray, + repeats: Repeats, + accountId: AccountId, + filter: EventFilterBox, + metadata: Metadata = Metadata(mapOf()), + ) = RegisterOfTrigger( + Trigger( + triggerId, + Action(Executable.Wasm(WasmSmartContract(wasm)), repeats, accountId, filter, metadata), + ), + ) + } +} + +class Unregister { + companion object { + /** + * Unregister a peer + */ + fun peer(peerId: PeerId) = UnregisterOfPeer(peerId) + + /** + * Unregister a domain + */ + fun domain(id: DomainId) = UnregisterOfDomain(id) + + /** + * Unregister an asset definition + */ + fun assetDefinition(id: AssetDefinitionId) = UnregisterOfAssetDefinition(id) + + /** + * Unregister an account + */ + fun account(id: AccountId) = UnregisterOfAccount(id) + + /** + * Unregister an asset + */ + fun asset(id: AssetId) = UnregisterOfAsset(id) + + /** + * Unregister a role + */ + fun role(id: RoleId) = UnregisterOfRole(id) + + /** + * Unregister a trigger + */ + fun trigger(id: TriggerId) = UnregisterOfTrigger(id) + } +} + +class SetKeyValue { + companion object { + /** + * Set key/value in the metadata of a given domain + */ + fun domain( + domainId: DomainId, + key: Name, + value: V, + ) = SetKeyValueOfDomain(domainId, key, Json.writeValue(value)) + + /** + * Set key/value for a given asset definition + */ + fun assetDefinition( + definitionId: AssetDefinitionId, + key: Name, + value: V, + ) = SetKeyValueOfAssetDefinition(definitionId, key, Json.writeValue(value)) + + /** + * Set key/value in the metadata of a given account + */ + fun account( + accountId: AccountId, + key: Name, + value: V, + ) = SetKeyValueOfAccount(accountId, key, Json.writeValue(value)) + + /** + * Set key/value for a given asset + */ + fun asset( + assetId: AssetId, + key: Name, + value: V, + ) = SetKeyValueOfAsset(assetId, key, Json.writeValue(value)) + + /** + * Set key/value for a given trigger + */ + fun trigger( + triggerId: TriggerId, + key: Name, + value: V, + ) = SetKeyValueOfTrigger(triggerId, key, Json.writeValue(value)) + } +} + +class RemoveKeyValue { + companion object { + /** + * Remove key/value from a given domain + */ + fun domain(domainId: DomainId, key: Name) = RemoveKeyValueOfDomain(domainId, key) + + /** + * Remove key/value from a given asset definition + */ + fun assetDefinition(assetDefinitionId: AssetDefinitionId, key: Name) = RemoveKeyValueOfAssetDefinition(assetDefinitionId, key) + + /** + * Remove key/value from a given account + */ + fun account(accountId: AccountId, key: Name) = RemoveKeyValueOfAccount(accountId, key) + + /** + * Remove key/value from a given asset + */ + fun asset(assetId: AssetId, key: Name) = RemoveKeyValueOfAsset(assetId, key) + + /** + * Remove key/value from a given trigger + */ + fun trigger(triggerId: TriggerId, key: Name) = RemoveKeyValueOfTrigger(triggerId, key) + } +} + +class Mint { + companion object { + /** + * Increase a numeric asset by the given amount + */ + fun asset(assetId: AssetId, quantity: BigDecimal) = MintOfNumericAndAsset(quantity.asNumeric(), assetId) + + /** + * Increase number of trigger repetitions + */ + fun trigger(triggerId: TriggerId, quantity: Long) = MintOfu32AndTrigger(quantity, triggerId) + } +} + +class Burn { + companion object { + /** + * Decrease a numeric asset by the given amount + */ + fun asset(assetId: AssetId, value: BigDecimal) = BurnOfNumericAndAsset(value.asNumeric(), assetId) + + /** + * Decrease number of trigger repetitions + */ + fun trigger(triggerId: TriggerId, quantity: Long) = BurnOfu32AndTrigger(quantity, triggerId) + } +} + +class Transfer { + companion object { + /** + * Transfer domain ownership. + */ + fun domain( + sourceId: AccountId, + domainId: DomainId, + destinationId: AccountId, + ) = TransferOfAccountAndDomainIdAndAccount(sourceId, domainId, destinationId) + + /** + * Transfer asset definition ownership + */ + fun assetDefinition( + sourceId: AccountId, + value: AssetDefinitionId, + destinationId: AccountId, + ) = TransferOfAccountAndAssetDefinitionIdAndAccount(sourceId, value, destinationId) + + /** + * Transfer a numeric asset + */ + fun asset( + sourceId: AssetId, + value: Metadata, + destinationId: AccountId, + ) = TransferOfAssetAndMetadataAndAccount(sourceId, value, destinationId) + + /** + * Transfer a store asset + */ + fun asset( + sourceId: AssetId, + value: BigDecimal, + destinationId: AccountId, + ) = TransferOfAssetAndNumericAndAccount(sourceId, value.asNumeric(), destinationId) + } +} + +class Grant { + companion object { + /** + * Grant permission to the given account + */ + fun

accountPermission(permission: P, destinationId: AccountId) = GrantOfPermissionAndAccount( + permission.asRaw(), + destinationId, + ) + + /** + * Grant role to the given account + */ + fun accountRole(roleId: RoleId, destinationId: AccountId) = GrantOfRoleIdAndAccount(roleId, destinationId) + + /** + * Grant permission to the given role + */ + fun

rolePermission(permission: P, destinationId: RoleId) = + GrantOfPermissionAndRole(permission.asRaw(), destinationId) + } +} + +class Revoke { + companion object { + /** + * Revoke permission from the given account + */ + fun

accountPermission(permission: P, accountId: AccountId) = + RevokeOfPermissionAndAccount(permission.asRaw(), accountId) + + /** + * Revoke role from the given account + */ + fun accountRole(roleId: RoleId, accountId: AccountId) = RevokeOfRoleIdAndAccount(roleId, accountId) + + /** + * Revoke permission from the given role + */ + fun

rolePermission(permission: P, roleId: RoleId) = RevokeOfPermissionAndRole(permission.asRaw(), roleId) + } +} + +class Execute { + companion object { + /** + * Execute a pre-registered trigger + */ + fun trigger(triggerId: TriggerId, args: A? = null) = ExecuteTrigger(triggerId, Json.writeValue(args)) + } +} + +class Upgrade { + companion object { + /** + * Upgrade executor + */ + fun executor(executor: Executor) = Upgrade(executor) + } +} + +class SetParameter { + fun sumeragi(parameter: SumeragiParameter) = SetParameter(Parameter.Sumeragi(parameter)) + fun block(parameter: BlockParameter) = SetParameter(Parameter.Block(parameter)) + fun transaction(parameter: TransactionParameter) = SetParameter(Parameter.Transaction(parameter)) + fun smartContract(parameter: SmartContractParameter) = SetParameter(Parameter.SmartContract(parameter)) + fun executor(parameter: SmartContractParameter) = SetParameter(Parameter.Executor(parameter)) + fun

custom(id: CustomParameterId, value: P) = + SetParameter(Parameter.Custom(CustomParameter(id, Json.writeValue(value)))) +} + +class Multisig { + fun register(accountId: AccountId, spec: MultisigSpec) = MultisigRegister(accountId, spec) + fun propose( + account: AccountId, + instructions: List, + transactionTtlMs: NonZeroOfu64? = null, + ) = MultisigPropose(account, instructions.map { it.asInstructionBox() }, transactionTtlMs) + + fun approve(account: AccountId, instructionsHash: HashOf>) = MultisigApprove(account, instructionsHash) +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/TransactionBuilder.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/TransactionBuilder.kt new file mode 100644 index 000000000..88fc36789 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/TransactionBuilder.kt @@ -0,0 +1,59 @@ +@file:Suppress("ktlint:standard:no-wildcard-imports") + +package jp.co.soramitsu.iroha2.transaction + +import jp.co.soramitsu.iroha2.* +import jp.co.soramitsu.iroha2.generated.* +import java.math.BigInteger +import java.security.KeyPair +import java.time.Duration +import java.util.UUID + +class TransactionBuilder(var chain: UUID) { + private val instructions: Lazy> = lazy { ArrayList() } + private var timeToLiveMillis: BigInteger = DURATION_OF_24_HOURS_IN_MILLIS + private var nonce: Long? = null + private var metadata: Lazy> = lazy { HashMap() } + + companion object { + val DURATION_OF_24_HOURS_IN_MILLIS = Duration.ofHours(24).toMillis().toBigInteger() + } + + fun addInstructions(vararg instructions: Instruction) = this.apply { + this.instructions.value.addAll( + instructions.map { + it.asInstructionBox() + }, + ) + } + + fun addInstructions(instructions: Iterable) = this.apply { + this.instructions.value.addAll( + instructions.map { + it.asInstructionBox() + }, + ) + } + + fun addInstruction(instruction: Instruction) = this.apply { this.instructions.value.add(instruction.asInstructionBox()) } + + fun timeToLive(ttl: Duration) = this.apply { this.timeToLiveMillis = ttl.toMillis().toBigInteger() } + + fun signAs(accountId: AccountId, keyPair: KeyPair): SignedTransaction { + val payload = TransactionPayload( + ChainId(chain.toString()), + accountId, + System.currentTimeMillis().toBigInteger(), + Executable.Instructions(instructions.value), + NonZeroOfu64(timeToLiveMillis), + nonce?.takeIf { it > 0 }?.let(::NonZeroOfu32), + Metadata(metadata.value), + ) + val encodedPayload = TransactionPayload.encode(payload) + val signature = Signature(keyPair.private.signAs(encodedPayload)).asSignatureOf() + + return SignedTransaction.V1( + SignedTransactionV1(TransactionSignature(signature), payload), + ) + } +} diff --git a/modules/test-tools/build.gradle b/modules/test-tools/build.gradle index 14d66d38b..1eb0225b6 100644 --- a/modules/test-tools/build.gradle +++ b/modules/test-tools/build.gradle @@ -1,20 +1,21 @@ dependencies { - api project(":client") - api project(":admin-client") - api project(":block") + implementation project(":admin-client") + implementation project(":block") - api "org.jetbrains.kotlin:kotlin-test:$kotlinVer" - api "org.jetbrains.kotlin:kotlin-test-junit5:$kotlinVer" - api "org.jetbrains.kotlin:kotlin-reflect:$kotlinVer" - api "org.testcontainers:testcontainers:$testContainersVer" - api "org.jetbrains.kotlin:kotlin-test-junit5:$kotlinVer" + implementation "org.testcontainers:testcontainers:$testContainersVer" + + implementation "io.ktor:ktor-client-logging:$ktorVer" + implementation "org.jetbrains.kotlin:kotlin-test:$kotlinVer" + implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlinVer" + implementation "org.jetbrains.kotlin:kotlin-test-junit5:$kotlinVer" implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVer" - implementation "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:$coroutinesVer" implementation "ch.qos.logback:logback-classic:$logbackVer" implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlinVer" implementation "org.yaml:snakeyaml:2.0" + implementation "com.fasterxml.jackson.module:jackson-module-kotlin:$jacksonKotlinVer" + testImplementation "org.jetbrains.kotlin:kotlin-test:$kotlinVer" } diff --git a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaConfig.kt b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaConfig.kt index 7a0e8ceed..1aa5f04d4 100644 --- a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaConfig.kt +++ b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaConfig.kt @@ -4,6 +4,7 @@ import jp.co.soramitsu.iroha2.DEFAULT_API_PORT import jp.co.soramitsu.iroha2.DEFAULT_P2P_PORT import jp.co.soramitsu.iroha2.Genesis import jp.co.soramitsu.iroha2.generateKeyPair +import jp.co.soramitsu.iroha2.generated.Peer import jp.co.soramitsu.iroha2.generated.PeerId import jp.co.soramitsu.iroha2.generated.SocketAddr import jp.co.soramitsu.iroha2.generated.SocketAddrHost @@ -18,6 +19,7 @@ import org.testcontainers.images.ImagePullPolicy import org.testcontainers.images.PullPolicy import java.security.KeyPair import java.time.Duration +import java.util.UUID import java.util.function.Consumer /** @@ -33,16 +35,16 @@ class IrohaConfig( var pullPolicy: ImagePullPolicy = PullPolicy.ageBased(Duration.ofMinutes(10)), var alias: String = IrohaContainer.NETWORK_ALIAS + DEFAULT_P2P_PORT, var keyPair: KeyPair = generateKeyPair(), + var chain: UUID = UUID.fromString("00000000-0000-0000-0000-000000000000"), var genesisKeyPair: KeyPair = keyPairFromHex(GENESIS_ADDRESS, GENESIS_PRIVATE_KEY), - var trustedPeers: List = listOf( - PeerId(SocketAddr.Host(SocketAddrHost(alias, DEFAULT_P2P_PORT)), keyPair.public.toIrohaPublicKey()), + var trustedPeers: List = listOf( + Peer(SocketAddr.Host(SocketAddrHost(alias, DEFAULT_P2P_PORT)), PeerId(keyPair.public.toIrohaPublicKey())), ), var ports: List = listOf(DEFAULT_P2P_PORT, DEFAULT_API_PORT), var shouldCloseNetwork: Boolean = true, var waitStrategy: Boolean = true, var submitGenesis: Boolean = true, var envs: Map = emptyMap(), - var fetchSize: Int = 10, var executorPath: String? = null, ) { companion object { diff --git a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaContainer.kt b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaContainer.kt index 7edfabfaa..ba268fd89 100644 --- a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaContainer.kt +++ b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaContainer.kt @@ -11,6 +11,7 @@ import org.testcontainers.utility.DockerImageName import org.testcontainers.utility.MountableFile import org.testcontainers.utility.MountableFile.forHostPath import java.io.IOException +import java.net.URI import java.net.URL import java.nio.file.Files import java.time.Duration @@ -40,26 +41,38 @@ open class IrohaContainer : GenericContainer { val genesisPublicKey = config.genesisKeyPair.public.bytes().toHex() val genesisPrivateKey = config.genesisKeyPair.private.bytes().toHex() + val topology = config.trustedPeers.map { it.id.publicKey.payload.toHex(true) } + this.p2pPort = config.ports[IrohaConfig.P2P_PORT_IDX] this.apiPort = config.ports[IrohaConfig.API_PORT_IDX] this.config = config this.withNetwork(config.networkToJoin) - .withEnv("CHAIN", "00000000-0000-0000-0000-000000000000") - .withEnv("TRUSTED_PEERS", JSON_SERDE.writeValueAsString(config.trustedPeers)) + .withEnv("CHAIN", config.chain.toString()) + .withEnv( + "TRUSTED_PEERS", + "[" + + config.trustedPeers.joinToString(",") { + JSON_SERDE.writeValueAsString( + it.id.publicKey, + ).trimEnd('"') + "@" + JSON_SERDE.writeValueAsString(it.address).trimStart( + '"', + ) + } + "]", + ) .withEnv("PUBLIC_KEY", "ed0120$publicKey") .withEnv("PRIVATE_KEY", "802620$privateKey") .withEnv("GENESIS_PUBLIC_KEY", "ed0120$genesisPublicKey") + .withEnv("P2P_PUBLIC_ADDRESS", "${config.alias}:$p2pPort") .withEnv("P2P_ADDRESS", "${config.alias}:$p2pPort") .withEnv("API_ADDRESS", "${config.alias}:$apiPort") - .withEnv("TORII_FETCH_SIZE", config.fetchSize.toString()) .withCreateContainerCmdModifier { cmd -> cmd.withName(containerName) } .also { container -> if (config.submitGenesis) { container.withEnv("GENESIS_PRIVATE_KEY", "802620$genesisPrivateKey") container.withEnv("GENESIS", "/tmp/genesis.signed.scale") - container.withEnv("TOPOLOGY", JSON_SERDE.writeValueAsString(config.trustedPeers)) + container.withEnv("TOPOLOGY", JSON_SERDE.writeValueAsString(topology)) } } .also { container -> config.envs.forEach { (k, v) -> container.withEnv(k, v) } } @@ -73,8 +86,7 @@ open class IrohaContainer : GenericContainer { .withCopyToContainer( forHostPath(configDirLocation), "/app/.cache/wasmtime", - ) - .also { + ).also { config.genesis?.writeToFile(genesisFileLocation) config.genesisPath?.also { path -> Files.copy(Path(path).toAbsolutePath(), genesisFileLocation) } @@ -87,8 +99,7 @@ open class IrohaContainer : GenericContainer { executorFileLocation.toFile().writeBytes(content) } } - } - .also { container -> + }.also { container -> if (config.submitGenesis) { container.withCopyFileToContainer( MountableFile.forClasspathResource("start.sh"), @@ -124,9 +135,9 @@ open class IrohaContainer : GenericContainer { private val executorFileLocation = Path("$configDirLocation/$DEFAULT_EXECUTOR_FILE_NAME") override fun start() { - logger().debug("Starting Iroha container") + logger().info("Starting Iroha container") super.start() - logger().debug("Iroha container started") + logger().info("Iroha container started") } override fun stop() { @@ -145,9 +156,7 @@ open class IrohaContainer : GenericContainer { logger().debug("Iroha container stopped") } - fun getP2pUrl(): URL = URL("http", host, this.getMappedPort(p2pPort), "") - - fun getApiUrl(): URL = URL("http", host, this.getMappedPort(apiPort), "") + fun getApiUrl(): URL = URI("http://$host:${getMappedPort(apiPort)}").toURL() private fun String.readStatusBlocks() = JSON_SERDE.readTree(this).get("blocks")?.doubleValue() @@ -161,7 +170,7 @@ open class IrohaContainer : GenericContainer { } const val NETWORK_ALIAS = "iroha" - const val DEFAULT_IMAGE_TAG = "2.0.0-pre-rc.22.2" + const val DEFAULT_IMAGE_TAG = "dev" const val DEFAULT_IMAGE_NAME = "hyperledger/iroha" const val DEFAULT_EXECUTOR_FILE_NAME = "executor.wasm" const val DEFAULT_GENESIS_FILE_NAME = "genesis.json" diff --git a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaRunnerExtension.kt b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaRunnerExtension.kt index 214c18202..b4e5f1bab 100644 --- a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaRunnerExtension.kt +++ b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaRunnerExtension.kt @@ -7,17 +7,14 @@ import jp.co.soramitsu.iroha2.DEFAULT_P2P_PORT import jp.co.soramitsu.iroha2.Genesis import jp.co.soramitsu.iroha2.Genesis.Companion.toSingle import jp.co.soramitsu.iroha2.IrohaSdkException -import jp.co.soramitsu.iroha2.asAccountId import jp.co.soramitsu.iroha2.cast -import jp.co.soramitsu.iroha2.client.Iroha2AsyncClient import jp.co.soramitsu.iroha2.client.Iroha2Client import jp.co.soramitsu.iroha2.generateKeyPair import jp.co.soramitsu.iroha2.generated.ChainId +import jp.co.soramitsu.iroha2.generated.Peer import jp.co.soramitsu.iroha2.generated.PeerId import jp.co.soramitsu.iroha2.generated.SocketAddr import jp.co.soramitsu.iroha2.generated.SocketAddrHost -import jp.co.soramitsu.iroha2.keyPairFromHex -import jp.co.soramitsu.iroha2.model.IrohaUrls import jp.co.soramitsu.iroha2.toIrohaPublicKey import kotlinx.coroutines.Deferred import kotlinx.coroutines.Dispatchers @@ -33,8 +30,11 @@ import org.yaml.snakeyaml.Yaml import java.io.File import java.lang.reflect.Field import java.lang.reflect.Method +import java.net.URI import java.security.KeyPair import java.util.Collections +import java.util.UUID +import kotlin.collections.ArrayList import kotlin.reflect.KClass import kotlin.reflect.KMutableProperty1 import kotlin.reflect.KProperty1 @@ -44,7 +44,9 @@ import kotlin.reflect.full.memberProperties /** * Runner for Iroha2 Docker containers */ -class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { +class IrohaRunnerExtension : + InvocationInterceptor, + BeforeEachCallback { private val resources: MutableMap> = Collections.synchronizedMap(mutableMapOf()) @@ -71,9 +73,7 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { } } - private suspend fun initIfRequested( - extensionContext: ExtensionContext, - ): List = coroutineScope { + private suspend fun initIfRequested(extensionContext: ExtensionContext): List = coroutineScope { val withIroha = extensionContext.element.get() .annotations.filterIsInstance() .firstOrNull() @@ -97,12 +97,7 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { utilizedResources.addAll(containers) val properties = testInstance::class.memberProperties - - // inject `KeyPair` if it is declared in test class - setPropertyValue(properties, testInstance) { ALICE_ACCOUNT_ID } - - // inject `AccountId` if it is declared in test class - setPropertyValue(properties, testInstance) { ALICE_KEYPAIR } + val defaultChainId = UUID.fromString("00000000-0000-0000-0000-000000000000") // inject `List` if it is declared in test class setPropertyValue(properties, testInstance) { containers } @@ -110,28 +105,30 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { // inject `Iroha2Client` if it is declared in test class setPropertyValue(properties, testInstance) { Iroha2Client( - containers.map { IrohaUrls(it.getApiUrl(), it.getP2pUrl()) }.toMutableList(), + containers.map { it.getApiUrl() }.toMutableList(), + defaultChainId, + ALICE_ACCOUNT_ID, + ALICE_KEYPAIR, ).also { utilizedResources.add(it) } } // inject `AdminIroha2Client` if it is declared in test class setPropertyValue(properties, testInstance) { AdminIroha2Client( - containers.map { IrohaUrls(it.getApiUrl(), it.getP2pUrl()) }.toMutableList(), - ).also { utilizedResources.add(it) } - } - - // inject `Iroha2AsyncClient` if it is declared in test class - setPropertyValue(properties, testInstance) { - Iroha2AsyncClient( - containers.map { IrohaUrls(it.getApiUrl(), it.getP2pUrl()) }.toMutableList(), + containers.map { it.getApiUrl() }.toMutableList(), + defaultChainId, + ALICE_ACCOUNT_ID, + ALICE_KEYPAIR, ).also { utilizedResources.add(it) } } // inject `AdminIroha2AsyncClient` if it is declared in test class setPropertyValue(properties, testInstance) { AdminIroha2AsyncClient( - containers.map { IrohaUrls(it.getApiUrl(), it.getP2pUrl()) }.toMutableList(), + containers.map { it.getApiUrl() }.toMutableList(), + defaultChainId, + ALICE_ACCOUNT_ID, + ALICE_KEYPAIR, ).also { utilizedResources.add(it) } } @@ -143,30 +140,30 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { val properties = testInstance::class.memberProperties val urls = when (this.dockerComposeFile.isEmpty()) { - true -> this.apiUrls.mapIndexed { idx, url -> IrohaUrls(url, peerUrls[idx]) } - else -> File(this.dockerComposeFile).readDockerComposeData() + true -> this.apiUrls.map { url -> URI.create(url).toURL() } + else -> File(this.dockerComposeFile).readDockerComposeData()?.map { url -> URI.create(url).toURL() } } ?: throw IrohaSdkException("Iroha URLs required") - // inject `KeyPair` if it is declared in test class - setPropertyValue(properties, testInstance) { keyPairFromHex(this.publicKey, this.privateKey) } + // // inject `KeyPair` if it is declared in test class + // setPropertyValue(properties, testInstance) { keyPairFromHex(this.publicKey, this.privateKey) } - // inject `AccountId` if it is declared in test class - setPropertyValue(properties, testInstance) { this.account.asAccountId() } + // // inject `AccountId` if it is declared in test class + // setPropertyValue(properties, testInstance) { this.account.asAccountId() } - // inject `Iroha2Client` if it is declared in test class - setPropertyValue(properties, testInstance) { Iroha2Client(urls) } + // // inject `Iroha2Client` if it is declared in test class + // setPropertyValue(properties, testInstance) { Iroha2Client(urls, chain, this.a, keyPair) } - // inject `AdminIroha2Client` if it is declared in test class - setPropertyValue(properties, testInstance) { AdminIroha2Client(urls) } + // // inject `AdminIroha2Client` if it is declared in test class + // setPropertyValue(properties, testInstance) { AdminIroha2Client(urls, chain, authority, keyPair) } - // inject `Iroha2AsyncClient` if it is declared in test class - setPropertyValue(properties, testInstance) { Iroha2AsyncClient(urls) } + // // inject `Iroha2AsyncClient` if it is declared in test class + // setPropertyValue(properties, testInstance) { Iroha2AsyncClient(urls, chain, authority, keyPair) } - // inject `AdminIroha2AsyncClient` if it is declared in test class - setPropertyValue(properties, testInstance) { AdminIroha2AsyncClient(urls) } + // // inject `AdminIroha2AsyncClient` if it is declared in test class + // setPropertyValue(properties, testInstance) { AdminIroha2AsyncClient(urls, chain, authority, keyPair) } } - private fun File.readDockerComposeData(): List? { + private fun File.readDockerComposeData(): List? { fun String?.convertUrl() = this ?.replace("${IrohaContainer.NETWORK_ALIAS}[0-9]*".toRegex(), "localhost") ?.let { "http://$it" } @@ -180,10 +177,7 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { }.onFailure { return null }.getOrThrow() return all.map { - IrohaUrls( - it["TORII_API_URL"].convertUrl(), - it["TORII_P2P_ADDR"].convertUrl(), - ) + it["TORII_API_URL"].convertUrl() } } @@ -207,10 +201,7 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { ?.call(testClassInstance, valueToSet()) } - private suspend fun createContainers( - withIroha: WithIroha, - testInstance: IrohaTest<*>, - ): List = coroutineScope { + private suspend fun createContainers(withIroha: WithIroha, testInstance: IrohaTest<*>): List = coroutineScope { val keyPairs = mutableListOf() val portsList = mutableListOf>() @@ -220,14 +211,17 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { } val peerIds = keyPairs.mapIndexed { i: Int, kp: KeyPair -> val p2pPort = portsList[i][IrohaConfig.P2P_PORT_IDX] - kp.toPeerId(IrohaContainer.NETWORK_ALIAS + p2pPort, p2pPort) + Peer( + SocketAddr.Host(SocketAddrHost(IrohaContainer.NETWORK_ALIAS + p2pPort, p2pPort)), + kp.toPeerId(), + ) } val deferredSet = mutableSetOf>() val containers = Collections.synchronizedList(ArrayList(withIroha.amount)) repeat(withIroha.amount) { n -> async { val p2pPort = portsList[n][IrohaConfig.P2P_PORT_IDX] - val container = IrohaContainer { + val container: IrohaContainer = IrohaContainer { this.networkToJoin = testInstance.network when { withIroha.source.isNotEmpty() -> genesisPath = withIroha.source @@ -264,8 +258,7 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { containers } - private fun KeyPair.toPeerId(host: String, port: Int) = PeerId( - SocketAddr.Host(SocketAddrHost(host, port)), + private fun KeyPair.toPeerId() = PeerId( this.public.toIrohaPublicKey(), ) @@ -273,7 +266,7 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { private fun genesisInstance(clazz: KClass): Genesis = clazz.createInstance().let { genesis -> val tx = genesis.transaction.copy( - chain = ChainId("00000000-0000-0000-0000-000000000000"), + ChainId("00000000-0000-0000-0000-000000000000"), ) val transactionField = findField(clazz.java, "transaction") transactionField.isAccessible = true @@ -282,14 +275,12 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { return genesis } - private fun findField(clazz: Class<*>, fieldName: String): Field { - return try { - clazz.getDeclaredField(fieldName) - } catch (e: NoSuchFieldException) { - when (clazz.superclass == null) { - true -> throw e - false -> findField(clazz.superclass, fieldName) - } + private fun findField(clazz: Class<*>, fieldName: String): Field = try { + clazz.getDeclaredField(fieldName) + } catch (e: NoSuchFieldException) { + when (clazz.superclass == null) { + true -> throw e + false -> findField(clazz.superclass, fieldName) } } } diff --git a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaTest.kt b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaTest.kt index bbf6a4a54..f49265370 100644 --- a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaTest.kt +++ b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/IrohaTest.kt @@ -2,8 +2,9 @@ package jp.co.soramitsu.iroha2.testengine import jp.co.soramitsu.iroha2.client.Iroha2Client import jp.co.soramitsu.iroha2.generated.AccountId +import jp.co.soramitsu.iroha2.transaction.Instruction import jp.co.soramitsu.iroha2.transaction.TransactionBuilder -import kotlinx.coroutines.time.withTimeout +import kotlinx.coroutines.Deferred import org.junit.jupiter.api.Timeout import org.junit.jupiter.api.extension.ExtendWith import org.junit.jupiter.api.parallel.Execution @@ -29,15 +30,9 @@ abstract class IrohaTest( lateinit var account: AccountId lateinit var keyPair: KeyPair - suspend fun Iroha2Client.tx( - account: AccountId? = null, - keyPair: KeyPair? = null, - builder: TransactionBuilder.() -> Unit = {}, - ) = this.sendTransaction { - account(account ?: this@IrohaTest.account) - builder(this) - buildSigned(keyPair ?: this@IrohaTest.keyPair) - }.also { d -> - withTimeout(txTimeout) { d.await() } - } + suspend fun Iroha2Client.submitAs( + account: AccountId, + keyPair: KeyPair, + vararg instructions: Instruction, + ): Deferred = submit(TransactionBuilder(chain).addInstructions(*instructions).signAs(account, keyPair)) } diff --git a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/TestConsts.kt b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/TestConsts.kt index c17e8733b..3bb5a3fce 100644 --- a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/TestConsts.kt +++ b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/TestConsts.kt @@ -5,9 +5,16 @@ import jp.co.soramitsu.iroha2.asName import jp.co.soramitsu.iroha2.generated.AccountId import jp.co.soramitsu.iroha2.generated.AssetDefinitionId import jp.co.soramitsu.iroha2.generated.AssetId +import jp.co.soramitsu.iroha2.generated.BlockParameters +import jp.co.soramitsu.iroha2.generated.NonZeroOfu64 +import jp.co.soramitsu.iroha2.generated.Parameters +import jp.co.soramitsu.iroha2.generated.SmartContractParameters +import jp.co.soramitsu.iroha2.generated.SumeragiParameters +import jp.co.soramitsu.iroha2.generated.TransactionParameters import jp.co.soramitsu.iroha2.keyPairFromHex import jp.co.soramitsu.iroha2.publicKeyFromHex import jp.co.soramitsu.iroha2.toIrohaPublicKey +import java.math.BigInteger const val DEFAULT_DOMAIN = "wonderland" const val GENESIS_DOMAIN = "genesis" @@ -20,6 +27,30 @@ val GENESIS_ACCOUNT = AccountId(GENESIS_DOMAIN.asDomainId(), publicKeyFromHex(GE @JvmField val DEFAULT_DOMAIN_ID = DEFAULT_DOMAIN.asDomainId() +val DEFAULT_GENESIS_PARAMETERS = Parameters( + sumeragi = SumeragiParameters( + blockTimeMs = BigInteger.valueOf(2000), + commitTimeMs = BigInteger.valueOf(4000), + maxClockDriftMs = BigInteger.valueOf(1000), + ), + block = BlockParameters( + maxTransactions = NonZeroOfu64(BigInteger.valueOf(4096)), + ), + smartContract = SmartContractParameters( + fuel = NonZeroOfu64(BigInteger.valueOf(5500000000)), + memory = NonZeroOfu64(BigInteger.valueOf(55000000)), + ), + executor = SmartContractParameters( + fuel = NonZeroOfu64(BigInteger.valueOf(5500000000)), + memory = NonZeroOfu64(BigInteger.valueOf(55000000)), + ), + transaction = TransactionParameters( + maxInstructions = NonZeroOfu64(BigInteger.valueOf(4096)), + smartContractSize = NonZeroOfu64(BigInteger.valueOf(4194304)), + ), + custom = emptyMap(), +) + @JvmField val ALICE_KEYPAIR = keyPairFromHex( "CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03", diff --git a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/WithIroha.kt b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/WithIroha.kt index f0aa049d9..7efbc1179 100644 --- a/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/WithIroha.kt +++ b/modules/test-tools/src/main/kotlin/jp/co/soramitsu/iroha2/testengine/WithIroha.kt @@ -34,7 +34,6 @@ annotation class WithIroha( @Inherited annotation class WithIrohaManual( val apiUrls: Array = [], - val peerUrls: Array = [], val account: String = "", val publicKey: String = "", val privateKey: String = "", @@ -44,8 +43,9 @@ annotation class WithIrohaManual( /** * Empty genesis with no instructions */ -open class EmptyGenesis : Genesis( - RawGenesisTransaction(ChainId(UUID.randomUUID().toString()), EXECUTOR_FILE_NAME, emptyList(), emptyList(), emptyList()), -) +open class EmptyGenesis : + Genesis( + RawGenesisTransaction(ChainId(UUID.randomUUID().toString()), EXECUTOR_FILE_NAME, null, emptyList(), "", emptyList(), emptyList()), + ) const val IROHA_CONFIG_DELIMITER = "=" diff --git a/modules/test-tools/src/main/resources/executor.wasm b/modules/test-tools/src/main/resources/executor.wasm index f51b51123..11cc0f19f 100644 Binary files a/modules/test-tools/src/main/resources/executor.wasm and b/modules/test-tools/src/main/resources/executor.wasm differ diff --git a/modules/test-tools/src/main/resources/genesis.json b/modules/test-tools/src/main/resources/genesis.json index 8da79f092..1e0d19a67 100644 --- a/modules/test-tools/src/main/resources/genesis.json +++ b/modules/test-tools/src/main/resources/genesis.json @@ -1,59 +1,35 @@ { "chain": "00000000-0000-0000-0000-000000000000", - "executor": "./executor.wasm", - "parameters": [ - { - "Sumeragi": { - "BlockTimeMs": 2000 - } - }, - { - "Sumeragi": { - "CommitTimeMs": 4000 - } - }, - { - "Block": { - "MaxTransactions": 512 - } + "executor": "executor.wasm", + "parameters": { + "sumeragi": { + "block_time_ms": 2000, + "commit_time_ms": 4000, + "max_clock_drift_ms": 1000 }, - { - "Transaction": { - "MaxInstructions": 4096 - } + "block": { + "max_transactions": 512 }, - { - "Transaction": { - "SmartContractSize": 4194304 - } - }, - { - "Executor": { - "Fuel": 5500000000 - } + "transaction": { + "max_instructions": 4096, + "smart_contract_size": 4194304 }, - { - "Executor": { - "Memory": 550000000 - } + "executor": { + "fuel": 55000000, + "memory": 55000000 }, - { - "SmartContract": { - "Fuel": 5500000000 - } + "smart_contract": { + "fuel": 55000000, + "memory": 55000000 }, - { - "SmartContract": { - "Memory": 550000000 - } - } - ], + "custom": {} + }, "instructions": [ { "Register": { "Domain": { "id": "wonderland", - "logo": null, + "logo":null, "metadata": { "key": "value" } @@ -152,7 +128,7 @@ "id": "rose#wonderland", "type": "Numeric", "mintable": "Infinitely", - "logo": null, + "logo":null, "metadata": {} } } @@ -161,7 +137,7 @@ "Register": { "Domain": { "id": "garden_of_live_flowers", - "logo": null, + "logo":null, "metadata": {} } } @@ -180,7 +156,7 @@ "id": "cabbage#garden_of_live_flowers", "type": "Numeric", "mintable": "Infinitely", - "logo": null, + "logo":null, "metadata": {} } } @@ -236,18 +212,13 @@ "id": "ALICE_METADATA_ACCESS", "permissions": [ { - "name": "CanRemoveKeyValueInAccount", - "payload": { - "account": "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland" - } - }, - { - "name": "CanSetKeyValueInAccount", + "name": "CanModifyAccountMetadata", "payload": { "account": "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland" } } - ] + ], + "grant_to": "ed012004FF5B81046DDCCF19E2E451C45DFB6F53759D4EB30FA2EFA807284D1CC33016@wonderland" } } }, @@ -285,5 +256,7 @@ } } ], + "wasm_dir": "libs", + "wasm_triggers": [], "topology": [] } diff --git a/modules/test-tools/src/main/resources/genesis2.json b/modules/test-tools/src/main/resources/genesis2.json index 2221f050f..43eef77f0 100644 --- a/modules/test-tools/src/main/resources/genesis2.json +++ b/modules/test-tools/src/main/resources/genesis2.json @@ -1,7 +1,29 @@ { "chain": "00000000-0000-0000-0000-000000000000", - "executor": "./executor.wasm", - "parameters": [], + "executor": "executor.wasm", + "parameters": { + "sumeragi": { + "block_time_ms": 1, + "commit_time_ms": 2, + "max_clock_drift_ms": 3 + }, + "block": { + "max_transactions": 4 + }, + "transaction": { + "max_instructions": 5, + "smart_contract_size": 6 + }, + "executor": { + "fuel": 7, + "memory": 8 + }, + "smart_contract": { + "fuel": 9, + "memory": 10 + }, + "custom": {} + }, "instructions": [ { "Register": { @@ -139,7 +161,7 @@ "Asset": { "object": "123#test#ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland", "key": "id", - "value": "123" + "value": 123 } } }, @@ -148,7 +170,7 @@ "Asset": { "object": "123#test#ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland", "key": "wt", - "value": "123" + "value": 123 } } }, @@ -184,7 +206,7 @@ "Asset": { "object": "123#test#ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland", "key": "ef", - "value": "1234" + "value": 1234 } } }, @@ -193,7 +215,7 @@ "Asset": { "object": "123#test#ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland", "key": "cd", - "value": "123" + "value": 123 } } }, @@ -202,7 +224,7 @@ "Asset": { "object": "123#test#ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland", "key": "ab", - "value": "false" + "value": false } } }, @@ -210,7 +232,7 @@ "Grant": { "Permission": { "object": { - "name": "CanSetKeyValueInUserAssets", + "name": "CanModifyAssetMetadata", "payload": { "asset": "123#test#ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland" } @@ -220,5 +242,7 @@ } } ], + "wasm_dir": "libs", + "wasm_triggers": [], "topology": [] } diff --git a/modules/test-tools/src/main/resources/genesis3.json b/modules/test-tools/src/main/resources/genesis3.json index b69226262..91dbdfd76 100644 --- a/modules/test-tools/src/main/resources/genesis3.json +++ b/modules/test-tools/src/main/resources/genesis3.json @@ -1,7 +1,29 @@ { "chain": "00000000-0000-0000-0000-000000000000", - "executor": "./executor.wasm", - "parameters": [], + "executor": "executor.wasm", + "parameters": { + "sumeragi": { + "block_time_ms": 1, + "commit_time_ms": 2, + "max_clock_drift_ms": 3 + }, + "block": { + "max_transactions": 4 + }, + "transaction": { + "max_instructions": 5, + "smart_contract_size": 6 + }, + "executor": { + "fuel": 7, + "memory": 8 + }, + "smart_contract": { + "fuel": 9, + "memory": 10 + }, + "custom": {} + }, "instructions": [ { "Register": { @@ -107,18 +129,13 @@ "id": "USER_METADATA_ACCESS", "permissions": [ { - "name": "CanSetKeyValueInUserAsset", - "payload": { - "account": "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland" - } - }, - { - "name": "CanRemoveKeyValueInUserAsset", + "name": "CanModifyAssetMetadata", "payload": { "account": "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland" } } - ] + ], + "grant_to": "ed012004FF5B81046DDCCF19E2E451C45DFB6F53759D4EB30FA2EFA807284D1CC33016@wonderland" } } }, @@ -157,7 +174,7 @@ "Asset": { "object": "foo#wonderland#ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland", "key": "key2", - "value": "123" + "value": 123 } } }, @@ -186,5 +203,7 @@ } } ], + "wasm_dir": "libs", + "wasm_triggers": [], "topology": [] }